sw/source/core/unocore/unocoll.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <config_features.h>
  21
  22 #include <hintids.hxx>
  23 #include <doc.hxx>
  24 #include <IDocumentChartDataProviderAccess.hxx>
  25 #include <IDocumentFieldsAccess.hxx>
  26 #include <docary.hxx>
  27 #include <unocoll.hxx>
  28 #include <unosett.hxx>
  29 #include <section.hxx>
  30 #include <IMark.hxx>
  31 #include <ftnidx.hxx>
  32 #include <fmtftn.hxx>
  33 #include <txtftn.hxx>
  34 #include <com/sun/star/text/XTextTable.hpp>
  35 #include <o3tl/safeint.hxx>
  36 #include <o3tl/string_view.hxx>
  37 #include <svtools/unoimap.hxx>
  38 #include <svtools/unoevent.hxx>
  39 #include <svx/SvxXTextColumns.hxx>
  40 #include <unotbl.hxx>
  41 #include <unostyle.hxx>
  42 #include <unofield.hxx>
  43 #include <unoidx.hxx>
  44 #include <unoframe.hxx>
  45 #include <textboxhelper.hxx>
  46 #include <unofootnote.hxx>
  47 #include <unolinebreak.hxx>
  48 #include <unoport.hxx>
  49 #include <vcl/svapp.hxx>
  50 #include <fmtcntnt.hxx>
  51 #include <authfld.hxx>
  52 #include <SwXTextDefaults.hxx>
  53 #include <unochart.hxx>
  54 #include <comphelper/sequence.hxx>
  55 #include <cppuhelper/supportsservice.hxx>
  56 #include <unosection.hxx>
  57 #include <unoparagraph.hxx>
  58 #include <unobookmark.hxx>
  59 #include <unorefmark.hxx>
  60 #include <unometa.hxx>
  61 #include <unocontentcontrol.hxx>
  62 #include <docsh.hxx>
  63 #include <hints.hxx>
  64 #include <frameformats.hxx>
  65 #include <com/sun/star/document/XCodeNameQuery.hpp>
  66 #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
  67 #include <com/sun/star/form/XFormsSupplier.hpp>
  68 #include <com/sun/star/script/ModuleInfo.hpp>
  69 #include <com/sun/star/script/ModuleType.hpp>
  70 #include <com/sun/star/script/vba/XVBAModuleInfo.hpp>
  71 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  72 #include <vbahelper/vbaaccesshelper.hxx>
  73 #include <basic/basmgr.hxx>
  74 #include <comphelper/processfactory.hxx>
  75 #include <cppuhelper/implbase.hxx>
  76 #include <sfx2/event.hxx>
  77 #include <sal/log.hxx>
  78 #include <tools/debug.hxx>
  79
  80 using namespace ::com::sun::star;
  81 using namespace ::com::sun::star::document;
  82 using namespace ::com::sun::star::uno;
  83 using namespace ::com::sun::star::text;
  84 using namespace ::com::sun::star::container;
  85 using namespace ::com::sun::star::lang;
  86
  87 #if HAVE_FEATURE_SCRIPTING
  88
  89 namespace {
  90
  91 class SwVbaCodeNameProvider : public ::cppu::WeakImplHelper< document::XCodeNameQuery >
  92 {
  93     SwDocShell* mpDocShell;
  94     OUString msThisDocumentCodeName;
  95 public:
  96     explicit SwVbaCodeNameProvider( SwDocShell* pDocShell ) : mpDocShell( pDocShell ) {}
  97         // XCodeNameQuery
  98
  99     OUString SAL_CALL getCodeNameForContainer( const uno::Reference< uno::XInterface >& /*xIf*/ ) override
 100     {
 101         // #FIXME not implemented...
 102         return OUString();
 103     }
 104
 105     OUString SAL_CALL getCodeNameForObject( const uno::Reference< uno::XInterface >& xIf ) override
 106     {
 107         // Initialise the code name
 108         if ( msThisDocumentCodeName.isEmpty() )
 109         {
 110             try
 111             {
 112                 uno::Reference< beans::XPropertySet > xProps( mpDocShell->GetModel(), uno::UNO_QUERY_THROW );
 113                 uno::Reference< container::XNameAccess > xLibContainer( xProps->getPropertyValue(u"BasicLibraries"_ustr), uno::UNO_QUERY_THROW );
 114                 OUString sProjectName( u"Standard"_ustr);
 115                 if ( !mpDocShell->GetBasicManager()->GetName().isEmpty() )
 116                 {
 117                     sProjectName =  mpDocShell->GetBasicManager()->GetName();
 118                 }
 119                 uno::Reference< container::XNameAccess > xLib( xLibContainer->getByName( sProjectName ), uno::UNO_QUERY_THROW );
 120                 const uno::Sequence< OUString > sModuleNames = xLib->getElementNames();
 121                 uno::Reference< script::vba::XVBAModuleInfo > xVBAModuleInfo( xLib, uno::UNO_QUERY );
 122
 123                 auto pModuleName = std::find_if(sModuleNames.begin(), sModuleNames.end(), [&xVBAModuleInfo](const OUString& rName) {
 124                     return xVBAModuleInfo->hasModuleInfo(rName)
 125                         && xVBAModuleInfo->getModuleInfo(rName).ModuleType == script::ModuleType::DOCUMENT; });
 126                 if (pModuleName != sModuleNames.end())
 127                     msThisDocumentCodeName = *pModuleName;
 128             }
 129             catch( uno::Exception& )
 130             {
 131             }
 132         }
 133         OUString sCodeName;
 134         if ( mpDocShell )
 135         {
 136             // need to find the page ( and index )  for this control
 137             uno::Reference< drawing::XDrawPageSupplier > xSupplier( mpDocShell->GetModel(), uno::UNO_QUERY_THROW );
 138             uno::Reference< container::XIndexAccess > xIndex( xSupplier->getDrawPage(), uno::UNO_QUERY_THROW );
 139
 140             try
 141             {
 142                 uno::Reference< form::XFormsSupplier >  xFormSupplier( xIndex, uno::UNO_QUERY_THROW );
 143                 uno::Reference< container::XIndexAccess > xFormIndex( xFormSupplier->getForms(), uno::UNO_QUERY_THROW );
 144                 // get the www-standard container
 145                 uno::Reference< container::XIndexAccess > xFormControls( xFormIndex->getByIndex(0), uno::UNO_QUERY_THROW );
 146                 sal_Int32 nCntrls = xFormControls->getCount();
 147                 for( sal_Int32 cIndex = 0; cIndex < nCntrls; ++cIndex )
 148                 {
 149                     uno::Reference< uno::XInterface > xControl( xFormControls->getByIndex( cIndex ), uno::UNO_QUERY_THROW );
 150                     bool bMatched = ( xControl == xIf );
 151                     if ( bMatched )
 152                     {
 153                         sCodeName = msThisDocumentCodeName;
 154                         break;
 155                     }
 156                 }
 157             }
 158             catch( uno::Exception& )
 159             {
 160             }
 161         }
 162         // #TODO Probably should throw here ( if !bMatched )
 163         return sCodeName;
 164     }
 165 };
 166
 167 }
 168
 169 typedef std::unordered_map< OUString, OUString > StringHashMap;
 170
 171 namespace {
 172
 173 class SwVbaProjectNameProvider : public ::cppu::WeakImplHelper< container::XNameContainer >
 174 {
 175     StringHashMap mTemplateToProject;
 176 public:
 177     SwVbaProjectNameProvider()
 178     {
 179     }
 180     virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override
 181     {
 182         return ( mTemplateToProject.find( aName ) != mTemplateToProject.end() );
 183     }
 184     virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override
 185     {
 186         if ( !hasByName( aName ) )
 187             throw container::NoSuchElementException();
 188         return uno::Any( mTemplateToProject.find( aName )->second );
 189     }
 190     virtual css::uno::Sequence< OUString > SAL_CALL getElementNames(  ) override
 191     {
 192         return comphelper::mapKeysToSequence( mTemplateToProject );
 193     }
 194
 195     virtual void SAL_CALL insertByName( const OUString& aName, const uno::Any& aElement ) override
 196     {
 197
 198         OUString sProjectName;
 199         aElement >>= sProjectName;
 200         SAL_INFO("sw.uno", "Template cache inserting template name " << aName
 201                 << " with project " << sProjectName);
 202         mTemplateToProject[ aName ] = sProjectName;
 203     }
 204
 205     virtual void SAL_CALL removeByName( const OUString& Name ) override
 206     {
 207         if ( !hasByName( Name ) )
 208             throw container::NoSuchElementException();
 209         mTemplateToProject.erase( Name );
 210     }
 211     virtual void SAL_CALL replaceByName( const OUString& aName, const uno::Any& aElement ) override
 212     {
 213         if ( !hasByName( aName ) )
 214             throw container::NoSuchElementException();
 215         insertByName( aName, aElement ); // insert will overwrite
 216     }
 217     // XElemenAccess
 218     virtual css::uno::Type SAL_CALL getElementType(  ) override
 219     {
 220         return ::cppu::UnoType<OUString>::get();
 221     }
 222     virtual sal_Bool SAL_CALL hasElements(  ) override
 223     {
 224
 225         return ( !mTemplateToProject.empty() );
 226     }
 227
 228 };
 229
 230 class SwVbaObjectForCodeNameProvider : public ::cppu::WeakImplHelper< container::XNameAccess >
 231 {
 232     SwDocShell* mpDocShell;
 233 public:
 234     explicit SwVbaObjectForCodeNameProvider( SwDocShell* pDocShell ) : mpDocShell( pDocShell )
 235     {
 236         // #FIXME #TODO is the code name for ThisDocument read anywhere?
 237     }
 238
 239     virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override
 240     {
 241         // #FIXME #TODO we really need to be checking against the codename for
 242         // ThisDocument
 243         if ( aName == "ThisDocument" )
 244             return true;
 245         return false;
 246     }
 247
 248     css::uno::Any SAL_CALL getByName( const OUString& aName ) override
 249     {
 250         if ( !hasByName( aName ) )
 251              throw container::NoSuchElementException();
 252         uno::Sequence< uno::Any > aArgs{ uno::Any(uno::Reference< uno::XInterface >()),
 253                                          uno::Any(mpDocShell->GetModel()) };
 254         uno::Reference< uno::XInterface > xDocObj = ooo::vba::createVBAUnoAPIServiceWithArgs( mpDocShell, "ooo.vba.word.Document" , aArgs );
 255         SAL_INFO("sw.uno",
 256             "Creating Object ( ooo.vba.word.Document ) 0x" << xDocObj.get());
 257         return  uno::Any( xDocObj );
 258     }
 259     virtual css::uno::Sequence< OUString > SAL_CALL getElementNames(  ) override
 260     {
 261         uno::Sequence< OUString > aNames;
 262         return aNames;
 263     }
 264     // XElemenAccess
 265     virtual css::uno::Type SAL_CALL getElementType(  ) override { return uno::Type(); }
 266     virtual sal_Bool SAL_CALL hasElements(  ) override { return true; }
 267
 268 };
 269
 270 }
 271
 272 #endif
 273
 274 namespace {
 275
 276 struct  ProvNamesId_Type
 277 {
 278     const char *    pName;
 279     SwServiceType   nType;
 280 };
 281
 282 }
 283
 284 // note: this thing is indexed as an array, so do not insert/remove entries!
 285 const ProvNamesId_Type aProvNamesId[] =
 286 {
 287     { "com.sun.star.text.TextTable",                          SwServiceType::TypeTextTable },
 288     { "com.sun.star.text.TextFrame",                          SwServiceType::TypeTextFrame },
 289     { "com.sun.star.text.GraphicObject",                      SwServiceType::TypeGraphic },
 290     { "com.sun.star.text.TextEmbeddedObject",                 SwServiceType::TypeOLE },
 291     { "com.sun.star.text.Bookmark",                           SwServiceType::TypeBookmark },
 292     { "com.sun.star.text.Footnote",                           SwServiceType::TypeFootnote },
 293     { "com.sun.star.text.Endnote",                            SwServiceType::TypeEndnote },
 294     { "com.sun.star.text.DocumentIndexMark",                  SwServiceType::TypeIndexMark },
 295     { "com.sun.star.text.DocumentIndex",                      SwServiceType::TypeIndex },
 296     { "com.sun.star.text.ReferenceMark",                      SwServiceType::ReferenceMark },
 297     { "com.sun.star.style.CharacterStyle",                    SwServiceType::StyleCharacter },
 298     { "com.sun.star.style.ParagraphStyle",                    SwServiceType::StyleParagraph },
 299     { "com.sun.star.style.FrameStyle",                        SwServiceType::StyleFrame },
 300     { "com.sun.star.style.PageStyle",                         SwServiceType::StylePage },
 301     { "com.sun.star.style.NumberingStyle",                    SwServiceType::StyleNumbering },
 302     { "com.sun.star.text.ContentIndexMark",                   SwServiceType::ContentIndexMark },
 303     { "com.sun.star.text.ContentIndex",                       SwServiceType::ContentIndex },
 304     { "com.sun.star.text.UserIndexMark",                      SwServiceType::UserIndexMark },
 305     { "com.sun.star.text.UserIndex",                          SwServiceType::UserIndex },
 306     { "com.sun.star.text.TextSection",                        SwServiceType::TextSection },
 307     { "com.sun.star.text.TextField.DateTime",                 SwServiceType::FieldTypeDateTime },
 308     { "com.sun.star.text.TextField.User",                     SwServiceType::FieldTypeUser },
 309     { "com.sun.star.text.TextField.SetExpression",            SwServiceType::FieldTypeSetExp },
 310     { "com.sun.star.text.TextField.GetExpression",            SwServiceType::FieldTypeGetExp },
 311     { "com.sun.star.text.TextField.FileName",                 SwServiceType::FieldTypeFileName },
 312     { "com.sun.star.text.TextField.PageNumber",               SwServiceType::FieldTypePageNum },
 313     { "com.sun.star.text.TextField.Author",                   SwServiceType::FieldTypeAuthor },
 314     { "com.sun.star.text.TextField.Chapter",                  SwServiceType::FieldTypeChapter },
 315     { "",                                                     SwServiceType::FieldTypeDummy0 },
 316     { "com.sun.star.text.TextField.GetReference",             SwServiceType::FieldTypeGetReference },
 317     { "com.sun.star.text.TextField.ConditionalText",          SwServiceType::FieldTypeConditionedText },
 318     { "com.sun.star.text.TextField.Annotation",               SwServiceType::FieldTypeAnnotation },
 319     { "com.sun.star.text.TextField.Input",                    SwServiceType::FieldTypeInput },
 320     { "com.sun.star.text.TextField.Macro",                    SwServiceType::FieldTypeMacro },
 321     { "com.sun.star.text.TextField.DDE",                      SwServiceType::FieldTypeDDE },
 322     { "com.sun.star.text.TextField.HiddenParagraph",          SwServiceType::FieldTypeHiddenPara },
 323     { "" /*com.sun.star.text.TextField.DocumentInfo"*/,       SwServiceType::FieldTypeDocInfo },
 324     { "com.sun.star.text.TextField.TemplateName",             SwServiceType::FieldTypeTemplateName },
 325     { "com.sun.star.text.TextField.ExtendedUser",             SwServiceType::FieldTypeUserExt },
 326     { "com.sun.star.text.TextField.ReferencePageSet",         SwServiceType::FieldTypeRefPageSet },
 327     { "com.sun.star.text.TextField.ReferencePageGet",         SwServiceType::FieldTypeRefPageGet },
 328     { "com.sun.star.text.TextField.JumpEdit",                 SwServiceType::FieldTypeJumpEdit },
 329     { "com.sun.star.text.TextField.Script",                   SwServiceType::FieldTypeScript },
 330     { "com.sun.star.text.TextField.DatabaseNextSet",          SwServiceType::FieldTypeDatabaseNextSet },
 331     { "com.sun.star.text.TextField.DatabaseNumberOfSet",      SwServiceType::FieldTypeDatabaseNumSet },
 332     { "com.sun.star.text.TextField.DatabaseSetNumber",        SwServiceType::FieldTypeDatabaseSetNum },
 333     { "com.sun.star.text.TextField.Database",                 SwServiceType::FieldTypeDatabase },
 334     { "com.sun.star.text.TextField.DatabaseName",             SwServiceType::FieldTypeDatabaseName },
 335     { "com.sun.star.text.TextField.TableFormula",             SwServiceType::FieldTypeTableFormula },
 336     { "com.sun.star.text.TextField.PageCount",                SwServiceType::FieldTypePageCount },
 337     { "com.sun.star.text.TextField.ParagraphCount",           SwServiceType::FieldTypeParagraphCount },
 338     { "com.sun.star.text.TextField.WordCount",                SwServiceType::FieldTypeWordCount },
 339     { "com.sun.star.text.TextField.CharacterCount",           SwServiceType::FieldTypeCharacterCount },
 340     { "com.sun.star.text.TextField.TableCount",               SwServiceType::FieldTypeTableCount },
 341     { "com.sun.star.text.TextField.GraphicObjectCount",       SwServiceType::FieldTypeGraphicObjectCount },
 342     { "com.sun.star.text.TextField.EmbeddedObjectCount",      SwServiceType::FieldTypeEmbeddedObjectCount },
 343     { "com.sun.star.text.TextField.DocInfo.ChangeAuthor",     SwServiceType::FieldTypeDocInfoChangeAuthor },
 344     { "com.sun.star.text.TextField.DocInfo.ChangeDateTime",   SwServiceType::FieldTypeDocInfoChangeDateTime },
 345     { "com.sun.star.text.TextField.DocInfo.EditTime",         SwServiceType::FieldTypeDocInfoEditTime },
 346     { "com.sun.star.text.TextField.DocInfo.Description",      SwServiceType::FieldTypeDocInfoDescription },
 347     { "com.sun.star.text.TextField.DocInfo.CreateAuthor",     SwServiceType::FieldTypeDocInfoCreateAuthor },
 348     { "com.sun.star.text.TextField.DocInfo.CreateDateTime",   SwServiceType::FieldTypeDocInfoCreateDateTime },
 349     { "",                                                     SwServiceType::FieldTypeDummy0 },
 350     { "",                                                     SwServiceType::FieldTypeDummy1 },
 351     { "",                                                     SwServiceType::FieldTypeDummy2 },
 352     { "",                                                     SwServiceType::FieldTypeDummy3 },
 353     { "com.sun.star.text.TextField.DocInfo.Custom",           SwServiceType::FieldTypeDocInfoCustom },
 354     { "com.sun.star.text.TextField.DocInfo.PrintAuthor",      SwServiceType::FieldTypeDocInfoPrintAuthor },
 355     { "com.sun.star.text.TextField.DocInfo.PrintDateTime",    SwServiceType::FieldTypeDocInfoPrintDateTime },
 356     { "com.sun.star.text.TextField.DocInfo.KeyWords",         SwServiceType::FieldTypeDocInfoKeywords },
 357     { "com.sun.star.text.TextField.DocInfo.Subject",          SwServiceType::FieldTypeDocInfoSubject },
 358     { "com.sun.star.text.TextField.DocInfo.Title",            SwServiceType::FieldTypeDocInfoTitle },
 359     { "com.sun.star.text.TextField.DocInfo.Revision",         SwServiceType::FieldTypeDocInfoRevision },
 360     { "com.sun.star.text.TextField.Bibliography",             SwServiceType::FieldTypeBibliography },
 361     { "com.sun.star.text.TextField.CombinedCharacters",       SwServiceType::FieldTypeCombinedCharacters },
 362     { "com.sun.star.text.TextField.DropDown",                 SwServiceType::FieldTypeDropdown },
 363     { "com.sun.star.text.textfield.MetadataField",            SwServiceType::FieldTypeMetafield },
 364     { "",                                                     SwServiceType::FieldTypeDummy4 },
 365     { "",                                                     SwServiceType::FieldTypeDummy5 },
 366     { "",                                                     SwServiceType::FieldTypeDummy6 },
 367     { "",                                                     SwServiceType::FieldTypeDummy7 },
 368     { "com.sun.star.text.FieldMaster.User",                   SwServiceType::FieldMasterUser },
 369     { "com.sun.star.text.FieldMaster.DDE",                    SwServiceType::FieldMasterDDE },
 370     { "com.sun.star.text.FieldMaster.SetExpression",          SwServiceType::FieldMasterSetExp },
 371     { "com.sun.star.text.FieldMaster.Database",               SwServiceType::FieldMasterDatabase },
 372     { "com.sun.star.text.FieldMaster.Bibliography",           SwServiceType::FieldMasterBibliography },
 373     { "",                                                     SwServiceType::FieldMasterDummy2 },
 374     { "",                                                     SwServiceType::FieldMasterDummy3 },
 375     { "",                                                     SwServiceType::FieldMasterDummy4 },
 376     { "",                                                     SwServiceType::FieldMasterDummy5 },
 377     { "com.sun.star.text.IllustrationsIndex",                 SwServiceType::IndexIllustrations },
 378     { "com.sun.star.text.ObjectIndex",                        SwServiceType::IndexObjects },
 379     { "com.sun.star.text.TableIndex",                         SwServiceType::IndexTables },
 380     { "com.sun.star.text.Bibliography",                       SwServiceType::IndexBibliography },
 381     { "com.sun.star.text.Paragraph",                          SwServiceType::Paragraph },
 382     { "com.sun.star.text.TextField.InputUser",                SwServiceType::FieldTypeInputUser },
 383     { "com.sun.star.text.TextField.HiddenText",               SwServiceType::FieldTypeHiddenText },
 384     { "com.sun.star.style.ConditionalParagraphStyle",         SwServiceType::StyleConditionalParagraph },
 385     { "com.sun.star.text.NumberingRules",                     SwServiceType::NumberingRules },
 386     { "com.sun.star.text.TextColumns",                        SwServiceType::TextColumns },
 387     { "com.sun.star.text.IndexHeaderSection",                 SwServiceType::IndexHeaderSection },
 388     { "com.sun.star.text.Defaults",                           SwServiceType::Defaults },
 389     { "com.sun.star.image.ImageMapRectangleObject",           SwServiceType::IMapRectangle },
 390     { "com.sun.star.image.ImageMapCircleObject",              SwServiceType::IMapCircle },
 391     { "com.sun.star.image.ImageMapPolygonObject",             SwServiceType::IMapPolygon },
 392     { "com.sun.star.text.TextGraphicObject",                  SwServiceType::TypeTextGraphic },
 393     { "com.sun.star.chart2.data.DataProvider",                SwServiceType::Chart2DataProvider },
 394     { "com.sun.star.text.Fieldmark",                          SwServiceType::TypeFieldMark },
 395     { "com.sun.star.text.FormFieldmark",                      SwServiceType::TypeFormFieldMark },
 396     { "com.sun.star.text.InContentMetadata",                  SwServiceType::TypeMeta },
 397     { "ooo.vba.VBAObjectModuleObjectProvider",                SwServiceType::VbaObjectProvider },
 398     { "ooo.vba.VBACodeNameProvider",                          SwServiceType::VbaCodeNameProvider },
 399     { "ooo.vba.VBAProjectNameProvider",                       SwServiceType::VbaProjectNameProvider },
 400     { "ooo.vba.VBAGlobals",                       SwServiceType::VbaGlobals },
 401
 402     // case-correct versions of the service names (see #i67811)
 403     { CSS_TEXT_TEXTFIELD_DATE_TIME,                   SwServiceType::FieldTypeDateTime },
 404     { CSS_TEXT_TEXTFIELD_USER,                        SwServiceType::FieldTypeUser },
 405     { CSS_TEXT_TEXTFIELD_SET_EXPRESSION,              SwServiceType::FieldTypeSetExp },
 406     { CSS_TEXT_TEXTFIELD_GET_EXPRESSION,              SwServiceType::FieldTypeGetExp },
 407     { CSS_TEXT_TEXTFIELD_FILE_NAME,                   SwServiceType::FieldTypeFileName },
 408     { CSS_TEXT_TEXTFIELD_PAGE_NUMBER,                 SwServiceType::FieldTypePageNum },
 409     { CSS_TEXT_TEXTFIELD_AUTHOR,                      SwServiceType::FieldTypeAuthor },
 410     { CSS_TEXT_TEXTFIELD_CHAPTER,                     SwServiceType::FieldTypeChapter },
 411     { CSS_TEXT_TEXTFIELD_GET_REFERENCE,               SwServiceType::FieldTypeGetReference },
 412     { CSS_TEXT_TEXTFIELD_CONDITIONAL_TEXT,            SwServiceType::FieldTypeConditionedText },
 413     { CSS_TEXT_TEXTFIELD_ANNOTATION,                  SwServiceType::FieldTypeAnnotation },
 414     { CSS_TEXT_TEXTFIELD_INPUT,                       SwServiceType::FieldTypeInput },
 415     { CSS_TEXT_TEXTFIELD_MACRO,                       SwServiceType::FieldTypeMacro },
 416     { CSS_TEXT_TEXTFIELD_DDE,                         SwServiceType::FieldTypeDDE },
 417     { CSS_TEXT_TEXTFIELD_HIDDEN_PARAGRAPH,            SwServiceType::FieldTypeHiddenPara },
 418     { CSS_TEXT_TEXTFIELD_TEMPLATE_NAME,               SwServiceType::FieldTypeTemplateName },
 419     { CSS_TEXT_TEXTFIELD_EXTENDED_USER,               SwServiceType::FieldTypeUserExt },
 420     { CSS_TEXT_TEXTFIELD_REFERENCE_PAGE_SET,          SwServiceType::FieldTypeRefPageSet },
 421     { CSS_TEXT_TEXTFIELD_REFERENCE_PAGE_GET,          SwServiceType::FieldTypeRefPageGet },
 422     { CSS_TEXT_TEXTFIELD_JUMP_EDIT,                   SwServiceType::FieldTypeJumpEdit },
 423     { CSS_TEXT_TEXTFIELD_SCRIPT,                      SwServiceType::FieldTypeScript },
 424     { CSS_TEXT_TEXTFIELD_DATABASE_NEXT_SET,           SwServiceType::FieldTypeDatabaseNextSet },
 425     { CSS_TEXT_TEXTFIELD_DATABASE_NUMBER_OF_SET,      SwServiceType::FieldTypeDatabaseNumSet },
 426     { CSS_TEXT_TEXTFIELD_DATABASE_SET_NUMBER,         SwServiceType::FieldTypeDatabaseSetNum },
 427     { CSS_TEXT_TEXTFIELD_DATABASE,                    SwServiceType::FieldTypeDatabase },
 428     { CSS_TEXT_TEXTFIELD_DATABASE_NAME,               SwServiceType::FieldTypeDatabaseName },
 429     { CSS_TEXT_TEXTFIELD_TABLE_FORMULA,               SwServiceType::FieldTypeTableFormula },
 430     { CSS_TEXT_TEXTFIELD_PAGE_COUNT,                  SwServiceType::FieldTypePageCount },
 431     { CSS_TEXT_TEXTFIELD_PARAGRAPH_COUNT,             SwServiceType::FieldTypeParagraphCount },
 432     { CSS_TEXT_TEXTFIELD_WORD_COUNT,                  SwServiceType::FieldTypeWordCount },
 433     { CSS_TEXT_TEXTFIELD_CHARACTER_COUNT,             SwServiceType::FieldTypeCharacterCount },
 434     { CSS_TEXT_TEXTFIELD_TABLE_COUNT,                 SwServiceType::FieldTypeTableCount },
 435     { CSS_TEXT_TEXTFIELD_GRAPHIC_OBJECT_COUNT,        SwServiceType::FieldTypeGraphicObjectCount },
 436     { CSS_TEXT_TEXTFIELD_EMBEDDED_OBJECT_COUNT,       SwServiceType::FieldTypeEmbeddedObjectCount },
 437     { CSS_TEXT_TEXTFIELD_DOCINFO_CHANGE_AUTHOR,       SwServiceType::FieldTypeDocInfoChangeAuthor },
 438     { CSS_TEXT_TEXTFIELD_DOCINFO_CHANGE_DATE_TIME,    SwServiceType::FieldTypeDocInfoChangeDateTime },
 439     { CSS_TEXT_TEXTFIELD_DOCINFO_EDIT_TIME,           SwServiceType::FieldTypeDocInfoEditTime },
 440     { CSS_TEXT_TEXTFIELD_DOCINFO_DESCRIPTION,         SwServiceType::FieldTypeDocInfoDescription },
 441     { CSS_TEXT_TEXTFIELD_DOCINFO_CREATE_AUTHOR,       SwServiceType::FieldTypeDocInfoCreateAuthor },
 442     { CSS_TEXT_TEXTFIELD_DOCINFO_CREATE_DATE_TIME,    SwServiceType::FieldTypeDocInfoCreateDateTime },
 443     { CSS_TEXT_TEXTFIELD_DOCINFO_PRINT_AUTHOR,        SwServiceType::FieldTypeDocInfoPrintAuthor },
 444     { CSS_TEXT_TEXTFIELD_DOCINFO_PRINT_DATE_TIME,     SwServiceType::FieldTypeDocInfoPrintDateTime },
 445     { CSS_TEXT_TEXTFIELD_DOCINFO_KEY_WORDS,           SwServiceType::FieldTypeDocInfoKeywords },
 446     { CSS_TEXT_TEXTFIELD_DOCINFO_SUBJECT,             SwServiceType::FieldTypeDocInfoSubject },
 447     { CSS_TEXT_TEXTFIELD_DOCINFO_TITLE,               SwServiceType::FieldTypeDocInfoTitle },
 448     { CSS_TEXT_TEXTFIELD_DOCINFO_REVISION,            SwServiceType::FieldTypeDocInfoRevision },
 449     { CSS_TEXT_TEXTFIELD_DOCINFO_CUSTOM,              SwServiceType::FieldTypeDocInfoCustom },
 450     { CSS_TEXT_TEXTFIELD_BIBLIOGRAPHY,                SwServiceType::FieldTypeBibliography },
 451     { CSS_TEXT_TEXTFIELD_COMBINED_CHARACTERS,         SwServiceType::FieldTypeCombinedCharacters },
 452     { CSS_TEXT_TEXTFIELD_DROP_DOWN,                   SwServiceType::FieldTypeDropdown },
 453     { CSS_TEXT_TEXTFIELD_INPUT_USER,                  SwServiceType::FieldTypeInputUser },
 454     { CSS_TEXT_TEXTFIELD_HIDDEN_TEXT,                 SwServiceType::FieldTypeHiddenText },
 455     { CSS_TEXT_FIELDMASTER_USER,                      SwServiceType::FieldMasterUser },
 456     { CSS_TEXT_FIELDMASTER_DDE,                       SwServiceType::FieldMasterDDE },
 457     { CSS_TEXT_FIELDMASTER_SET_EXPRESSION,            SwServiceType::FieldMasterSetExp },
 458     { CSS_TEXT_FIELDMASTER_DATABASE,                  SwServiceType::FieldMasterDatabase },
 459     { CSS_TEXT_FIELDMASTER_BIBLIOGRAPHY,              SwServiceType::FieldMasterBibliography },
 460     { "com.sun.star.style.TableStyle",                SwServiceType::StyleTable },
 461     { "com.sun.star.style.CellStyle",                 SwServiceType::StyleCell },
 462     { "com.sun.star.text.LineBreak",                  SwServiceType::LineBreak },
 463     { "com.sun.star.text.ContentControl",             SwServiceType::ContentControl }
 464 };
 465
 466 const SvEventDescription* sw_GetSupportedMacroItems()
 467 {
 468     static const SvEventDescription aMacroDescriptionsImpl[] =
 469     {
 470         { SvMacroItemId::OnMouseOver, "OnMouseOver" },
 471         { SvMacroItemId::OnMouseOut,  "OnMouseOut" },
 472         { SvMacroItemId::NONE, nullptr }
 473     };
 474
 475     return aMacroDescriptionsImpl;
 476 }
 477
 478 OUString SwXServiceProvider::GetProviderName(SwServiceType nObjectType)
 479 {
 480     OUString sRet;
 481     const sal_uInt16 nEntries = SAL_N_ELEMENTS(aProvNamesId);
 482     if(static_cast<sal_uInt16>(nObjectType) < nEntries)
 483         sRet = OUString::createFromAscii(aProvNamesId[static_cast<sal_uInt16>(nObjectType)].pName);
 484     return sRet;
 485 }
 486
 487 uno::Sequence<OUString>     SwXServiceProvider::GetAllServiceNames()
 488 {
 489     const sal_uInt16 nEntries = SAL_N_ELEMENTS(aProvNamesId);
 490     uno::Sequence<OUString> aRet(nEntries);
 491     OUString* pArray = aRet.getArray();
 492     sal_uInt16 n = 0;
 493     for(const ProvNamesId_Type & i : aProvNamesId)
 494     {
 495         OUString sProv(OUString::createFromAscii(i.pName));
 496         if(!sProv.isEmpty())
 497         {
 498             pArray[n] = sProv;
 499             n++;
 500         }
 501     }
 502     aRet.realloc(n);
 503     return aRet;
 504
 505 }
 506
 507 SwServiceType  SwXServiceProvider::GetProviderType(std::u16string_view rServiceName)
 508 {
 509     for(const ProvNamesId_Type & i : aProvNamesId)
 510     {
 511         if (o3tl::equalsAscii(rServiceName, i.pName))
 512             return i.nType;
 513     }
 514     return SwServiceType::Invalid;
 515 }
 516
 517 uno::Reference<uno::XInterface>
 518 SwXServiceProvider::MakeInstance(SwServiceType nObjectType, SwDoc & rDoc)
 519 {
 520     SolarMutexGuard aGuard;
 521     uno::Reference< uno::XInterface >  xRet;
 522     switch(nObjectType)
 523     {
 524         case  SwServiceType::TypeTextTable:
 525         {
 526             xRet = getXWeak(SwXTextTable::CreateXTextTable(nullptr).get());
 527         }
 528         break;
 529         case  SwServiceType::TypeTextFrame:
 530         {
 531             xRet = getXWeak(SwXTextFrame::CreateXTextFrame(rDoc, nullptr).get());
 532         }
 533         break;
 534         case  SwServiceType::TypeGraphic  :
 535         case  SwServiceType::TypeTextGraphic /* #i47503# */ :
 536         {
 537             xRet = getXWeak(SwXTextGraphicObject::CreateXTextGraphicObject(rDoc, nullptr).get());
 538
 539         }
 540         break;
 541         case  SwServiceType::TypeOLE      :
 542         {
 543             xRet = getXWeak(SwXTextEmbeddedObject::CreateXTextEmbeddedObject(rDoc, nullptr).get());
 544         }
 545         break;
 546         case  SwServiceType::TypeBookmark :
 547         {
 548             xRet = getXWeak(SwXBookmark::CreateXBookmark(rDoc, nullptr).get());
 549         }
 550         break;
 551         case  SwServiceType::TypeFieldMark :
 552         {
 553             xRet = getXWeak(SwXFieldmark::CreateXFieldmark(rDoc, nullptr).get());
 554         }
 555         break;
 556         case  SwServiceType::TypeFormFieldMark :
 557         {
 558             xRet = getXWeak(SwXFieldmark::CreateXFieldmark(rDoc, nullptr, true).get());
 559         }
 560         break;
 561         case  SwServiceType::VbaObjectProvider :
 562 #if HAVE_FEATURE_SCRIPTING
 563         {
 564             xRet = getXWeak(new SwVbaObjectForCodeNameProvider(rDoc.GetDocShell()));
 565         }
 566 #endif
 567         break;
 568         case  SwServiceType::VbaCodeNameProvider :
 569 #if HAVE_FEATURE_SCRIPTING
 570         {
 571             if (rDoc.GetDocShell() && ooo::vba::isAlienWordDoc(*rDoc.GetDocShell()))
 572             {
 573                 xRet = getXWeak(new SwVbaCodeNameProvider(rDoc.GetDocShell()));
 574             }
 575         }
 576 #endif
 577         break;
 578         case  SwServiceType::VbaProjectNameProvider :
 579 #if HAVE_FEATURE_SCRIPTING
 580         {
 581                 uno::Reference< container::XNameContainer > xProjProv = rDoc.GetVBATemplateToProjectCache();
 582                 if (!xProjProv.is() && rDoc.GetDocShell()
 583                             && ooo::vba::isAlienWordDoc(*rDoc.GetDocShell()))
 584                 {
 585                     xProjProv = new SwVbaProjectNameProvider;
 586                     rDoc.SetVBATemplateToProjectCache(xProjProv);
 587                 }
 588                 xRet = xProjProv;
 589         }
 590 #endif
 591         break;
 592         case  SwServiceType::VbaGlobals :
 593 #if HAVE_FEATURE_SCRIPTING
 594         {
 595             uno::Any aGlobs;
 596             if (SwDocShell* pShell = rDoc.GetDocShell())
 597             {
 598                 BasicManager *pBasicMan = pShell->GetBasicManager();
 599                 if (pBasicMan && !pBasicMan->GetGlobalUNOConstant(u"VBAGlobals"_ustr, aGlobs))
 600                 {
 601                     uno::Sequence< uno::Any > aArgs{ uno::Any(pShell->GetModel()) };
 602                     aGlobs <<= ::comphelper::getProcessServiceFactory()->createInstanceWithArguments( u"ooo.vba.word.Globals"_ustr, aArgs );
 603                     pBasicMan->SetGlobalUNOConstant( u"VBAGlobals"_ustr, aGlobs );
 604                 }
 605             }
 606             aGlobs >>= xRet;
 607         }
 608 #endif
 609         break;
 610
 611         case  SwServiceType::TypeFootnote :
 612             xRet = getXWeak(SwXFootnote::CreateXFootnote(rDoc, nullptr).get());
 613         break;
 614         case  SwServiceType::TypeEndnote  :
 615             xRet = getXWeak(SwXFootnote::CreateXFootnote(rDoc, nullptr, true).get());
 616         break;
 617         case  SwServiceType::ContentIndexMark :
 618         case  SwServiceType::UserIndexMark    :
 619         case  SwServiceType::TypeIndexMark:
 620         {
 621             TOXTypes eType = TOX_INDEX;
 622             if(SwServiceType::ContentIndexMark== nObjectType)
 623                 eType = TOX_CONTENT;
 624             else if(SwServiceType::UserIndexMark == nObjectType)
 625                 eType = TOX_USER;
 626             xRet = getXWeak(SwXDocumentIndexMark::CreateXDocumentIndexMark(rDoc, nullptr, eType).get());
 627         }
 628         break;
 629         case  SwServiceType::ContentIndex      :
 630         case  SwServiceType::UserIndex         :
 631         case  SwServiceType::TypeIndex    :
 632         case SwServiceType::IndexIllustrations:
 633         case SwServiceType::IndexObjects      :
 634         case SwServiceType::IndexTables:
 635         case SwServiceType::IndexBibliography :
 636         {
 637             TOXTypes eType = TOX_INDEX;
 638             if(SwServiceType::ContentIndex == nObjectType)
 639                 eType = TOX_CONTENT;
 640             else if(SwServiceType::UserIndex == nObjectType)
 641                 eType = TOX_USER;
 642             else if(SwServiceType::IndexIllustrations == nObjectType)
 643             {
 644                 eType = TOX_ILLUSTRATIONS;
 645             }
 646             else if(SwServiceType::IndexObjects       == nObjectType)
 647             {
 648                 eType = TOX_OBJECTS;
 649             }
 650             else if(SwServiceType::IndexBibliography  == nObjectType)
 651             {
 652                 eType = TOX_AUTHORITIES;
 653             }
 654             else if(SwServiceType::IndexTables == nObjectType)
 655             {
 656                 eType = TOX_TABLES;
 657             }
 658             xRet = getXWeak(SwXDocumentIndex::CreateXDocumentIndex(rDoc, nullptr, eType).get());
 659         }
 660         break;
 661         case SwServiceType::IndexHeaderSection :
 662         case SwServiceType::TextSection :
 663             xRet = getXWeak(SwXTextSection::CreateXTextSection(nullptr,
 664                     (SwServiceType::IndexHeaderSection == nObjectType)).get());
 665
 666         break;
 667         case SwServiceType::ReferenceMark :
 668             xRet = getXWeak(SwXReferenceMark::CreateXReferenceMark(rDoc, nullptr).get());
 669         break;
 670         case SwServiceType::StyleCharacter:
 671         case SwServiceType::StyleParagraph:
 672         case SwServiceType::StyleConditionalParagraph:
 673         case SwServiceType::StyleFrame:
 674         case SwServiceType::StylePage:
 675         case SwServiceType::StyleNumbering:
 676         case SwServiceType::StyleTable:
 677         case SwServiceType::StyleCell:
 678         {
 679             SfxStyleFamily eFamily = SfxStyleFamily::Char;
 680             switch(nObjectType)
 681             {
 682                 case SwServiceType::StyleParagraph:
 683                     eFamily = SfxStyleFamily::Para;
 684                 break;
 685                 case SwServiceType::StyleConditionalParagraph:
 686                     eFamily = SfxStyleFamily::Para;
 687                     xRet = SwXStyleFamilies::CreateStyleCondParagraph(rDoc);
 688                 break;
 689                 case SwServiceType::StyleFrame:
 690                     eFamily = SfxStyleFamily::Frame;
 691                 break;
 692                 case SwServiceType::StylePage:
 693                     eFamily = SfxStyleFamily::Page;
 694                 break;
 695                 case SwServiceType::StyleNumbering:
 696                     eFamily = SfxStyleFamily::Pseudo;
 697                 break;
 698                 case SwServiceType::StyleTable:
 699                     eFamily = SfxStyleFamily::Table;
 700                 break;
 701                 case SwServiceType::StyleCell:
 702                     eFamily = SfxStyleFamily::Cell;
 703                 break;
 704                 default: break;
 705             }
 706             if(!xRet.is())
 707                 xRet = SwXStyleFamilies::CreateStyle(eFamily, rDoc);
 708         }
 709         break;
 710         case SwServiceType::FieldTypeDateTime:
 711         case SwServiceType::FieldTypeUser:
 712         case SwServiceType::FieldTypeSetExp:
 713         case SwServiceType::FieldTypeGetExp:
 714         case SwServiceType::FieldTypeFileName:
 715         case SwServiceType::FieldTypePageNum:
 716         case SwServiceType::FieldTypeAuthor:
 717         case SwServiceType::FieldTypeChapter:
 718         case SwServiceType::FieldTypeGetReference:
 719         case SwServiceType::FieldTypeConditionedText:
 720         case SwServiceType::FieldTypeInput:
 721         case SwServiceType::FieldTypeMacro:
 722         case SwServiceType::FieldTypeDDE:
 723         case SwServiceType::FieldTypeHiddenPara:
 724         case SwServiceType::FieldTypeDocInfo:
 725         case SwServiceType::FieldTypeTemplateName:
 726         case SwServiceType::FieldTypeUserExt:
 727         case SwServiceType::FieldTypeRefPageSet:
 728         case SwServiceType::FieldTypeRefPageGet:
 729         case SwServiceType::FieldTypeJumpEdit:
 730         case SwServiceType::FieldTypeScript:
 731         case SwServiceType::FieldTypeDatabaseNextSet:
 732         case SwServiceType::FieldTypeDatabaseNumSet:
 733         case SwServiceType::FieldTypeDatabaseSetNum:
 734         case SwServiceType::FieldTypeDatabase:
 735         case SwServiceType::FieldTypeDatabaseName:
 736         case SwServiceType::FieldTypePageCount:
 737         case SwServiceType::FieldTypeParagraphCount:
 738         case SwServiceType::FieldTypeWordCount:
 739         case SwServiceType::FieldTypeCharacterCount:
 740         case SwServiceType::FieldTypeTableCount:
 741         case SwServiceType::FieldTypeGraphicObjectCount:
 742         case SwServiceType::FieldTypeEmbeddedObjectCount:
 743         case SwServiceType::FieldTypeDocInfoChangeAuthor:
 744         case SwServiceType::FieldTypeDocInfoChangeDateTime:
 745         case SwServiceType::FieldTypeDocInfoEditTime:
 746         case SwServiceType::FieldTypeDocInfoDescription:
 747         case SwServiceType::FieldTypeDocInfoCreateAuthor:
 748         case SwServiceType::FieldTypeDocInfoCreateDateTime:
 749         case SwServiceType::FieldTypeDocInfoCustom:
 750         case SwServiceType::FieldTypeDocInfoPrintAuthor:
 751         case SwServiceType::FieldTypeDocInfoPrintDateTime:
 752         case SwServiceType::FieldTypeDocInfoKeywords:
 753         case SwServiceType::FieldTypeDocInfoSubject:
 754         case SwServiceType::FieldTypeDocInfoTitle:
 755         case SwServiceType::FieldTypeDocInfoRevision:
 756         case SwServiceType::FieldTypeBibliography:
 757         case SwServiceType::FieldTypeInputUser:
 758         case SwServiceType::FieldTypeHiddenText:
 759         case SwServiceType::FieldTypeCombinedCharacters:
 760         case SwServiceType::FieldTypeDropdown:
 761         case SwServiceType::FieldTypeTableFormula:
 762             // NOTE: the sw.SwXAutoTextEntry unoapi test depends on pDoc = 0
 763             xRet = getXWeak(SwXTextField::CreateXTextField(nullptr, nullptr, nObjectType).get());
 764             break;
 765         case SwServiceType::FieldTypeAnnotation:
 766             xRet = getXWeak(SwXTextField::CreateXTextField(&rDoc, nullptr, nObjectType).get());
 767             break;
 768         case SwServiceType::FieldMasterUser:
 769         case SwServiceType::FieldMasterDDE:
 770         case SwServiceType::FieldMasterSetExp :
 771         case SwServiceType::FieldMasterDatabase:
 772         {
 773             SwFieldIds nResId = SwFieldIds::Unknown;
 774             switch(nObjectType)
 775             {
 776                 case SwServiceType::FieldMasterUser: nResId = SwFieldIds::User; break;
 777                 case SwServiceType::FieldMasterDDE:  nResId = SwFieldIds::Dde; break;
 778                 case SwServiceType::FieldMasterSetExp : nResId = SwFieldIds::SetExp; break;
 779                 case SwServiceType::FieldMasterDatabase: nResId = SwFieldIds::Database; break;
 780                 default: break;
 781             }
 782             xRet = getXWeak(SwXFieldMaster::CreateXFieldMaster(&rDoc, nullptr, nResId).get());
 783         }
 784         break;
 785         case SwServiceType::FieldMasterBibliography:
 786         {
 787             SwFieldType* pType = rDoc.getIDocumentFieldsAccess().GetFieldType(SwFieldIds::TableOfAuthorities, OUString(), true);
 788             if(!pType)
 789             {
 790                 SwAuthorityFieldType aType(&rDoc);
 791                 pType = rDoc.getIDocumentFieldsAccess().InsertFieldType(aType);
 792             }
 793             xRet = getXWeak(SwXFieldMaster::CreateXFieldMaster(&rDoc, pType).get());
 794         }
 795         break;
 796         case SwServiceType::Paragraph:
 797             xRet = getXWeak(SwXParagraph::CreateXParagraph(rDoc, nullptr, nullptr).get());
 798         break;
 799         case SwServiceType::NumberingRules:
 800             xRet = getXWeak(new SwXNumberingRules(rDoc));
 801         break;
 802         case SwServiceType::TextColumns:
 803             xRet = SvxXTextColumns_createInstance();
 804         break;
 805         case SwServiceType::Defaults:
 806             xRet = getXWeak(new SwXTextDefaults(&rDoc));
 807         break;
 808         case SwServiceType::IMapRectangle:
 809             xRet = SvUnoImageMapRectangleObject_createInstance( sw_GetSupportedMacroItems() );
 810         break;
 811         case SwServiceType::IMapCircle:
 812             xRet = SvUnoImageMapCircleObject_createInstance( sw_GetSupportedMacroItems() );
 813         break;
 814         case SwServiceType::IMapPolygon:
 815             xRet = SvUnoImageMapPolygonObject_createInstance( sw_GetSupportedMacroItems() );
 816         break;
 817         case SwServiceType::Chart2DataProvider:
 818         {
 819             // #i64497# If a chart is in a temporary document during clipboard
 820             // paste, there should be no data provider, so that own data is used
 821             // This should not happen during copy/paste, as this will unlink
 822             // charts using table data.
 823             SwDocShell* pShell = rDoc.GetDocShell();
 824             if (pShell && pShell->GetCreateMode() != SfxObjectCreateMode::EMBEDDED)
 825                 xRet = getXWeak(rDoc.getIDocumentChartDataProviderAccess().GetChartDataProvider( true /* create - if not yet available */ ));
 826             else
 827                 SAL_WARN("sw.uno",
 828                     "not creating chart data provider for embedded object");
 829         }
 830         break;
 831         case SwServiceType::TypeMeta:
 832             xRet = getXWeak(SwXMeta::CreateXMeta(rDoc, false).get());
 833         break;
 834         case SwServiceType::FieldTypeMetafield:
 835             xRet = getXWeak(SwXMeta::CreateXMeta(rDoc, true).get());
 836         break;
 837         case SwServiceType::LineBreak:
 838             xRet = getXWeak(SwXLineBreak::CreateXLineBreak(nullptr).get());
 839             break;
 840         case SwServiceType::ContentControl:
 841             xRet = getXWeak(SwXContentControl::CreateXContentControl(rDoc).get());
 842         break;
 843         default:
 844             throw uno::RuntimeException();
 845     }
 846     return xRet;
 847 }
 848
 849 //SMART_UNO_IMPLEMENTATION( SwXTextTables, UsrObject );
 850 SwXTextTables::SwXTextTables(SwDoc* pDc) :
 851         SwUnoCollection(pDc)
 852 {
 853
 854 }
 855
 856 SwXTextTables::~SwXTextTables()
 857 {
 858
 859 }
 860
 861 sal_Int32 SwXTextTables::getCount()
 862 {
 863     SolarMutexGuard aGuard;
 864     sal_Int32 nRet = 0;
 865     if(IsValid())
 866         nRet = static_cast<sal_Int32>(GetDoc().GetTableFrameFormatCount(true));
 867     return nRet;
 868 }
 869
 870 uno::Any SAL_CALL SwXTextTables::getByIndex(sal_Int32 nInputIndex)
 871 {
 872     uno::Reference<XTextTable> xTable = getTextTableByIndex(nInputIndex);
 873     uno::Any aRet;
 874     aRet <<= xTable;
 875     return aRet;
 876 }
 877
 878 rtl::Reference<SwXTextTable> SwXTextTables::getTextTableByIndex(sal_Int32 nInputIndex)
 879 {
 880     SolarMutexGuard aGuard;
 881
 882     if (nInputIndex < 0)
 883         throw IndexOutOfBoundsException();
 884
 885     size_t nIndex = static_cast<size_t>(nInputIndex);
 886     for(SwTableFormat* pFormat: *GetDoc().GetTableFrameFormats())
 887     {
 888         if(!pFormat->IsUsed())
 889             continue;
 890         if(nIndex)
 891             --nIndex;
 892         else
 893         {
 894             return SwXTextTables::GetObject(*pFormat);
 895         }
 896     }
 897     throw IndexOutOfBoundsException();
 898 }
 899
 900 uno::Any SwXTextTables::getByName(const OUString& rItemName)
 901 {
 902     return uno::Any(uno::Reference< XTextTable >(getTextTableByName(rItemName)));
 903 }
 904
 905 rtl::Reference<SwXTextTable> SwXTextTables::getTextTableByName(std::u16string_view rItemName)
 906 {
 907     SolarMutexGuard aGuard;
 908
 909     const size_t nCount = GetDoc().GetTableFrameFormatCount(true);
 910     rtl::Reference< SwXTextTable >  xTable;
 911     for( size_t i = 0; i < nCount; ++i)
 912     {
 913         SwFrameFormat& rFormat = GetDoc().GetTableFrameFormat(i, true);
 914         if (rItemName == rFormat.GetName())
 915         {
 916             xTable = SwXTextTables::GetObject(rFormat);
 917             break;
 918         }
 919     }
 920     if(!xTable.is())
 921         throw NoSuchElementException();
 922
 923     return xTable;
 924 }
 925
 926 uno::Sequence< OUString > SwXTextTables::getElementNames()
 927 {
 928     SolarMutexGuard aGuard;
 929     const size_t nCount = GetDoc().GetTableFrameFormatCount(true);
 930     uno::Sequence<OUString> aSeq(static_cast<sal_Int32>(nCount));
 931     if(nCount)
 932     {
 933         OUString* pArray = aSeq.getArray();
 934         for( size_t i = 0; i < nCount; ++i)
 935         {
 936             SwFrameFormat& rFormat = GetDoc().GetTableFrameFormat(i, true);
 937
 938             pArray[i] = rFormat.GetName();
 939         }
 940     }
 941     return aSeq;
 942 }
 943
 944 sal_Bool SwXTextTables::hasByName(const OUString& rName)
 945 {
 946     SolarMutexGuard aGuard;
 947     bool bRet= false;
 948
 949     const size_t nCount = GetDoc().GetTableFrameFormatCount(true);
 950     for( size_t i = 0; i < nCount; ++i)
 951     {
 952         SwFrameFormat& rFormat = GetDoc().GetTableFrameFormat(i, true);
 953         if (rName == rFormat.GetName())
 954         {
 955             bRet = true;
 956             break;
 957         }
 958     }
 959     return bRet;
 960 }
 961
 962 uno::Type SAL_CALL
 963     SwXTextTables::getElementType(  )
 964 {
 965     return cppu::UnoType<XTextTable>::get();
 966 }
 967
 968 sal_Bool SwXTextTables::hasElements()
 969 {
 970     SolarMutexGuard aGuard;
 971     return 0 != GetDoc().GetTableFrameFormatCount(true);
 972 }
 973
 974 OUString SwXTextTables::getImplementationName()
 975 {
 976     return u"SwXTextTables"_ustr;
 977 }
 978
 979 sal_Bool SwXTextTables::supportsService(const OUString& rServiceName)
 980 {
 981     return cppu::supportsService(this, rServiceName);
 982 }
 983
 984 uno::Sequence< OUString > SwXTextTables::getSupportedServiceNames()
 985 {
 986     return { u"com.sun.star.text.TextTables"_ustr };
 987 }
 988
 989 rtl::Reference<SwXTextTable> SwXTextTables::GetObject(SwFrameFormat& rFormat)
 990 {
 991     return SwXTextTable::CreateXTextTable(& rFormat);
 992 }
 993
 994 namespace
 995 {
 996     template<FlyCntType T> struct UnoFrameWrap_traits {};
 997
 998     template<>
 999     struct UnoFrameWrap_traits<FLYCNTTYPE_FRM>
1000     {
1001         static uno::Any wrapFrame(SwFrameFormat & rFrameFormat)
1002         {
1003             uno::Reference<text::XTextFrame> const xRet(
1004                 SwXTextFrame::CreateXTextFrame(*rFrameFormat.GetDoc(), &rFrameFormat));
1005             return uno::Any(xRet);
1006         }
1007         static bool filter(const SwNode* const pNode) { return !pNode->IsNoTextNode(); };
1008     };
1009
1010     template<>
1011     struct UnoFrameWrap_traits<FLYCNTTYPE_GRF>
1012     {
1013         static uno::Any wrapFrame(SwFrameFormat & rFrameFormat)
1014         {
1015             uno::Reference<text::XTextContent> const xRet(
1016                 SwXTextGraphicObject::CreateXTextGraphicObject(*rFrameFormat.GetDoc(), &rFrameFormat));
1017             return uno::Any(xRet);
1018         }
1019         static bool filter(const SwNode* const pNode) { return pNode->IsGrfNode(); };
1020     };
1021
1022     template<>
1023     struct UnoFrameWrap_traits<FLYCNTTYPE_OLE>
1024     {
1025         static uno::Any wrapFrame(SwFrameFormat & rFrameFormat)
1026         {
1027             uno::Reference<text::XTextContent> const xRet(
1028                 SwXTextEmbeddedObject::CreateXTextEmbeddedObject(*rFrameFormat.GetDoc(), &rFrameFormat));
1029             return uno::Any(xRet);
1030         }
1031         static bool filter(const SwNode* const pNode) { return pNode->IsOLENode(); };
1032     };
1033
1034     template<FlyCntType T>
1035     uno::Any lcl_UnoWrapFrame(SwFrameFormat* pFormat)
1036     {
1037         return UnoFrameWrap_traits<T>::wrapFrame(*pFormat);
1038     }
1039
1040     // runtime adapter for lcl_UnoWrapFrame
1041     /// @throws uno::RuntimeException
1042     uno::Any lcl_UnoWrapFrame(SwFrameFormat* pFormat, FlyCntType eType)
1043     {
1044         switch(eType)
1045         {
1046             case FLYCNTTYPE_FRM:
1047                 return lcl_UnoWrapFrame<FLYCNTTYPE_FRM>(pFormat);
1048             case FLYCNTTYPE_GRF:
1049                 return lcl_UnoWrapFrame<FLYCNTTYPE_GRF>(pFormat);
1050             case FLYCNTTYPE_OLE:
1051                 return lcl_UnoWrapFrame<FLYCNTTYPE_OLE>(pFormat);
1052             default:
1053                 throw uno::RuntimeException();
1054         }
1055     }
1056
1057     template<FlyCntType T>
1058     class SwXFrameEnumeration
1059         : public SwSimpleEnumeration_Base
1060     {
1061         private:
1062             std::vector< Any > m_aFrames;
1063         protected:
1064             virtual ~SwXFrameEnumeration() override {};
1065         public:
1066             SwXFrameEnumeration(const SwDoc& rDoc);
1067
1068             //XEnumeration
1069             virtual sal_Bool SAL_CALL hasMoreElements() override;
1070             virtual Any SAL_CALL nextElement() override;
1071
1072             //XServiceInfo
1073             virtual OUString SAL_CALL getImplementationName() override;
1074             virtual sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
1075             virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
1076     };
1077 }
1078
1079 template<FlyCntType T>
1080 SwXFrameEnumeration<T>::SwXFrameEnumeration(const SwDoc& rDoc)
1081 {
1082     SolarMutexGuard aGuard;
1083     for(sw::SpzFrameFormat* pFormat: *rDoc.GetSpzFrameFormats())
1084     {
1085         // #i104937#
1086         if(pFormat->Which() != RES_FLYFRMFMT || SwTextBoxHelper::isTextBox(pFormat, RES_FLYFRMFMT))
1087             continue;
1088         const SwNodeIndex* pIdx =  pFormat->GetContent().GetContentIdx();
1089         if(!pIdx || !pIdx->GetNodes().IsDocNodes())
1090             continue;
1091         const SwNode* pNd = rDoc.GetNodes()[ pIdx->GetIndex() + 1 ];
1092         if(UnoFrameWrap_traits<T>::filter(pNd))
1093             m_aFrames.push_back(lcl_UnoWrapFrame<T>(pFormat));
1094     }
1095 }
1096
1097 template<FlyCntType T>
1098 sal_Bool SwXFrameEnumeration<T>::hasMoreElements()
1099 {
1100     SolarMutexGuard aGuard;
1101     return !m_aFrames.empty();
1102 }
1103
1104 template<FlyCntType T>
1105 Any SwXFrameEnumeration<T>::nextElement()
1106 {
1107     SolarMutexGuard aGuard;
1108     if(m_aFrames.empty())
1109         throw NoSuchElementException();
1110
1111     Any aResult = m_aFrames.back();
1112     m_aFrames.pop_back();
1113     return aResult;
1114 }
1115
1116 template<FlyCntType T>
1117 OUString SwXFrameEnumeration<T>::getImplementationName()
1118 {
1119     return u"SwXFrameEnumeration"_ustr;
1120 }
1121
1122 template<FlyCntType T>
1123 sal_Bool SwXFrameEnumeration<T>::supportsService(const OUString& ServiceName)
1124 {
1125     return cppu::supportsService(this, ServiceName);
1126 }
1127
1128 template<FlyCntType T>
1129 Sequence< OUString > SwXFrameEnumeration<T>::getSupportedServiceNames()
1130 {
1131     return { u"com.sun.star.container.XEnumeration"_ustr };
1132 }
1133
1134 OUString SwXFrames::getImplementationName()
1135 {
1136     return u"SwXFrames"_ustr;
1137 }
1138
1139 sal_Bool SwXFrames::supportsService(const OUString& rServiceName)
1140 {
1141     return cppu::supportsService(this, rServiceName);
1142 }
1143
1144 Sequence<OUString> SwXFrames::getSupportedServiceNames()
1145 {
1146     return { u"com.sun.star.text.TextFrames"_ustr };
1147 }
1148
1149 SwXFrames::SwXFrames(SwDoc* _pDoc, FlyCntType eSet) :
1150     SwUnoCollection(_pDoc),
1151     m_eType(eSet)
1152 {}
1153
1154 SwXFrames::~SwXFrames()
1155 {}
1156
1157 uno::Reference<container::XEnumeration> SwXFrames::createEnumeration()
1158 {
1159     SolarMutexGuard aGuard;
1160     switch(m_eType)
1161     {
1162         case FLYCNTTYPE_FRM:
1163             return uno::Reference< container::XEnumeration >(
1164                 new SwXFrameEnumeration<FLYCNTTYPE_FRM>(GetDoc()));
1165         case FLYCNTTYPE_GRF:
1166             return uno::Reference< container::XEnumeration >(
1167                 new SwXFrameEnumeration<FLYCNTTYPE_GRF>(GetDoc()));
1168         case FLYCNTTYPE_OLE:
1169             return uno::Reference< container::XEnumeration >(
1170                 new SwXFrameEnumeration<FLYCNTTYPE_OLE>(GetDoc()));
1171         default:
1172             throw uno::RuntimeException();
1173     }
1174 }
1175
1176 sal_Int32 SwXFrames::getCount()
1177 {
1178     SolarMutexGuard aGuard;
1179     // Ignore TextBoxes for TextFrames.
1180     return static_cast<sal_Int32>(GetDoc().GetFlyCount(m_eType, /*bIgnoreTextBoxes=*/m_eType == FLYCNTTYPE_FRM));
1181 }
1182
1183 uno::Any SwXFrames::getByIndex(sal_Int32 nIndex)
1184 {
1185     SolarMutexGuard aGuard;
1186     if(nIndex < 0)
1187         throw IndexOutOfBoundsException();
1188     // Ignore TextBoxes for TextFrames.
1189     SwFrameFormat* pFormat = GetDoc().GetFlyNum(static_cast<size_t>(nIndex), m_eType, /*bIgnoreTextBoxes=*/m_eType == FLYCNTTYPE_FRM);
1190     if(!pFormat)
1191         throw IndexOutOfBoundsException();
1192     return lcl_UnoWrapFrame(pFormat, m_eType);
1193 }
1194
1195 uno::Any SwXFrames::getByName(const OUString& rName)
1196 {
1197     SolarMutexGuard aGuard;
1198     const SwFrameFormat* pFormat;
1199     switch(m_eType)
1200     {
1201         case FLYCNTTYPE_GRF:
1202             pFormat = GetDoc().FindFlyByName(rName, SwNodeType::Grf);
1203             break;
1204         case FLYCNTTYPE_OLE:
1205             pFormat = GetDoc().FindFlyByName(rName, SwNodeType::Ole);
1206             break;
1207         default:
1208             pFormat = GetDoc().FindFlyByName(rName, SwNodeType::Text);
1209             break;
1210     }
1211     if(!pFormat)
1212         throw NoSuchElementException();
1213     return lcl_UnoWrapFrame(const_cast<SwFrameFormat*>(pFormat), m_eType);
1214 }
1215
1216 uno::Sequence<OUString> SwXFrames::getElementNames()
1217 {
1218     SolarMutexGuard aGuard;
1219     const Reference<XEnumeration> xEnum = createEnumeration();
1220     std::vector<OUString> vNames;
1221     while(xEnum->hasMoreElements())
1222     {
1223         Reference<container::XNamed> xNamed;
1224         xEnum->nextElement() >>= xNamed;
1225         if(xNamed.is())
1226             vNames.push_back(xNamed->getName());
1227     }
1228     return ::comphelper::containerToSequence(vNames);
1229 }
1230
1231 sal_Bool SwXFrames::hasByName(const OUString& rName)
1232 {
1233     SolarMutexGuard aGuard;
1234     switch(m_eType)
1235     {
1236         case FLYCNTTYPE_GRF:
1237             return GetDoc().FindFlyByName(rName, SwNodeType::Grf) != nullptr;
1238         case FLYCNTTYPE_OLE:
1239             return GetDoc().FindFlyByName(rName, SwNodeType::Ole) != nullptr;
1240         default:
1241             return GetDoc().FindFlyByName(rName, SwNodeType::Text) != nullptr;
1242     }
1243 }
1244
1245 uno::Type SAL_CALL SwXFrames::getElementType()
1246 {
1247     SolarMutexGuard aGuard;
1248     switch(m_eType)
1249     {
1250         case FLYCNTTYPE_FRM:
1251             return cppu::UnoType<XTextFrame>::get();
1252         case FLYCNTTYPE_GRF:
1253             return cppu::UnoType<XTextContent>::get();
1254         case FLYCNTTYPE_OLE:
1255             return cppu::UnoType<XEmbeddedObjectSupplier>::get();
1256         default:
1257             return uno::Type();
1258     }
1259 }
1260
1261 sal_Bool SwXFrames::hasElements()
1262 {
1263     SolarMutexGuard aGuard;
1264     return GetDoc().GetFlyCount(m_eType) > 0;
1265 }
1266
1267
1268 OUString SwXTextFrames::getImplementationName()
1269 {
1270     return u"SwXTextFrames"_ustr;
1271 }
1272
1273 sal_Bool SwXTextFrames::supportsService(const OUString& rServiceName)
1274 {
1275     return cppu::supportsService(this, rServiceName);
1276 }
1277
1278 Sequence< OUString > SwXTextFrames::getSupportedServiceNames()
1279 {
1280     return { u"com.sun.star.text.TextFrames"_ustr };
1281 }
1282
1283 SwXTextFrames::SwXTextFrames(SwDoc* _pDoc) :
1284     SwXFrames(_pDoc, FLYCNTTYPE_FRM)
1285 {
1286 }
1287
1288 SwXTextFrames::~SwXTextFrames()
1289 {
1290 }
1291
1292 OUString SwXTextGraphicObjects::getImplementationName()
1293 {
1294     return u"SwXTextGraphicObjects"_ustr;
1295 }
1296
1297 sal_Bool SwXTextGraphicObjects::supportsService(const OUString& rServiceName)
1298 {
1299     return cppu::supportsService(this, rServiceName);
1300 }
1301
1302 Sequence< OUString > SwXTextGraphicObjects::getSupportedServiceNames()
1303 {
1304     return { u"com.sun.star.text.TextGraphicObjects"_ustr };
1305 }
1306
1307 SwXTextGraphicObjects::SwXTextGraphicObjects(SwDoc* _pDoc) :
1308     SwXFrames(_pDoc, FLYCNTTYPE_GRF)
1309 {
1310 }
1311
1312 SwXTextGraphicObjects::~SwXTextGraphicObjects()
1313 {
1314 }
1315
1316 OUString SwXTextEmbeddedObjects::getImplementationName()
1317 {
1318     return u"SwXTextEmbeddedObjects"_ustr;
1319 }
1320
1321 sal_Bool SwXTextEmbeddedObjects::supportsService(const OUString& rServiceName)
1322 {
1323     return cppu::supportsService(this, rServiceName);
1324 }
1325
1326 Sequence< OUString > SwXTextEmbeddedObjects::getSupportedServiceNames()
1327 {
1328     return { u"com.sun.star.text.TextEmbeddedObjects"_ustr };
1329 }
1330
1331 SwXTextEmbeddedObjects::SwXTextEmbeddedObjects(SwDoc* _pDoc) :
1332         SwXFrames(_pDoc, FLYCNTTYPE_OLE)
1333 {
1334 }
1335
1336 SwXTextEmbeddedObjects::~SwXTextEmbeddedObjects()
1337 {
1338 }
1339
1340 OUString SwXTextSections::getImplementationName()
1341 {
1342     return u"SwXTextSections"_ustr;
1343 }
1344
1345 sal_Bool SwXTextSections::supportsService(const OUString& rServiceName)
1346 {
1347     return cppu::supportsService(this, rServiceName);
1348 }
1349
1350 Sequence< OUString > SwXTextSections::getSupportedServiceNames()
1351 {
1352     return { u"com.sun.star.text.TextSections"_ustr };
1353 }
1354
1355 SwXTextSections::SwXTextSections(SwDoc* _pDoc) :
1356     SwUnoCollection(_pDoc)
1357 {
1358 }
1359
1360 SwXTextSections::~SwXTextSections()
1361 {
1362 }
1363
1364 sal_Int32 SwXTextSections::getCount()
1365 {
1366     SolarMutexGuard aGuard;
1367     const SwSectionFormats& rSectFormats = GetDoc().GetSections();
1368     size_t nCount = rSectFormats.size();
1369     for(size_t i = nCount; i; --i)
1370     {
1371         if( !rSectFormats[i - 1]->IsInNodesArr())
1372             nCount--;
1373     }
1374     return nCount;
1375 }
1376
1377 uno::Any SwXTextSections::getByIndex(sal_Int32 nIndex)
1378 {
1379     if (nIndex < 0)
1380         throw IndexOutOfBoundsException();
1381     size_t nIndex2 = nIndex;
1382     SolarMutexGuard aGuard;
1383
1384     const SwSectionFormats& rSectFormats = GetDoc().GetSections();
1385     const size_t nCount = rSectFormats.size();
1386     for(size_t i = 0; i < nCount; ++i)
1387     {
1388         if( !rSectFormats[i]->IsInNodesArr())
1389             nIndex2++;
1390         else if (nIndex2 == i)
1391             return Any(css::uno::Reference< css::text::XTextSection>(GetObject(*rSectFormats[i])));
1392     }
1393     throw IndexOutOfBoundsException();
1394 }
1395
1396 uno::Any SwXTextSections::getByName(const OUString& rName)
1397 {
1398     SolarMutexGuard aGuard;
1399     uno::Any aRet;
1400
1401     SwSectionFormats& rFormats = GetDoc().GetSections();
1402     uno::Reference< XTextSection >  xSect;
1403     for(size_t i = 0; i < rFormats.size(); ++i)
1404     {
1405         SwSectionFormat* pFormat = rFormats[i];
1406         if (pFormat->IsInNodesArr()
1407             && (rName == pFormat->GetSection()->GetSectionName()))
1408         {
1409             xSect = GetObject(*pFormat);
1410             aRet <<= xSect;
1411             break;
1412         }
1413     }
1414     if(!xSect.is())
1415         throw NoSuchElementException();
1416
1417     return aRet;
1418 }
1419
1420 uno::Sequence< OUString > SwXTextSections::getElementNames()
1421 {
1422     SolarMutexGuard aGuard;
1423     SwSectionFormats& rSectFormats = GetDoc().GetSections();
1424     size_t nCount = rSectFormats.size();
1425     for(size_t i = nCount; i; --i)
1426     {
1427         if( !rSectFormats[i - 1]->IsInNodesArr())
1428             nCount--;
1429     }
1430
1431     uno::Sequence<OUString> aSeq(nCount);
1432     if(nCount)
1433     {
1434         OUString* pArray = aSeq.getArray();
1435         size_t nIndex = 0;
1436         for( size_t i = 0; i < nCount; ++i, ++nIndex)
1437         {
1438             const SwSectionFormat* pFormat = rSectFormats[nIndex];
1439             while(!pFormat->IsInNodesArr())
1440             {
1441                 pFormat = rSectFormats[++nIndex];
1442             }
1443             pArray[i] = pFormat->GetSection()->GetSectionName();
1444         }
1445     }
1446     return aSeq;
1447 }
1448
1449 sal_Bool SwXTextSections::hasByName(const OUString& rName)
1450 {
1451     SolarMutexGuard aGuard;
1452     bool bRet = false;
1453     if(IsValid())
1454     {
1455         SwSectionFormats& rFormats = GetDoc().GetSections();
1456         for(size_t i = 0; i < rFormats.size(); ++i)
1457         {
1458             const SwSectionFormat* pFormat = rFormats[i];
1459             if (rName == pFormat->GetSection()->GetSectionName())
1460             {
1461                 bRet = true;
1462                 break;
1463             }
1464         }
1465     }
1466     else
1467     {
1468         // special handling for dbg_ methods
1469         if( !rName.startsWith("dbg_"))
1470             throw uno::RuntimeException();
1471     }
1472     return bRet;
1473 }
1474
1475 uno::Type SAL_CALL SwXTextSections::getElementType()
1476 {
1477     return cppu::UnoType<XTextSection>::get();
1478 }
1479
1480 sal_Bool SwXTextSections::hasElements()
1481 {
1482     SolarMutexGuard aGuard;
1483     size_t nCount = 0;
1484
1485     SwSectionFormats& rFormats = GetDoc().GetSections();
1486     nCount = rFormats.size();
1487
1488     return nCount > 0;
1489 }
1490
1491 rtl::Reference< SwXTextSection >  SwXTextSections::GetObject( SwSectionFormat& rFormat )
1492 {
1493     return SwXTextSection::CreateXTextSection(&rFormat);
1494 }
1495
1496 OUString SwXBookmarks::getImplementationName()
1497 {
1498     return u"SwXBookmarks"_ustr;
1499 }
1500
1501 sal_Bool SwXBookmarks::supportsService(const OUString& rServiceName)
1502 {
1503     return cppu::supportsService(this, rServiceName);
1504 }
1505
1506 Sequence< OUString > SwXBookmarks::getSupportedServiceNames()
1507 {
1508     return { u"com.sun.star.text.Bookmarks"_ustr };
1509 }
1510
1511 SwXBookmarks::SwXBookmarks(SwDoc* _pDoc) :
1512     SwUnoCollection(_pDoc)
1513 { }
1514
1515 SwXBookmarks::~SwXBookmarks()
1516 { }
1517
1518 sal_Int32 SwXBookmarks::getCount()
1519 {
1520     SolarMutexGuard aGuard;
1521
1522     sal_Int32 count(0);
1523     IDocumentMarkAccess* const pMarkAccess = GetDoc().getIDocumentMarkAccess();
1524     for (auto ppMark = pMarkAccess->getBookmarksBegin();
1525          ppMark != pMarkAccess->getBookmarksEnd(); ++ppMark)
1526     {
1527         if (IDocumentMarkAccess::MarkType::BOOKMARK ==
1528                 IDocumentMarkAccess::GetType(**ppMark))
1529         {
1530             ++count; // only count real bookmarks
1531         }
1532     }
1533     return count;
1534 }
1535
1536 uno::Any SwXBookmarks::getByIndex(sal_Int32 nIndex)
1537 {
1538     SolarMutexGuard aGuard;
1539     auto& rDoc = GetDoc();
1540     IDocumentMarkAccess* const pMarkAccess = rDoc.getIDocumentMarkAccess();
1541     if(nIndex < 0 || nIndex >= pMarkAccess->getBookmarksCount())
1542         throw IndexOutOfBoundsException();
1543
1544     sal_Int32 count(0);
1545     for (auto ppMark = pMarkAccess->getBookmarksBegin();
1546          ppMark != pMarkAccess->getBookmarksEnd(); ++ppMark)
1547     {
1548         if (IDocumentMarkAccess::MarkType::BOOKMARK ==
1549                 IDocumentMarkAccess::GetType(**ppMark))
1550         {
1551             if (count == nIndex)
1552             {
1553                 uno::Any aRet;
1554                 const uno::Reference< text::XTextContent > xRef =
1555                     SwXBookmark::CreateXBookmark(rDoc, *ppMark);
1556                 aRet <<= xRef;
1557                 return aRet;
1558             }
1559             ++count; // only count real bookmarks
1560         }
1561     }
1562     throw IndexOutOfBoundsException();
1563 }
1564
1565 uno::Any SwXBookmarks::getByName(const OUString& rName)
1566 {
1567     SolarMutexGuard aGuard;
1568
1569     auto& rDoc = GetDoc();
1570     IDocumentMarkAccess* const pMarkAccess = rDoc.getIDocumentMarkAccess();
1571     auto ppBkmk = pMarkAccess->findBookmark(rName);
1572     if(ppBkmk == pMarkAccess->getBookmarksEnd())
1573         throw NoSuchElementException();
1574
1575     uno::Any aRet;
1576     const uno::Reference< text::XTextContent > xRef =
1577         SwXBookmark::CreateXBookmark(rDoc, *ppBkmk);
1578     aRet <<= xRef;
1579     return aRet;
1580 }
1581
1582 uno::Sequence< OUString > SwXBookmarks::getElementNames()
1583 {
1584     SolarMutexGuard aGuard;
1585
1586     std::vector< OUString > ret;
1587     IDocumentMarkAccess* const pMarkAccess = GetDoc().getIDocumentMarkAccess();
1588     for (auto ppMark =
1589             pMarkAccess->getBookmarksBegin();
1590          ppMark != pMarkAccess->getBookmarksEnd(); ++ppMark)
1591     {
1592         if (IDocumentMarkAccess::MarkType::BOOKMARK ==
1593                 IDocumentMarkAccess::GetType(**ppMark))
1594         {
1595             ret.push_back((*ppMark)->GetName()); // only add real bookmarks
1596         }
1597     }
1598     return comphelper::containerToSequence(ret);
1599 }
1600
1601 sal_Bool SwXBookmarks::hasByName(const OUString& rName)
1602 {
1603     SolarMutexGuard aGuard;
1604
1605     IDocumentMarkAccess* const pMarkAccess = GetDoc().getIDocumentMarkAccess();
1606     return pMarkAccess->findBookmark(rName) != pMarkAccess->getBookmarksEnd();
1607 }
1608
1609 uno::Type SAL_CALL SwXBookmarks::getElementType()
1610 {
1611     return cppu::UnoType<XTextContent>::get();
1612 }
1613
1614 sal_Bool SwXBookmarks::hasElements()
1615 {
1616     SolarMutexGuard aGuard;
1617
1618     IDocumentMarkAccess* const pMarkAccess = GetDoc().getIDocumentMarkAccess();
1619     for (auto ppMark =
1620             pMarkAccess->getBookmarksBegin();
1621          ppMark != pMarkAccess->getBookmarksEnd(); ++ppMark)
1622     {
1623         if (IDocumentMarkAccess::MarkType::BOOKMARK ==
1624                 IDocumentMarkAccess::GetType(**ppMark))
1625         {
1626             return true;
1627         }
1628     }
1629     return false;
1630 }
1631
1632 SwXNumberingRulesCollection::SwXNumberingRulesCollection( SwDoc* _pDoc ) :
1633     SwUnoCollection(_pDoc)
1634 {
1635 }
1636
1637 SwXNumberingRulesCollection::~SwXNumberingRulesCollection()
1638 {
1639 }
1640
1641 sal_Int32 SwXNumberingRulesCollection::getCount()
1642 {
1643     SolarMutexGuard aGuard;
1644     return GetDoc().GetNumRuleTable().size();
1645 }
1646
1647 uno::Any SwXNumberingRulesCollection::getByIndex(sal_Int32 nIndex)
1648 {
1649     if (nIndex < 0)
1650         throw IndexOutOfBoundsException();
1651
1652     SolarMutexGuard aGuard;
1653
1654     if (SwDoc& rDoc = GetDoc(); o3tl::make_unsigned(nIndex) < rDoc.GetNumRuleTable().size())
1655     {
1656         uno::Reference<XIndexReplace> xRef(
1657             new SwXNumberingRules(*rDoc.GetNumRuleTable()[nIndex], &rDoc));
1658         return uno::Any(xRef);
1659     }
1660
1661     throw IndexOutOfBoundsException();
1662 }
1663
1664 uno::Type SAL_CALL SwXNumberingRulesCollection::getElementType()
1665 {
1666     return cppu::UnoType<XIndexReplace>::get();
1667 }
1668
1669 sal_Bool SwXNumberingRulesCollection::hasElements()
1670 {
1671     SolarMutexGuard aGuard;
1672     return !GetDoc().GetNumRuleTable().empty();
1673 }
1674
1675 OUString SwXFootnotes::getImplementationName()
1676 {
1677     return u"SwXFootnotes"_ustr;
1678 }
1679
1680 sal_Bool SwXFootnotes::supportsService(const OUString& rServiceName)
1681 {
1682     return cppu::supportsService(this, rServiceName);
1683 }
1684
1685 Sequence< OUString > SwXFootnotes::getSupportedServiceNames()
1686 {
1687     return { u"com.sun.star.text.Footnotes"_ustr };
1688 }
1689
1690 SwXFootnotes::SwXFootnotes(bool bEnd, SwDoc* _pDoc)
1691     : SwUnoCollection(_pDoc)
1692     , m_bEndnote(bEnd)
1693 {
1694 }
1695
1696 SwXFootnotes::~SwXFootnotes()
1697 {
1698 }
1699
1700 sal_Int32 SwXFootnotes::getCount()
1701 {
1702     SolarMutexGuard aGuard;
1703     sal_Int32 nCount = 0;
1704     for (const SwTextFootnote* pTextFootnote : GetDoc().GetFootnoteIdxs())
1705     {
1706         const SwFormatFootnote& rFootnote = pTextFootnote->GetFootnote();
1707         if ( rFootnote.IsEndNote() != m_bEndnote )
1708             continue;
1709         nCount++;
1710     }
1711     return nCount;
1712 }
1713
1714 uno::Any SwXFootnotes::getByIndex(sal_Int32 nIndex)
1715 {
1716     if (nIndex < 0)
1717         throw IndexOutOfBoundsException();
1718     return uno::Any(uno::Reference< XFootnote >(getFootnoteByIndex(nIndex)));
1719 }
1720
1721 rtl::Reference<SwXFootnote> SwXFootnotes::getFootnoteByIndex(sal_Int32 nIndex)
1722 {
1723     SolarMutexGuard aGuard;
1724     sal_Int32 nCount = 0;
1725
1726     auto& rDoc = GetDoc();
1727     for (const SwTextFootnote* pTextFootnote : rDoc.GetFootnoteIdxs())
1728     {
1729         const SwFormatFootnote& rFootnote = pTextFootnote->GetFootnote();
1730         if ( rFootnote.IsEndNote() != m_bEndnote )
1731             continue;
1732
1733         if(nCount == nIndex)
1734             return SwXFootnote::CreateXFootnote(rDoc, &const_cast<SwFormatFootnote&>(rFootnote));
1735         nCount++;
1736     }
1737     throw IndexOutOfBoundsException();
1738 }
1739
1740 uno::Type SAL_CALL SwXFootnotes::getElementType()
1741 {
1742     return cppu::UnoType<XFootnote>::get();
1743 }
1744
1745 sal_Bool SwXFootnotes::hasElements()
1746 {
1747     SolarMutexGuard aGuard;
1748     return !GetDoc().GetFootnoteIdxs().empty();
1749 }
1750
1751 rtl::Reference<SwXFootnote> SwXFootnotes::GetObject( SwDoc& rDoc, const SwFormatFootnote& rFormat )
1752 {
1753     return SwXFootnote::CreateXFootnote(rDoc, &const_cast<SwFormatFootnote&>(rFormat));
1754 }
1755
1756 OUString SwXReferenceMarks::getImplementationName()
1757 {
1758     return u"SwXReferenceMarks"_ustr;
1759 }
1760
1761 sal_Bool SwXReferenceMarks::supportsService(const OUString& rServiceName)
1762 {
1763     return cppu::supportsService(this, rServiceName);
1764 }
1765
1766 Sequence< OUString > SwXReferenceMarks::getSupportedServiceNames()
1767 {
1768     return { u"com.sun.star.text.ReferenceMarks"_ustr };
1769 }
1770
1771 SwXReferenceMarks::SwXReferenceMarks(SwDoc* _pDoc) :
1772     SwUnoCollection(_pDoc)
1773 {
1774 }
1775
1776 SwXReferenceMarks::~SwXReferenceMarks()
1777 {
1778 }
1779
1780 sal_Int32 SwXReferenceMarks::getCount()
1781 {
1782     SolarMutexGuard aGuard;
1783     return GetDoc().GetRefMarks();
1784 }
1785
1786 uno::Any SwXReferenceMarks::getByIndex(sal_Int32 nIndex)
1787 {
1788     if(0 <= nIndex && nIndex < SAL_MAX_UINT16)
1789     {
1790         SolarMutexGuard aGuard;
1791         auto& rDoc = GetDoc();
1792         if (auto* const pMark = const_cast<SwFormatRefMark*>(rDoc.GetRefMark(nIndex)))
1793             return uno::Any(
1794                 uno::Reference<XTextContent>(SwXReferenceMark::CreateXReferenceMark(rDoc, pMark)));
1795     }
1796     throw IndexOutOfBoundsException();
1797 }
1798
1799 uno::Any SwXReferenceMarks::getByName(const OUString& rName)
1800 {
1801     SolarMutexGuard aGuard;
1802     auto& rDoc = GetDoc();
1803     if (auto* const pMark = const_cast<SwFormatRefMark*>(rDoc.GetRefMark(rName)))
1804         return uno::Any(
1805             uno::Reference<XTextContent>(SwXReferenceMark::CreateXReferenceMark(rDoc, pMark)));
1806
1807     throw NoSuchElementException();
1808 }
1809
1810 uno::Sequence< OUString > SwXReferenceMarks::getElementNames()
1811 {
1812     SolarMutexGuard aGuard;
1813
1814     std::vector<OUString> aStrings;
1815     GetDoc().GetRefMarks(&aStrings);
1816
1817     return comphelper::containerToSequence(aStrings);
1818 }
1819
1820 sal_Bool SwXReferenceMarks::hasByName(const OUString& rName)
1821 {
1822     SolarMutexGuard aGuard;
1823     return nullptr != GetDoc().GetRefMark( rName);
1824 }
1825
1826 uno::Type SAL_CALL SwXReferenceMarks::getElementType()
1827 {
1828     return cppu::UnoType<XTextContent>::get();
1829 }
1830
1831 sal_Bool SwXReferenceMarks::hasElements()
1832 {
1833     SolarMutexGuard aGuard;
1834     return 0 != GetDoc().GetRefMarks();
1835 }
1836
1837 SwDoc& SwUnoCollection::GetDoc() const
1838 {
1839     DBG_TESTSOLARMUTEX();
1840     if (!m_pDoc)
1841         throw uno::RuntimeException();
1842     return *m_pDoc;
1843 }
1844
1845 void SwUnoCollection::Invalidate()
1846 {
1847     SolarMutexGuard aGuard;
1848     m_pDoc = nullptr;
1849 }
1850
1851 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */