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