LibreOffice Module sw (master)  1
unocoll.cxx
Go to the documentation of this file.
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 <svtools/unoimap.hxx>
36 #include <svtools/unoevent.hxx>
37 #include <unotbl.hxx>
38 #include <unostyle.hxx>
39 #include <unofield.hxx>
40 #include <unoidx.hxx>
41 #include <unoframe.hxx>
42 #include <textboxhelper.hxx>
43 #include <unofootnote.hxx>
44 #include <vcl/svapp.hxx>
45 #include <fmtcntnt.hxx>
46 #include <authfld.hxx>
47 #include <SwXTextDefaults.hxx>
48 #include <unochart.hxx>
49 #include <comphelper/sequence.hxx>
50 #include <cppuhelper/supportsservice.hxx>
51 #include <unosection.hxx>
52 #include <unoparagraph.hxx>
53 #include <unobookmark.hxx>
54 #include <unorefmark.hxx>
55 #include <unometa.hxx>
56 #include <docsh.hxx>
57 #include <hints.hxx>
58 #include <com/sun/star/document/XCodeNameQuery.hpp>
59 #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
60 #include <com/sun/star/form/XFormsSupplier.hpp>
61 #include <com/sun/star/script/ModuleInfo.hpp>
62 #include <com/sun/star/script/ModuleType.hpp>
63 #include <com/sun/star/script/vba/XVBAModuleInfo.hpp>
64 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
65 #include <vbahelper/vbaaccesshelper.hxx>
66 #include <basic/basmgr.hxx>
67 #include <comphelper/processfactory.hxx>
68 #include <cppuhelper/implbase.hxx>
69 #include <sfx2/event.hxx>
70 #include <sal/log.hxx>
71 
72 using namespace ::com::sun::star;
73 using namespace ::com::sun::star::document;
74 using namespace ::com::sun::star::uno;
75 using namespace ::com::sun::star::text;
76 using namespace ::com::sun::star::container;
77 using namespace ::com::sun::star::lang;
78 
79 #if HAVE_FEATURE_SCRIPTING
80 
81 namespace {
82 
83 class SwVbaCodeNameProvider : public ::cppu::WeakImplHelper< document::XCodeNameQuery >
84 {
85  SwDocShell* const mpDocShell;
86  OUString msThisDocumentCodeName;
87 public:
88  explicit SwVbaCodeNameProvider( SwDocShell* pDocShell ) : mpDocShell( pDocShell ) {}
89  // XCodeNameQuery
90 
91  OUString SAL_CALL getCodeNameForContainer( const uno::Reference< uno::XInterface >& /*xIf*/ ) override
92  {
93  // #FIXME not implemented...
94  return OUString();
95  }
96 
97  OUString SAL_CALL getCodeNameForObject( const uno::Reference< uno::XInterface >& xIf ) override
98  {
99  // Initialise the code name
100  if ( msThisDocumentCodeName.isEmpty() )
101  {
102  try
103  {
104  uno::Reference< beans::XPropertySet > xProps( mpDocShell->GetModel(), uno::UNO_QUERY_THROW );
105  uno::Reference< container::XNameAccess > xLibContainer( xProps->getPropertyValue("BasicLibraries"), uno::UNO_QUERY_THROW );
106  OUString sProjectName( "Standard");
107  if ( !mpDocShell->GetBasicManager()->GetName().isEmpty() )
108  {
109  sProjectName = mpDocShell->GetBasicManager()->GetName();
110  }
111  uno::Reference< container::XNameAccess > xLib( xLibContainer->getByName( sProjectName ), uno::UNO_QUERY_THROW );
112  uno::Sequence< OUString > sModuleNames = xLib->getElementNames();
113  uno::Reference< script::vba::XVBAModuleInfo > xVBAModuleInfo( xLib, uno::UNO_QUERY );
114 
115  auto pModuleName = std::find_if(sModuleNames.begin(), sModuleNames.end(), [&xVBAModuleInfo](const OUString& rName) {
116  return xVBAModuleInfo->hasModuleInfo(rName)
117  && xVBAModuleInfo->getModuleInfo(rName).ModuleType == script::ModuleType::DOCUMENT; });
118  if (pModuleName != sModuleNames.end())
119  msThisDocumentCodeName = *pModuleName;
120  }
121  catch( uno::Exception& )
122  {
123  }
124  }
125  OUString sCodeName;
126  if ( mpDocShell )
127  {
128  // need to find the page ( and index ) for this control
129  uno::Reference< drawing::XDrawPageSupplier > xSupplier( mpDocShell->GetModel(), uno::UNO_QUERY_THROW );
130  uno::Reference< container::XIndexAccess > xIndex( xSupplier->getDrawPage(), uno::UNO_QUERY_THROW );
131 
132  try
133  {
134  uno::Reference< form::XFormsSupplier > xFormSupplier( xIndex, uno::UNO_QUERY_THROW );
135  uno::Reference< container::XIndexAccess > xFormIndex( xFormSupplier->getForms(), uno::UNO_QUERY_THROW );
136  // get the www-standard container
137  uno::Reference< container::XIndexAccess > xFormControls( xFormIndex->getByIndex(0), uno::UNO_QUERY_THROW );
138  sal_Int32 nCntrls = xFormControls->getCount();
139  for( sal_Int32 cIndex = 0; cIndex < nCntrls; ++cIndex )
140  {
141  uno::Reference< uno::XInterface > xControl( xFormControls->getByIndex( cIndex ), uno::UNO_QUERY_THROW );
142  bool bMatched = ( xControl == xIf );
143  if ( bMatched )
144  {
145  sCodeName = msThisDocumentCodeName;
146  break;
147  }
148  }
149  }
150  catch( uno::Exception& )
151  {
152  }
153  }
154  // #TODO Probably should throw here ( if !bMatched )
155  return sCodeName;
156  }
157 };
158 
159 }
160 
161 typedef std::unordered_map< OUString, OUString > StringHashMap;
162 
163 namespace {
164 
165 class SwVbaProjectNameProvider : public ::cppu::WeakImplHelper< container::XNameContainer >
166 {
167  StringHashMap mTemplateToProject;
168 public:
169  SwVbaProjectNameProvider()
170  {
171  }
172  virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override
173  {
174  return ( mTemplateToProject.find( aName ) != mTemplateToProject.end() );
175  }
176  virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override
177  {
178  if ( !hasByName( aName ) )
179  throw container::NoSuchElementException();
180  return uno::makeAny( mTemplateToProject.find( aName )->second );
181  }
182  virtual css::uno::Sequence< OUString > SAL_CALL getElementNames( ) override
183  {
184  return comphelper::mapKeysToSequence( mTemplateToProject );
185  }
186 
187  virtual void SAL_CALL insertByName( const OUString& aName, const uno::Any& aElement ) override
188  {
189 
190  OUString sProjectName;
191  aElement >>= sProjectName;
192  SAL_INFO("sw.uno", "Template cache inserting template name " << aName
193  << " with project " << sProjectName);
194  mTemplateToProject[ aName ] = sProjectName;
195  }
196 
197  virtual void SAL_CALL removeByName( const OUString& Name ) override
198  {
199  if ( !hasByName( Name ) )
200  throw container::NoSuchElementException();
201  mTemplateToProject.erase( Name );
202  }
203  virtual void SAL_CALL replaceByName( const OUString& aName, const uno::Any& aElement ) override
204  {
205  if ( !hasByName( aName ) )
206  throw container::NoSuchElementException();
207  insertByName( aName, aElement ); // insert will overwrite
208  }
209  // XElemenAccess
210  virtual css::uno::Type SAL_CALL getElementType( ) override
211  {
212  return ::cppu::UnoType<OUString>::get();
213  }
214  virtual sal_Bool SAL_CALL hasElements( ) override
215  {
216 
217  return ( !mTemplateToProject.empty() );
218  }
219 
220 };
221 
222 class SwVbaObjectForCodeNameProvider : public ::cppu::WeakImplHelper< container::XNameAccess >
223 {
224  SwDocShell* const mpDocShell;
225 public:
226  explicit SwVbaObjectForCodeNameProvider( SwDocShell* pDocShell ) : mpDocShell( pDocShell )
227  {
228  // #FIXME #TODO is the code name for ThisDocument read anywhere?
229  }
230 
231  virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override
232  {
233  // #FIXME #TODO we really need to be checking against the codename for
234  // ThisDocument
235  if ( aName == "ThisDocument" )
236  return true;
237  return false;
238  }
239 
240  css::uno::Any SAL_CALL getByName( const OUString& aName ) override
241  {
242  if ( !hasByName( aName ) )
243  throw container::NoSuchElementException();
244  uno::Sequence< uno::Any > aArgs( 2 );
245  aArgs[0] <<= uno::Reference< uno::XInterface >();
246  aArgs[1] <<= mpDocShell->GetModel();
247  uno::Reference< uno::XInterface > xDocObj = ooo::vba::createVBAUnoAPIServiceWithArgs( mpDocShell, "ooo.vba.word.Document" , aArgs );
248  SAL_INFO("sw.uno",
249  "Creating Object ( ooo.vba.word.Document ) 0x" << xDocObj.get());
250  return uno::makeAny( xDocObj );
251  }
252  virtual css::uno::Sequence< OUString > SAL_CALL getElementNames( ) override
253  {
254  uno::Sequence< OUString > aNames;
255  return aNames;
256  }
257  // XElemenAccess
258  virtual css::uno::Type SAL_CALL getElementType( ) override { return uno::Type(); }
259  virtual sal_Bool SAL_CALL hasElements( ) override { return true; }
260 
261 };
262 
263 }
264 
265 #endif
266 
267 namespace {
268 
269 struct ProvNamesId_Type
270 {
271  const char * pName;
272  SwServiceType const nType;
273 };
274 
275 }
276 
277 // note: this thing is indexed as an array, so do not insert/remove entries!
278 const ProvNamesId_Type aProvNamesId[] =
279 {
280  { "com.sun.star.text.TextTable", SwServiceType::TypeTextTable },
281  { "com.sun.star.text.TextFrame", SwServiceType::TypeTextFrame },
282  { "com.sun.star.text.GraphicObject", SwServiceType::TypeGraphic },
283  { "com.sun.star.text.TextEmbeddedObject", SwServiceType::TypeOLE },
284  { "com.sun.star.text.Bookmark", SwServiceType::TypeBookmark },
285  { "com.sun.star.text.Footnote", SwServiceType::TypeFootnote },
286  { "com.sun.star.text.Endnote", SwServiceType::TypeEndnote },
287  { "com.sun.star.text.DocumentIndexMark", SwServiceType::TypeIndexMark },
288  { "com.sun.star.text.DocumentIndex", SwServiceType::TypeIndex },
289  { "com.sun.star.text.ReferenceMark", SwServiceType::ReferenceMark },
290  { "com.sun.star.style.CharacterStyle", SwServiceType::StyleCharacter },
291  { "com.sun.star.style.ParagraphStyle", SwServiceType::StyleParagraph },
292  { "com.sun.star.style.FrameStyle", SwServiceType::StyleFrame },
293  { "com.sun.star.style.PageStyle", SwServiceType::StylePage },
294  { "com.sun.star.style.NumberingStyle", SwServiceType::StyleNumbering },
295  { "com.sun.star.text.ContentIndexMark", SwServiceType::ContentIndexMark },
296  { "com.sun.star.text.ContentIndex", SwServiceType::ContentIndex },
297  { "com.sun.star.text.UserIndexMark", SwServiceType::UserIndexMark },
298  { "com.sun.star.text.UserIndex", SwServiceType::UserIndex },
299  { "com.sun.star.text.TextSection", SwServiceType::TextSection },
300  { "com.sun.star.text.TextField.DateTime", SwServiceType::FieldTypeDateTime },
301  { "com.sun.star.text.TextField.User", SwServiceType::FieldTypeUser },
302  { "com.sun.star.text.TextField.SetExpression", SwServiceType::FieldTypeSetExp },
303  { "com.sun.star.text.TextField.GetExpression", SwServiceType::FieldTypeGetExp },
304  { "com.sun.star.text.TextField.FileName", SwServiceType::FieldTypeFileName },
305  { "com.sun.star.text.TextField.PageNumber", SwServiceType::FieldTypePageNum },
306  { "com.sun.star.text.TextField.Author", SwServiceType::FieldTypeAuthor },
307  { "com.sun.star.text.TextField.Chapter", SwServiceType::FieldTypeChapter },
308  { "", SwServiceType::FieldTypeDummy0 },
309  { "com.sun.star.text.TextField.GetReference", SwServiceType::FieldTypeGetReference },
310  { "com.sun.star.text.TextField.ConditionalText", SwServiceType::FieldTypeConditionedText },
311  { "com.sun.star.text.TextField.Annotation", SwServiceType::FieldTypeAnnotation },
312  { "com.sun.star.text.TextField.Input", SwServiceType::FieldTypeInput },
313  { "com.sun.star.text.TextField.Macro", SwServiceType::FieldTypeMacro },
314  { "com.sun.star.text.TextField.DDE", SwServiceType::FieldTypeDDE },
315  { "com.sun.star.text.TextField.HiddenParagraph", SwServiceType::FieldTypeHiddenPara },
316  { "" /*com.sun.star.text.TextField.DocumentInfo"*/, SwServiceType::FieldTypeDocInfo },
317  { "com.sun.star.text.TextField.TemplateName", SwServiceType::FieldTypeTemplateName },
318  { "com.sun.star.text.TextField.ExtendedUser", SwServiceType::FieldTypeUserExt },
319  { "com.sun.star.text.TextField.ReferencePageSet", SwServiceType::FieldTypeRefPageSet },
320  { "com.sun.star.text.TextField.ReferencePageGet", SwServiceType::FieldTypeRefPageGet },
321  { "com.sun.star.text.TextField.JumpEdit", SwServiceType::FieldTypeJumpEdit },
322  { "com.sun.star.text.TextField.Script", SwServiceType::FieldTypeScript },
323  { "com.sun.star.text.TextField.DatabaseNextSet", SwServiceType::FieldTypeDatabaseNextSet },
324  { "com.sun.star.text.TextField.DatabaseNumberOfSet", SwServiceType::FieldTypeDatabaseNumSet },
325  { "com.sun.star.text.TextField.DatabaseSetNumber", SwServiceType::FieldTypeDatabaseSetNum },
326  { "com.sun.star.text.TextField.Database", SwServiceType::FieldTypeDatabase },
327  { "com.sun.star.text.TextField.DatabaseName", SwServiceType::FieldTypeDatabaseName },
328  { "com.sun.star.text.TextField.TableFormula", SwServiceType::FieldTypeTableFormula },
329  { "com.sun.star.text.TextField.PageCount", SwServiceType::FieldTypePageCount },
330  { "com.sun.star.text.TextField.ParagraphCount", SwServiceType::FieldTypeParagraphCount },
331  { "com.sun.star.text.TextField.WordCount", SwServiceType::FieldTypeWordCount },
332  { "com.sun.star.text.TextField.CharacterCount", SwServiceType::FieldTypeCharacterCount },
333  { "com.sun.star.text.TextField.TableCount", SwServiceType::FieldTypeTableCount },
334  { "com.sun.star.text.TextField.GraphicObjectCount", SwServiceType::FieldTypeGraphicObjectCount },
335  { "com.sun.star.text.TextField.EmbeddedObjectCount", SwServiceType::FieldTypeEmbeddedObjectCount },
336  { "com.sun.star.text.TextField.DocInfo.ChangeAuthor", SwServiceType::FieldTypeDocInfoChangeAuthor },
337  { "com.sun.star.text.TextField.DocInfo.ChangeDateTime", SwServiceType::FieldTypeDocInfoChangeDateTime },
338  { "com.sun.star.text.TextField.DocInfo.EditTime", SwServiceType::FieldTypeDocInfoEditTime },
339  { "com.sun.star.text.TextField.DocInfo.Description", SwServiceType::FieldTypeDocInfoDescription },
340  { "com.sun.star.text.TextField.DocInfo.CreateAuthor", SwServiceType::FieldTypeDocInfoCreateAuthor },
341  { "com.sun.star.text.TextField.DocInfo.CreateDateTime", SwServiceType::FieldTypeDocInfoCreateDateTime },
342  { "", SwServiceType::FieldTypeDummy0 },
343  { "", SwServiceType::FieldTypeDummy1 },
344  { "", SwServiceType::FieldTypeDummy2 },
345  { "", SwServiceType::FieldTypeDummy3 },
346  { "com.sun.star.text.TextField.DocInfo.Custom", SwServiceType::FieldTypeDocInfoCustom },
347  { "com.sun.star.text.TextField.DocInfo.PrintAuthor", SwServiceType::FieldTypeDocInfoPrintAuthor },
348  { "com.sun.star.text.TextField.DocInfo.PrintDateTime", SwServiceType::FieldTypeDocInfoPrintDateTime },
349  { "com.sun.star.text.TextField.DocInfo.KeyWords", SwServiceType::FieldTypeDocInfoKeywords },
350  { "com.sun.star.text.TextField.DocInfo.Subject", SwServiceType::FieldTypeDocInfoSubject },
351  { "com.sun.star.text.TextField.DocInfo.Title", SwServiceType::FieldTypeDocInfoTitle },
352  { "com.sun.star.text.TextField.DocInfo.Revision", SwServiceType::FieldTypeDocInfoRevision },
353  { "com.sun.star.text.TextField.Bibliography", SwServiceType::FieldTypeBibliography },
354  { "com.sun.star.text.TextField.CombinedCharacters", SwServiceType::FieldTypeCombinedCharacters },
355  { "com.sun.star.text.TextField.DropDown", SwServiceType::FieldTypeDropdown },
356  { "com.sun.star.text.textfield.MetadataField", SwServiceType::FieldTypeMetafield },
357  { "", SwServiceType::FieldTypeDummy4 },
358  { "", SwServiceType::FieldTypeDummy5 },
359  { "", SwServiceType::FieldTypeDummy6 },
360  { "", SwServiceType::FieldTypeDummy7 },
361  { "com.sun.star.text.FieldMaster.User", SwServiceType::FieldMasterUser },
362  { "com.sun.star.text.FieldMaster.DDE", SwServiceType::FieldMasterDDE },
363  { "com.sun.star.text.FieldMaster.SetExpression", SwServiceType::FieldMasterSetExp },
364  { "com.sun.star.text.FieldMaster.Database", SwServiceType::FieldMasterDatabase },
365  { "com.sun.star.text.FieldMaster.Bibliography", SwServiceType::FieldMasterBibliography },
366  { "", SwServiceType::FieldMasterDummy2 },
367  { "", SwServiceType::FieldMasterDummy3 },
368  { "", SwServiceType::FieldMasterDummy4 },
369  { "", SwServiceType::FieldMasterDummy5 },
370  { "com.sun.star.text.IllustrationsIndex", SwServiceType::IndexIllustrations },
371  { "com.sun.star.text.ObjectIndex", SwServiceType::IndexObjects },
372  { "com.sun.star.text.TableIndex", SwServiceType::IndexTables },
373  { "com.sun.star.text.Bibliography", SwServiceType::IndexBibliography },
374  { "com.sun.star.text.Paragraph", SwServiceType::Paragraph },
375  { "com.sun.star.text.TextField.InputUser", SwServiceType::FieldTypeInputUser },
376  { "com.sun.star.text.TextField.HiddenText", SwServiceType::FieldTypeHiddenText },
377  { "com.sun.star.style.ConditionalParagraphStyle", SwServiceType::StyleConditionalParagraph },
378  { "com.sun.star.text.NumberingRules", SwServiceType::NumberingRules },
379  { "com.sun.star.text.TextColumns", SwServiceType::TextColumns },
380  { "com.sun.star.text.IndexHeaderSection", SwServiceType::IndexHeaderSection },
381  { "com.sun.star.text.Defaults", SwServiceType::Defaults },
382  { "com.sun.star.image.ImageMapRectangleObject", SwServiceType::IMapRectangle },
383  { "com.sun.star.image.ImageMapCircleObject", SwServiceType::IMapCircle },
384  { "com.sun.star.image.ImageMapPolygonObject", SwServiceType::IMapPolygon },
385  { "com.sun.star.text.TextGraphicObject", SwServiceType::TypeTextGraphic },
386  { "com.sun.star.chart2.data.DataProvider", SwServiceType::Chart2DataProvider },
387  { "com.sun.star.text.Fieldmark", SwServiceType::TypeFieldMark },
388  { "com.sun.star.text.FormFieldmark", SwServiceType::TypeFormFieldMark },
389  { "com.sun.star.text.InContentMetadata", SwServiceType::TypeMeta },
390  { "ooo.vba.VBAObjectModuleObjectProvider", SwServiceType::VbaObjectProvider },
391  { "ooo.vba.VBACodeNameProvider", SwServiceType::VbaCodeNameProvider },
392  { "ooo.vba.VBAProjectNameProvider", SwServiceType::VbaProjectNameProvider },
393  { "ooo.vba.VBAGlobals", SwServiceType::VbaGlobals },
394 
395  // case-correct versions of the service names (see #i67811)
396  { CSS_TEXT_TEXTFIELD_DATE_TIME, SwServiceType::FieldTypeDateTime },
397  { CSS_TEXT_TEXTFIELD_USER, SwServiceType::FieldTypeUser },
398  { CSS_TEXT_TEXTFIELD_SET_EXPRESSION, SwServiceType::FieldTypeSetExp },
399  { CSS_TEXT_TEXTFIELD_GET_EXPRESSION, SwServiceType::FieldTypeGetExp },
400  { CSS_TEXT_TEXTFIELD_FILE_NAME, SwServiceType::FieldTypeFileName },
401  { CSS_TEXT_TEXTFIELD_PAGE_NUMBER, SwServiceType::FieldTypePageNum },
402  { CSS_TEXT_TEXTFIELD_AUTHOR, SwServiceType::FieldTypeAuthor },
403  { CSS_TEXT_TEXTFIELD_CHAPTER, SwServiceType::FieldTypeChapter },
404  { CSS_TEXT_TEXTFIELD_GET_REFERENCE, SwServiceType::FieldTypeGetReference },
405  { CSS_TEXT_TEXTFIELD_CONDITIONAL_TEXT, SwServiceType::FieldTypeConditionedText },
406  { CSS_TEXT_TEXTFIELD_ANNOTATION, SwServiceType::FieldTypeAnnotation },
407  { CSS_TEXT_TEXTFIELD_INPUT, SwServiceType::FieldTypeInput },
408  { CSS_TEXT_TEXTFIELD_MACRO, SwServiceType::FieldTypeMacro },
409  { CSS_TEXT_TEXTFIELD_DDE, SwServiceType::FieldTypeDDE },
410  { CSS_TEXT_TEXTFIELD_HIDDEN_PARAGRAPH, SwServiceType::FieldTypeHiddenPara },
411  { CSS_TEXT_TEXTFIELD_TEMPLATE_NAME, SwServiceType::FieldTypeTemplateName },
412  { CSS_TEXT_TEXTFIELD_EXTENDED_USER, SwServiceType::FieldTypeUserExt },
413  { CSS_TEXT_TEXTFIELD_REFERENCE_PAGE_SET, SwServiceType::FieldTypeRefPageSet },
414  { CSS_TEXT_TEXTFIELD_REFERENCE_PAGE_GET, SwServiceType::FieldTypeRefPageGet },
415  { CSS_TEXT_TEXTFIELD_JUMP_EDIT, SwServiceType::FieldTypeJumpEdit },
416  { CSS_TEXT_TEXTFIELD_SCRIPT, SwServiceType::FieldTypeScript },
417  { CSS_TEXT_TEXTFIELD_DATABASE_NEXT_SET, SwServiceType::FieldTypeDatabaseNextSet },
418  { CSS_TEXT_TEXTFIELD_DATABASE_NUMBER_OF_SET, SwServiceType::FieldTypeDatabaseNumSet },
419  { CSS_TEXT_TEXTFIELD_DATABASE_SET_NUMBER, SwServiceType::FieldTypeDatabaseSetNum },
420  { CSS_TEXT_TEXTFIELD_DATABASE, SwServiceType::FieldTypeDatabase },
421  { CSS_TEXT_TEXTFIELD_DATABASE_NAME, SwServiceType::FieldTypeDatabaseName },
422  { CSS_TEXT_TEXTFIELD_TABLE_FORMULA, SwServiceType::FieldTypeTableFormula },
423  { CSS_TEXT_TEXTFIELD_PAGE_COUNT, SwServiceType::FieldTypePageCount },
424  { CSS_TEXT_TEXTFIELD_PARAGRAPH_COUNT, SwServiceType::FieldTypeParagraphCount },
425  { CSS_TEXT_TEXTFIELD_WORD_COUNT, SwServiceType::FieldTypeWordCount },
426  { CSS_TEXT_TEXTFIELD_CHARACTER_COUNT, SwServiceType::FieldTypeCharacterCount },
427  { CSS_TEXT_TEXTFIELD_TABLE_COUNT, SwServiceType::FieldTypeTableCount },
428  { CSS_TEXT_TEXTFIELD_GRAPHIC_OBJECT_COUNT, SwServiceType::FieldTypeGraphicObjectCount },
429  { CSS_TEXT_TEXTFIELD_EMBEDDED_OBJECT_COUNT, SwServiceType::FieldTypeEmbeddedObjectCount },
430  { CSS_TEXT_TEXTFIELD_DOCINFO_CHANGE_AUTHOR, SwServiceType::FieldTypeDocInfoChangeAuthor },
431  { CSS_TEXT_TEXTFIELD_DOCINFO_CHANGE_DATE_TIME, SwServiceType::FieldTypeDocInfoChangeDateTime },
432  { CSS_TEXT_TEXTFIELD_DOCINFO_EDIT_TIME, SwServiceType::FieldTypeDocInfoEditTime },
433  { CSS_TEXT_TEXTFIELD_DOCINFO_DESCRIPTION, SwServiceType::FieldTypeDocInfoDescription },
434  { CSS_TEXT_TEXTFIELD_DOCINFO_CREATE_AUTHOR, SwServiceType::FieldTypeDocInfoCreateAuthor },
435  { CSS_TEXT_TEXTFIELD_DOCINFO_CREATE_DATE_TIME, SwServiceType::FieldTypeDocInfoCreateDateTime },
436  { CSS_TEXT_TEXTFIELD_DOCINFO_PRINT_AUTHOR, SwServiceType::FieldTypeDocInfoPrintAuthor },
437  { CSS_TEXT_TEXTFIELD_DOCINFO_PRINT_DATE_TIME, SwServiceType::FieldTypeDocInfoPrintDateTime },
438  { CSS_TEXT_TEXTFIELD_DOCINFO_KEY_WORDS, SwServiceType::FieldTypeDocInfoKeywords },
439  { CSS_TEXT_TEXTFIELD_DOCINFO_SUBJECT, SwServiceType::FieldTypeDocInfoSubject },
440  { CSS_TEXT_TEXTFIELD_DOCINFO_TITLE, SwServiceType::FieldTypeDocInfoTitle },
441  { CSS_TEXT_TEXTFIELD_DOCINFO_REVISION, SwServiceType::FieldTypeDocInfoRevision },
442  { CSS_TEXT_TEXTFIELD_DOCINFO_CUSTOM, SwServiceType::FieldTypeDocInfoCustom },
443  { CSS_TEXT_TEXTFIELD_BIBLIOGRAPHY, SwServiceType::FieldTypeBibliography },
444  { CSS_TEXT_TEXTFIELD_COMBINED_CHARACTERS, SwServiceType::FieldTypeCombinedCharacters },
445  { CSS_TEXT_TEXTFIELD_DROP_DOWN, SwServiceType::FieldTypeDropdown },
446  { CSS_TEXT_TEXTFIELD_INPUT_USER, SwServiceType::FieldTypeInputUser },
447  { CSS_TEXT_TEXTFIELD_HIDDEN_TEXT, SwServiceType::FieldTypeHiddenText },
448  { CSS_TEXT_FIELDMASTER_USER, SwServiceType::FieldMasterUser },
449  { CSS_TEXT_FIELDMASTER_DDE, SwServiceType::FieldMasterDDE },
450  { CSS_TEXT_FIELDMASTER_SET_EXPRESSION, SwServiceType::FieldMasterSetExp },
451  { CSS_TEXT_FIELDMASTER_DATABASE, SwServiceType::FieldMasterDatabase },
452  { CSS_TEXT_FIELDMASTER_BIBLIOGRAPHY, SwServiceType::FieldMasterBibliography },
453  { "com.sun.star.style.TableStyle", SwServiceType::StyleTable },
454  { "com.sun.star.style.CellStyle", SwServiceType::StyleCell }
455 };
456 
457 const SvEventDescription* sw_GetSupportedMacroItems()
458 {
459  static const SvEventDescription aMacroDescriptionsImpl[] =
460  {
461  { SvMacroItemId::OnMouseOver, "OnMouseOver" },
462  { SvMacroItemId::OnMouseOut, "OnMouseOut" },
463  { SvMacroItemId::NONE, nullptr }
464  };
465 
466  return aMacroDescriptionsImpl;
467 }
468 
469 OUString SwXServiceProvider::GetProviderName(SwServiceType nObjectType)
470 {
471  SolarMutexGuard aGuard;
472  OUString sRet;
473  const sal_uInt16 nEntries = SAL_N_ELEMENTS(aProvNamesId);
474  if(static_cast<sal_uInt16>(nObjectType) < nEntries)
475  sRet = OUString::createFromAscii(aProvNamesId[static_cast<sal_uInt16>(nObjectType)].pName);
476  return sRet;
477 }
478 
479 uno::Sequence<OUString> SwXServiceProvider::GetAllServiceNames()
480 {
481  const sal_uInt16 nEntries = SAL_N_ELEMENTS(aProvNamesId);
482  uno::Sequence<OUString> aRet(nEntries);
483  OUString* pArray = aRet.getArray();
484  sal_uInt16 n = 0;
485  for(const ProvNamesId_Type & i : aProvNamesId)
486  {
487  OUString sProv(OUString::createFromAscii(i.pName));
488  if(!sProv.isEmpty())
489  {
490  pArray[n] = sProv;
491  n++;
492  }
493  }
494  aRet.realloc(n);
495  return aRet;
496 
497 }
498 
499 SwServiceType SwXServiceProvider::GetProviderType(const OUString& rServiceName)
500 {
501  for(const ProvNamesId_Type & i : aProvNamesId)
502  {
503  if (rServiceName.equalsAscii(i.pName))
504  return i.nType;
505  }
506  return SwServiceType::Invalid;
507 }
508 
509 uno::Reference<uno::XInterface>
510 SwXServiceProvider::MakeInstance(SwServiceType nObjectType, SwDoc & rDoc)
511 {
512  SolarMutexGuard aGuard;
513  uno::Reference< uno::XInterface > xRet;
514  switch(nObjectType)
515  {
516  case SwServiceType::TypeTextTable:
517  {
518  xRet = SwXTextTable::CreateXTextTable(nullptr);
519  }
520  break;
521  case SwServiceType::TypeTextFrame:
522  {
523  xRet = SwXTextFrame::CreateXTextFrame(rDoc, nullptr);
524  }
525  break;
526  case SwServiceType::TypeGraphic :
527  case SwServiceType::TypeTextGraphic /* #i47503# */ :
528  {
529  xRet = SwXTextGraphicObject::CreateXTextGraphicObject(rDoc, nullptr);
530 
531  }
532  break;
533  case SwServiceType::TypeOLE :
534  {
535  xRet = SwXTextEmbeddedObject::CreateXTextEmbeddedObject(rDoc, nullptr);
536  }
537  break;
538  case SwServiceType::TypeBookmark :
539  {
540  xRet = SwXBookmark::CreateXBookmark(rDoc, nullptr);
541  }
542  break;
543  case SwServiceType::TypeFieldMark :
544  {
545  xRet = SwXFieldmark::CreateXFieldmark(rDoc, nullptr);
546  }
547  break;
548  case SwServiceType::TypeFormFieldMark :
549  {
550  xRet = SwXFieldmark::CreateXFieldmark(rDoc, nullptr, true);
551  }
552  break;
553  case SwServiceType::VbaObjectProvider :
554 #if HAVE_FEATURE_SCRIPTING
555  {
556  SwVbaObjectForCodeNameProvider* pObjProv =
557  new SwVbaObjectForCodeNameProvider(rDoc.GetDocShell());
558  xRet = static_cast<cppu::OWeakObject*>(pObjProv);
559  }
560 #endif
561  break;
562  case SwServiceType::VbaCodeNameProvider :
563 #if HAVE_FEATURE_SCRIPTING
564  {
565  if (rDoc.GetDocShell() && ooo::vba::isAlienWordDoc(*rDoc.GetDocShell()))
566  {
567  SwVbaCodeNameProvider* pObjProv = new SwVbaCodeNameProvider(rDoc.GetDocShell());
568  xRet = static_cast<cppu::OWeakObject*>(pObjProv);
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 = static_cast<cppu::OWeakObject*>(new SwXTextColumns);
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 clipoard
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 );
835 SwXTextTables::SwXTextTables(SwDoc* pDc) :
836  SwUnoCollection(pDc)
837 {
838 
839 }
840 
841 SwXTextTables::~SwXTextTables()
842 {
843 
844 }
845 
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 
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 
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 
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 
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
952  SwXTextTables::getElementType( )
953 {
954  return cppu::UnoType<XTextTable>::get();
955 }
956 
957 sal_Bool SwXTextTables::hasElements()
958 {
959  SolarMutexGuard aGuard;
960  if(!IsValid())
961  throw uno::RuntimeException();
962  return 0 != GetDoc()->GetTableFrameFormatCount(true);
963 }
964 
965 OUString SwXTextTables::getImplementationName()
966 {
967  return "SwXTextTables";
968 }
969 
970 sal_Bool SwXTextTables::supportsService(const OUString& rServiceName)
971 {
972  return cppu::supportsService(this, rServiceName);
973 }
974 
975 uno::Sequence< OUString > SwXTextTables::getSupportedServiceNames()
976 {
977  return { "com.sun.star.text.TextTables" };
978 }
979 
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  {
992  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  }
998  static bool filter(const SwNode* const pNode) { return !pNode->IsNoTextNode(); };
999  };
1000 
1001  template<>
1002  struct UnoFrameWrap_traits<FLYCNTTYPE_GRF>
1003  {
1004  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  }
1010  static bool filter(const SwNode* const pNode) { return pNode->IsGrfNode(); };
1011  };
1012 
1013  template<>
1014  struct UnoFrameWrap_traits<FLYCNTTYPE_OLE>
1015  {
1016  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  }
1022  static bool filter(const SwNode* const pNode) { return pNode->IsOLENode(); };
1023  };
1024 
1025  template<FlyCntType T>
1026  uno::Any lcl_UnoWrapFrame(SwFrameFormat* pFormat)
1027  {
1028  return UnoFrameWrap_traits<T>::wrapFrame(*pFormat);
1029  }
1030 
1031  // runtime adapter for lcl_UnoWrapFrame
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:
1055  virtual ~SwXFrameEnumeration() override {};
1056  public:
1057  SwXFrameEnumeration(const SwDoc* const pDoc);
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>
1071 SwXFrameEnumeration<T>::SwXFrameEnumeration(const SwDoc* const pDoc)
1072  : m_aFrames()
1073 {
1074  SolarMutexGuard aGuard;
1075  const SwFrameFormats* const pFormats = pDoc->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 = pDoc->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 "SwXFrameEnumeration";
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 { OUString("com.sun.star.container.XEnumeration") };
1132 }
1133 
1134 OUString SwXFrames::getImplementationName()
1135 {
1136  return "SwXFrames";
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 { OUString("com.sun.star.text.TextFrames") };
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  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 
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 
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 
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 
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 
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 
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 
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 
1282 OUString SwXTextFrames::getImplementationName()
1283 {
1284  return "SwXTextFrames";
1285 }
1286 
1287 sal_Bool SwXTextFrames::supportsService(const OUString& rServiceName)
1288 {
1289  return cppu::supportsService(this, rServiceName);
1290 }
1291 
1292 Sequence< OUString > SwXTextFrames::getSupportedServiceNames()
1293 {
1294  return { "com.sun.star.text.TextFrames" };
1295 }
1296 
1297 SwXTextFrames::SwXTextFrames(SwDoc* _pDoc) :
1298  SwXFrames(_pDoc, FLYCNTTYPE_FRM)
1299 {
1300 }
1301 
1302 SwXTextFrames::~SwXTextFrames()
1303 {
1304 }
1305 
1306 OUString SwXTextGraphicObjects::getImplementationName()
1307 {
1308  return "SwXTextGraphicObjects";
1309 }
1310 
1311 sal_Bool SwXTextGraphicObjects::supportsService(const OUString& rServiceName)
1312 {
1313  return cppu::supportsService(this, rServiceName);
1314 }
1315 
1316 Sequence< OUString > SwXTextGraphicObjects::getSupportedServiceNames()
1317 {
1318  return { "com.sun.star.text.TextGraphicObjects" };
1319 }
1320 
1321 SwXTextGraphicObjects::SwXTextGraphicObjects(SwDoc* _pDoc) :
1322  SwXFrames(_pDoc, FLYCNTTYPE_GRF)
1323 {
1324 }
1325 
1326 SwXTextGraphicObjects::~SwXTextGraphicObjects()
1327 {
1328 }
1329 
1330 OUString SwXTextEmbeddedObjects::getImplementationName()
1331 {
1332  return "SwXTextEmbeddedObjects";
1333 }
1334 
1335 sal_Bool SwXTextEmbeddedObjects::supportsService(const OUString& rServiceName)
1336 {
1337  return cppu::supportsService(this, rServiceName);
1338 }
1339 
1340 Sequence< OUString > SwXTextEmbeddedObjects::getSupportedServiceNames()
1341 {
1342  return { "com.sun.star.text.TextEmbeddedObjects" };
1343 }
1344 
1345 SwXTextEmbeddedObjects::SwXTextEmbeddedObjects(SwDoc* _pDoc) :
1346  SwXFrames(_pDoc, FLYCNTTYPE_OLE)
1347 {
1348 }
1349 
1350 SwXTextEmbeddedObjects::~SwXTextEmbeddedObjects()
1351 {
1352 }
1353 
1354 OUString SwXTextSections::getImplementationName()
1355 {
1356  return "SwXTextSections";
1357 }
1358 
1359 sal_Bool SwXTextSections::supportsService(const OUString& rServiceName)
1360 {
1361  return cppu::supportsService(this, rServiceName);
1362 }
1363 
1364 Sequence< OUString > SwXTextSections::getSupportedServiceNames()
1365 {
1366  return { "com.sun.star.text.TextSections" };
1367 }
1368 
1369 SwXTextSections::SwXTextSections(SwDoc* _pDoc) :
1370  SwUnoCollection(_pDoc)
1371 {
1372 }
1373 
1374 SwXTextSections::~SwXTextSections()
1375 {
1376 }
1377 
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 
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 && static_cast<size_t>(nIndex) < rFormats.size()))
1414  throw IndexOutOfBoundsException();
1415 
1416  SwSectionFormat* pFormat = rFormats[nIndex];
1417  xRet = GetObject(*pFormat);
1418 
1419  return makeAny(xRet);
1420 }
1421 
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 
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 
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 
1506 uno::Type SAL_CALL SwXTextSections::getElementType()
1507 {
1508  return cppu::UnoType<XTextSection>::get();
1509 }
1510 
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 
1524 uno::Reference< XTextSection > SwXTextSections::GetObject( SwSectionFormat& rFormat )
1525 {
1526  return SwXTextSection::CreateXTextSection(&rFormat);
1527 }
1528 
1529 OUString SwXBookmarks::getImplementationName()
1530 {
1531  return "SwXBookmarks";
1532 }
1533 
1534 sal_Bool SwXBookmarks::supportsService(const OUString& rServiceName)
1535 {
1536  return cppu::supportsService(this, rServiceName);
1537 }
1538 
1539 Sequence< OUString > SwXBookmarks::getSupportedServiceNames()
1540 {
1541  return { "com.sun.star.text.Bookmarks" };
1542 }
1543 
1544 SwXBookmarks::SwXBookmarks(SwDoc* _pDoc) :
1545  SwUnoCollection(_pDoc)
1546 { }
1547 
1548 SwXBookmarks::~SwXBookmarks()
1549 { }
1550 
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 
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 
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 
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 
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 
1652 uno::Type SAL_CALL SwXBookmarks::getElementType()
1653 {
1654  return cppu::UnoType<XTextContent>::get();
1655 }
1656 
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 
1677 SwXNumberingRulesCollection::SwXNumberingRulesCollection( SwDoc* _pDoc ) :
1678  SwUnoCollection(_pDoc)
1679 {
1680 }
1681 
1682 SwXNumberingRulesCollection::~SwXNumberingRulesCollection()
1683 {
1684 }
1685 
1686 sal_Int32 SwXNumberingRulesCollection::getCount()
1687 {
1688  SolarMutexGuard aGuard;
1689  if(!IsValid())
1690  throw uno::RuntimeException();
1691  return GetDoc()->GetNumRuleTable().size();
1692 }
1693 
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 ( static_cast<size_t>(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 
1714 uno::Type SAL_CALL SwXNumberingRulesCollection::getElementType()
1715 {
1716  return cppu::UnoType<XIndexReplace>::get();
1717 }
1718 
1719 sal_Bool SwXNumberingRulesCollection::hasElements()
1720 {
1721  SolarMutexGuard aGuard;
1722  if(!IsValid())
1723  throw uno::RuntimeException();
1724  return !GetDoc()->GetNumRuleTable().empty();
1725 }
1726 
1727 OUString SwXFootnotes::getImplementationName()
1728 {
1729  return "SwXFootnotes";
1730 }
1731 
1732 sal_Bool SwXFootnotes::supportsService(const OUString& rServiceName)
1733 {
1734  return cppu::supportsService(this, rServiceName);
1735 }
1736 
1737 Sequence< OUString > SwXFootnotes::getSupportedServiceNames()
1738 {
1739  return { "com.sun.star.text.Footnotes" };
1740 }
1741 
1742 SwXFootnotes::SwXFootnotes(bool bEnd, SwDoc* _pDoc)
1743  : SwUnoCollection(_pDoc)
1744  , m_bEndnote(bEnd)
1745 {
1746 }
1747 
1748 SwXFootnotes::~SwXFootnotes()
1749 {
1750 }
1751 
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 
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 
1804 uno::Type SAL_CALL SwXFootnotes::getElementType()
1805 {
1806  return cppu::UnoType<XFootnote>::get();
1807 }
1808 
1809 sal_Bool SwXFootnotes::hasElements()
1810 {
1811  SolarMutexGuard aGuard;
1812  if(!IsValid())
1813  throw uno::RuntimeException();
1814  return !GetDoc()->GetFootnoteIdxs().empty();
1815 }
1816 
1817 Reference<XFootnote> SwXFootnotes::GetObject( SwDoc& rDoc, const SwFormatFootnote& rFormat )
1818 {
1819  return SwXFootnote::CreateXFootnote(rDoc, &const_cast<SwFormatFootnote&>(rFormat));
1820 }
1821 
1822 OUString SwXReferenceMarks::getImplementationName()
1823 {
1824  return "SwXReferenceMarks";
1825 }
1826 
1827 sal_Bool SwXReferenceMarks::supportsService(const OUString& rServiceName)
1828 {
1829  return cppu::supportsService(this, rServiceName);
1830 }
1831 
1832 Sequence< OUString > SwXReferenceMarks::getSupportedServiceNames()
1833 {
1834  return { "com.sun.star.text.ReferenceMarks" };
1835 }
1836 
1837 SwXReferenceMarks::SwXReferenceMarks(SwDoc* _pDoc) :
1838  SwUnoCollection(_pDoc)
1839 {
1840 }
1841 
1842 SwXReferenceMarks::~SwXReferenceMarks()
1843 {
1844 }
1845 
1846 sal_Int32 SwXReferenceMarks::getCount()
1847 {
1848  SolarMutexGuard aGuard;
1849  if(!IsValid())
1850  throw uno::RuntimeException();
1851  return GetDoc()->GetRefMarks();
1852 }
1853 
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(static_cast<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 
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 
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 
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 
1920 uno::Type SAL_CALL SwXReferenceMarks::getElementType()
1921 {
1922  return cppu::UnoType<XTextContent>::get();
1923 }
1924 
1925 sal_Bool SwXReferenceMarks::hasElements()
1926 {
1927  SolarMutexGuard aGuard;
1928  if(!IsValid())
1929  throw uno::RuntimeException();
1930  return 0 != GetDoc()->GetRefMarks();
1931 }
1932 
1933 void SwUnoCollection::Invalidate()
1934 {
1935  m_bObjectValid = false;
1936  m_pDoc = nullptr;
1937 }
1938 
1939 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
sw::proofreadingiterator::get
css::uno::Reference< css::linguistic2::XProofreadingIterator > get(css::uno::Reference< css::uno::XComponentContext > const &context)
Definition: proofreadingiterator.cxx:40
CSS_TEXT_TEXTFIELD_DOCINFO_KEY_WORDS
#define CSS_TEXT_TEXTFIELD_DOCINFO_KEY_WORDS
Definition: unocoll.hxx:227
SwXMeta::CreateXMeta
static css::uno::Reference< css::rdf::XMetadatable > CreateXMeta(::sw::Meta &rMeta, css::uno::Reference< css::text::XText > const &xParentText=nullptr, std::unique_ptr< TextRangeList_t const > &&pPortions=std::unique_ptr< TextRangeList_t const >())
SwUnoCollection::GetDoc
SwDoc * GetDoc() const
Definition: unocoll.hxx:59
SwXTextEmbeddedObjects::SwXTextEmbeddedObjects
SwXTextEmbeddedObjects(SwDoc *pDoc)
Definition: unocoll.cxx:1345
SwFieldType
Instances of SwFields and those derived from it occur 0 to n times.
Definition: fldbas.hxx:234
CSS_TEXT_TEXTFIELD_DOCINFO_CREATE_DATE_TIME
#define CSS_TEXT_TEXTFIELD_DOCINFO_CREATE_DATE_TIME
Definition: unocoll.hxx:224
CSS_TEXT_TEXTFIELD_EXTENDED_USER
#define CSS_TEXT_TEXTFIELD_EXTENDED_USER
Definition: unocoll.hxx:201
TOXTypes
TOXTypes
Definition: toxe.hxx:39
SwXTextTables::hasElements
virtual sal_Bool SAL_CALL hasElements() override
Definition: unocoll.cxx:957
SwXReferenceMarks::supportsService
virtual sal_Bool SAL_CALL supportsService(const OUString &ServiceName) override
Definition: unocoll.cxx:1827
SwXNumberingRulesCollection::hasElements
virtual sal_Bool SAL_CALL hasElements() override
Definition: unocoll.cxx:1719
count
const size_t count(pCandidateA->getBorderLines().size())
SwXTextTable::CreateXTextTable
static css::uno::Reference< css::text::XTextTable > CreateXTextTable(SwFrameFormat *pFrameFormat)
Definition: unotbl.cxx:2137
SwXTextFrames::getImplementationName
virtual OUString SAL_CALL getImplementationName() override
Definition: unocoll.cxx:1282
nIndex
sal_Int32 nIndex
SwXTextTables::getSupportedServiceNames
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
Definition: unocoll.cxx:975
SwXNumberingRulesCollection::getByIndex
virtual css::uno::Any SAL_CALL getByIndex(sal_Int32 nIndex) override
Definition: unocoll.cxx:1694
CSS_TEXT_FIELDMASTER_DDE
#define CSS_TEXT_FIELDMASTER_DDE
Definition: unocoll.hxx:238
SwUnoCollection::m_bObjectValid
bool m_bObjectValid
Definition: unocoll.hxx:47
SwXTextTables::hasByName
virtual sal_Bool SAL_CALL hasByName(const OUString &Name) override
Definition: unocoll.cxx:931
SwXTextEmbeddedObjects::getSupportedServiceNames
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
Definition: unocoll.cxx:1340
SwNode::IsGrfNode
bool IsGrfNode() const
Definition: node.hxx:656
CSS_TEXT_TEXTFIELD_CHARACTER_COUNT
#define CSS_TEXT_TEXTFIELD_CHARACTER_COUNT
Definition: unocoll.hxx:215
SwXReferenceMarks::getSupportedServiceNames
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
Definition: unocoll.cxx:1832
SwXTextTables::supportsService
virtual sal_Bool SAL_CALL supportsService(const OUString &ServiceName) override
Definition: unocoll.cxx:970
CSS_TEXT_TEXTFIELD_CONDITIONAL_TEXT
#define CSS_TEXT_TEXTFIELD_CONDITIONAL_TEXT
Definition: unocoll.hxx:194
CSS_TEXT_TEXTFIELD_CHAPTER
#define CSS_TEXT_TEXTFIELD_CHAPTER
Definition: unocoll.hxx:192
SwDoc::GetDocShell
SwDocShell * GetDocShell()
Definition: doc.hxx:1346
CSS_TEXT_TEXTFIELD_EMBEDDED_OBJECT_COUNT
#define CSS_TEXT_TEXTFIELD_EMBEDDED_OBJECT_COUNT
Definition: unocoll.hxx:218
SwDoc::GetTableFrameFormats
const SwFrameFormats * GetTableFrameFormats() const
Definition: doc.hxx:808
SwXTextGraphicObjects::getImplementationName
virtual OUString SAL_CALL getImplementationName() override
Definition: unocoll.cxx:1306
CSS_TEXT_TEXTFIELD_DOCINFO_CHANGE_DATE_TIME
#define CSS_TEXT_TEXTFIELD_DOCINFO_CHANGE_DATE_TIME
Definition: unocoll.hxx:220
IDocumentFieldsAccess::GetFieldType
virtual SwFieldType * GetFieldType(SwFieldIds nResId, const OUString &rName, bool bDbFieldMatching) const =0
IDocumentMarkAccess::getBookmarksCount
virtual sal_Int32 getBookmarksCount() const =0
returns the number of IBookmarks.
SwXNumberingRulesCollection::~SwXNumberingRulesCollection
virtual ~SwXNumberingRulesCollection() override
Definition: unocoll.cxx:1682
IDocumentMarkAccess::iterator
wrapper iterator: wraps iterator of implementation while hiding MarkBase class; only IMark instances ...
Definition: IDocumentMarkAccess.hxx:60
SwXTextFrames::supportsService
virtual sal_Bool SAL_CALL supportsService(const OUString &ServiceName) override
Definition: unocoll.cxx:1287
SwXParagraph::CreateXParagraph
static css::uno::Reference< css::text::XTextContent > CreateXParagraph(SwDoc &rDoc, SwTextNode *pTextNode, css::uno::Reference< css::text::XText > const &xParentText=nullptr, const sal_Int32 nSelStart=-1, const sal_Int32 nSelEnd=-1)
Definition: unoparagraph.cxx:233
IDocumentMarkAccess::GetType
static SW_DLLPUBLIC MarkType GetType(const ::sw::mark::IMark &rMark)
Returns the MarkType used to create the mark.
Definition: docbm.cxx:474
SwXReferenceMarks::getImplementationName
virtual OUString SAL_CALL getImplementationName() override
Definition: unocoll.cxx:1822
SvUnoImageMapRectangleObject_createInstance
Reference< XInterface > SvUnoImageMapRectangleObject_createInstance(const SvEventDescription *pSupportedMacroItems)
n
sal_Int64 n
IDocumentMarkAccess
Provides access to the marks of a document.
Definition: IDocumentMarkAccess.hxx:39
SwDoc
Definition: doc.hxx:185
SvUnoImageMapCircleObject_createInstance
Reference< XInterface > SvUnoImageMapCircleObject_createInstance(const SvEventDescription *pSupportedMacroItems)
SwXStyleFamilies::CreateStyleCondParagraph
static css::uno::Reference< css::style::XStyle > CreateStyleCondParagraph(SwDoc &rDoc)
Definition: unostyle.cxx:806
SwXTextSections::getByName
virtual css::uno::Any SAL_CALL getByName(const OUString &Name) override
Definition: unocoll.cxx:1422
getImplementationName
OUString getImplementationName()
CSS_TEXT_TEXTFIELD_DOCINFO_REVISION
#define CSS_TEXT_TEXTFIELD_DOCINFO_REVISION
Definition: unocoll.hxx:230
CSS_TEXT_TEXTFIELD_TABLE_COUNT
#define CSS_TEXT_TEXTFIELD_TABLE_COUNT
Definition: unocoll.hxx:216
SwXBookmarks::~SwXBookmarks
virtual ~SwXBookmarks() override
Definition: unocoll.cxx:1548
CSS_TEXT_FIELDMASTER_BIBLIOGRAPHY
#define CSS_TEXT_FIELDMASTER_BIBLIOGRAPHY
Definition: unocoll.hxx:241
CSS_TEXT_TEXTFIELD_WORD_COUNT
#define CSS_TEXT_TEXTFIELD_WORD_COUNT
Definition: unocoll.hxx:214
CSS_TEXT_TEXTFIELD_TABLE_FORMULA
#define CSS_TEXT_TEXTFIELD_TABLE_FORMULA
Definition: unocoll.hxx:211
StringHashMap
std::unordered_map< OUString, OUString > StringHashMap
SwFormatFootnote::IsEndNote
bool IsEndNote() const
Definition: fmtftn.hxx:74
SwDoc::getIDocumentMarkAccess
IDocumentMarkAccess * getIDocumentMarkAccess()
Definition: docbm.cxx:1625
SfxObjectShell::GetModel
css::uno::Reference< css::frame::XModel > GetModel() const
SwXTextField::CreateXTextField
static css::uno::Reference< css::text::XTextField > CreateXTextField(SwDoc *pDoc, SwFormatField const *pFormat, SwServiceType nServiceId=SwServiceType::Invalid)
Definition: unofield.cxx:1248
SwXFootnotes::~SwXFootnotes
virtual ~SwXFootnotes() override
Definition: unocoll.cxx:1748
SwXTextSections::hasByName
virtual sal_Bool SAL_CALL hasByName(const OUString &Name) override
Definition: unocoll.cxx:1480
SwXFrames::supportsService
virtual sal_Bool SAL_CALL supportsService(const OUString &ServiceName) override
Definition: unocoll.cxx:1139
SwVectorModifyBase::empty
bool empty() const
Definition: docary.hxx:89
SwFieldIds::Database
For old documents the Field-Which IDs must be preserved !!!
SwXTextSections::getElementType
virtual css::uno::Type SAL_CALL getElementType() override
Definition: unocoll.cxx:1506
SwDoc::GetSpzFrameFormats
const SwFrameFormats * GetSpzFrameFormats() const
Definition: doc.hxx:738
CSS_TEXT_TEXTFIELD_INPUT_USER
#define CSS_TEXT_TEXTFIELD_INPUT_USER
Definition: unocoll.hxx:235
CSS_TEXT_FIELDMASTER_SET_EXPRESSION
#define CSS_TEXT_FIELDMASTER_SET_EXPRESSION
Definition: unocoll.hxx:239
SwXTextTables::getByName
virtual css::uno::Any SAL_CALL getByName(const OUString &Name) override
Definition: unocoll.cxx:886
SwXTextSection::CreateXTextSection
static css::uno::Reference< css::text::XTextSection > CreateXTextSection(SwSectionFormat *const pFormat, const bool bIndexHeader=false)
Definition: unosect.cxx:196
SwXTextFrames::~SwXTextFrames
virtual ~SwXTextFrames() override
Definition: unocoll.cxx:1302
SwXReferenceMarks::getByIndex
virtual css::uno::Any SAL_CALL getByIndex(sal_Int32 nIndex) override
Definition: unocoll.cxx:1854
SwSectionFormats
Array of Undo-history.
Definition: docary.hxx:299
CSS_TEXT_TEXTFIELD_DATABASE_NAME
#define CSS_TEXT_TEXTFIELD_DATABASE_NAME
Definition: unocoll.hxx:210
SwDoc::getIDocumentFieldsAccess
IDocumentFieldsAccess const & getIDocumentFieldsAccess() const
Definition: doc.cxx:356
CSS_TEXT_TEXTFIELD_DATE_TIME
#define CSS_TEXT_TEXTFIELD_DATE_TIME
Definition: unocoll.hxx:185
SwXTextTables::getImplementationName
virtual OUString SAL_CALL getImplementationName() override
Definition: unocoll.cxx:965
SAL_MAX_UINT16
#define SAL_MAX_UINT16
SwUnoCollection::IsValid
bool IsValid() const
Definition: unocoll.hxx:57
SwXTextTables::getElementNames
virtual css::uno::Sequence< OUString > SAL_CALL getElementNames() override
Definition: unocoll.cxx:911
SwFormat::GetName
const OUString & GetName() const
Definition: format.hxx:111
SwXNumberingRulesCollection::getCount
virtual sal_Int32 SAL_CALL getCount() override
Definition: unocoll.cxx:1686
nCount
int nCount
SwNodeIndex::GetIndex
sal_uLong GetIndex() const
Definition: ndindex.hxx:152
CSS_TEXT_TEXTFIELD_DATABASE_NEXT_SET
#define CSS_TEXT_TEXTFIELD_DATABASE_NEXT_SET
Definition: unocoll.hxx:206
SwTextBoxHelper::isTextBox
static bool isTextBox(const SwFrameFormat *pFormat, sal_uInt16 nType)
Is the frame format a text box?
Definition: textboxhelper.cxx:149
CSS_TEXT_TEXTFIELD_USER
#define CSS_TEXT_TEXTFIELD_USER
Definition: unocoll.hxx:186
CSS_TEXT_TEXTFIELD_DOCINFO_PRINT_DATE_TIME
#define CSS_TEXT_TEXTFIELD_DOCINFO_PRINT_DATE_TIME
Definition: unocoll.hxx:226
SwXTextSections::supportsService
virtual sal_Bool SAL_CALL supportsService(const OUString &ServiceName) override
Definition: unocoll.cxx:1359
cppu::supportsService
bool CPPUHELPER_DLLPUBLIC supportsService(css::lang::XServiceInfo *implementation, rtl::OUString const &name)
SwXFrames::getByIndex
virtual css::uno::Any SAL_CALL getByIndex(sal_Int32 nIndex) override
Definition: unocoll.cxx:1187
SwXFieldmark::CreateXFieldmark
static css::uno::Reference< css::text::XTextContent > CreateXFieldmark(SwDoc &rDoc,::sw::mark::IMark *pMark, bool isReplacementObject=false)
Definition: unobkm.cxx:649
ooo::vba::createVBAUnoAPIServiceWithArgs
css::uno::Reference< css::uno::XInterface > createVBAUnoAPIServiceWithArgs(SfxObjectShell const *pShell, const char *_pAsciiName, const css::uno::Sequence< css::uno::Any > &aArgs)
CSS_TEXT_TEXTFIELD_DOCINFO_PRINT_AUTHOR
#define CSS_TEXT_TEXTFIELD_DOCINFO_PRINT_AUTHOR
Definition: unocoll.hxx:225
SwFrameFormats::empty
bool empty() const
Definition: docary.hxx:224
SwXReferenceMarks::getElementNames
virtual css::uno::Sequence< OUString > SAL_CALL getElementNames() override
Definition: unocoll.cxx:1895
SfxStyleFamily
SfxStyleFamily
SwDoc::GetFlyNum
SwFrameFormat * GetFlyNum(size_t nIdx, FlyCntType eType, bool bIgnoreTextBoxes=false)
Definition: docfly.cxx:114
SfxObjectShell::GetCreateMode
SfxObjectCreateMode GetCreateMode() const
o3tl::sorted_vector::size
size_type size() const
CSS_TEXT_TEXTFIELD_DOCINFO_CUSTOM
#define CSS_TEXT_TEXTFIELD_DOCINFO_CUSTOM
Definition: unocoll.hxx:231
SwXFrames::~SwXFrames
virtual ~SwXFrames() override
Definition: unocoll.cxx:1154
SwFrameFormats
Specific frame formats (frames, DrawObjects).
Definition: docary.hxx:201
SwNode::IsOLENode
bool IsOLENode() const
Definition: node.hxx:652
CSS_TEXT_TEXTFIELD_FILE_NAME
#define CSS_TEXT_TEXTFIELD_FILE_NAME
Definition: unocoll.hxx:189
SAL_N_ELEMENTS
#define SAL_N_ELEMENTS(arr)
RES_FLYFRMFMT
#define RES_FLYFRMFMT
Definition: hintids.hxx:369
CSS_TEXT_TEXTFIELD_REFERENCE_PAGE_SET
#define CSS_TEXT_TEXTFIELD_REFERENCE_PAGE_SET
Definition: unocoll.hxx:202
SwXServiceProvider::GetProviderName
static OUString GetProviderName(SwServiceType nObjectType)
Definition: unocoll.cxx:469
IDocumentMarkAccess::getBookmarksEnd
virtual const_iterator_t getBookmarksEnd() const =0
returns a STL-like random access iterator to the end of the sequence of IBookmarks.
SwXTextEmbeddedObjects::supportsService
virtual sal_Bool SAL_CALL supportsService(const OUString &ServiceName) override
Definition: unocoll.cxx:1335
SwXTextTables::getElementType
virtual css::uno::Type SAL_CALL getElementType() override
Definition: unocoll.cxx:952
SwXBookmark::CreateXBookmark
static css::uno::Reference< css::text::XTextContent > CreateXBookmark(SwDoc &rDoc,::sw::mark::IMark *pBookmark)
Definition: unobkm.cxx:155
CSS_TEXT_TEXTFIELD_DOCINFO_DESCRIPTION
#define CSS_TEXT_TEXTFIELD_DOCINFO_DESCRIPTION
Definition: unocoll.hxx:222
SwXBookmarks::getByName
virtual css::uno::Any SAL_CALL getByName(const OUString &Name) override
Definition: unocoll.cxx:1603
SwXFrames::createEnumeration
virtual css::uno::Reference< css::container::XEnumeration > SAL_CALL createEnumeration() override
Definition: unocoll.cxx:1157
pName
sal_uInt16 char * pName
SwXTextTables::~SwXTextTables
virtual ~SwXTextTables() override
Definition: unocoll.cxx:841
SwDoc::FindFlyByName
const SwFlyFrameFormat * FindFlyByName(const OUString &rName, SwNodeType nNdTyp=SwNodeType::NONE) const
Definition: doclay.cxx:1384
SwXBookmarks::getSupportedServiceNames
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
Definition: unocoll.cxx:1539
CSS_TEXT_TEXTFIELD_PARAGRAPH_COUNT
#define CSS_TEXT_TEXTFIELD_PARAGRAPH_COUNT
Definition: unocoll.hxx:213
SwFrameFormat
Style of a layout element.
Definition: frmfmt.hxx:57
SwXBookmarks::hasByName
virtual sal_Bool SAL_CALL hasByName(const OUString &Name) override
Definition: unocoll.cxx:1642
SwXReferenceMarks::getByName
virtual css::uno::Any SAL_CALL getByName(const OUString &Name) override
Definition: unocoll.cxx:1876
getSupportedServiceNames
css::uno::Sequence< OUString > getSupportedServiceNames()
SwXBookmarks::hasElements
virtual sal_Bool SAL_CALL hasElements() override
Definition: unocoll.cxx:1657
CSS_TEXT_TEXTFIELD_COMBINED_CHARACTERS
#define CSS_TEXT_TEXTFIELD_COMBINED_CHARACTERS
Definition: unocoll.hxx:233
SwSection::GetSectionName
const OUString & GetSectionName() const
Definition: section.hxx:169
CSS_TEXT_TEXTFIELD_DROP_DOWN
#define CSS_TEXT_TEXTFIELD_DROP_DOWN
Definition: unocoll.hxx:234
FlyCntType
FlyCntType
Definition: flyenum.hxx:23
SwXReferenceMarks::~SwXReferenceMarks
virtual ~SwXReferenceMarks() override
Definition: unocoll.cxx:1842
SwXNumberingRulesCollection::getElementType
virtual css::uno::Type SAL_CALL getElementType() override
Definition: unocoll.cxx:1714
IDocumentChartDataProviderAccess::GetChartDataProvider
virtual SwChartDataProvider * GetChartDataProvider(bool bCreate=false) const =0
returns or creates the data-provider for chart
SwXBookmarks::getElementNames
virtual css::uno::Sequence< OUString > SAL_CALL getElementNames() override
Definition: unocoll.cxx:1621
CSS_TEXT_TEXTFIELD_DDE
#define CSS_TEXT_TEXTFIELD_DDE
Definition: unocoll.hxx:198
SwDoc::GetRefMark
const SwFormatRefMark * GetRefMark(const OUString &rName) const
Definition: doc.cxx:1064
i
int i
nType
QPRO_FUNC_TYPE const nType
SwFieldIds
SwFieldIds
Definition: fldbas.hxx:38
SwXReferenceMarks::getElementType
virtual css::uno::Type SAL_CALL getElementType() override
Definition: unocoll.cxx:1920
SwVectorModifyBase::size
size_t size() const
Definition: docary.hxx:91
sal_Bool
unsigned char sal_Bool
SwXDocumentIndexMark::CreateXDocumentIndexMark
static css::uno::Reference< css::text::XDocumentIndexMark > CreateXDocumentIndexMark(SwDoc &rDoc, SwTOXMark *pMark, TOXTypes eType=TOX_INDEX)
Definition: unoidx.cxx:1627
SwSimpleEnumeration_Base
::cppu::WeakImplHelper< css::lang::XServiceInfo, css::container::XEnumeration > SwSimpleEnumeration_Base
Definition: unobaseclass.hxx:33
SwXFootnotes::getImplementationName
virtual OUString SAL_CALL getImplementationName() override
Definition: unocoll.cxx:1727
SwXTextEmbeddedObjects::getImplementationName
virtual OUString SAL_CALL getImplementationName() override
Definition: unocoll.cxx:1330
SwDoc::GetRefMarks
sal_uInt16 GetRefMarks(std::vector< OUString > *=nullptr) const
Definition: doc.cxx:1109
SwXDocumentIndex::CreateXDocumentIndex
static css::uno::Reference< css::text::XDocumentIndex > CreateXDocumentIndex(SwDoc &rDoc, SwTOXBaseSection *pSection, TOXTypes eTypes=TOX_INDEX)
Definition: unoidx.cxx:399
SwNode::IsNoTextNode
bool IsNoTextNode() const
Definition: node.hxx:648
SwXReferenceMarks::hasByName
virtual sal_Bool SAL_CALL hasByName(const OUString &Name) override
Definition: unocoll.cxx:1912
SwXFootnotes::getSupportedServiceNames
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
Definition: unocoll.cxx:1737
size
size
CSS_TEXT_TEXTFIELD_JUMP_EDIT
#define CSS_TEXT_TEXTFIELD_JUMP_EDIT
Definition: unocoll.hxx:204
IDocumentMarkAccess::findBookmark
virtual const_iterator_t findBookmark(const OUString &rMark) const =0
Finds a bookmark by name.
SwNodeIndex
Marks a node in the document model.
Definition: ndindex.hxx:31
cppu::UnoType::get
css::uno::Type const & get()
SwXNumberingRulesCollection::SwXNumberingRulesCollection
SwXNumberingRulesCollection(SwDoc *pDoc)
Definition: unocoll.cxx:1677
SwXTextTables::GetObject
static css::uno::Reference< css::text::XTextTable > GetObject(SwFrameFormat &rFormat)
Definition: unocoll.cxx:980
CSS_TEXT_TEXTFIELD_DATABASE_SET_NUMBER
#define CSS_TEXT_TEXTFIELD_DATABASE_SET_NUMBER
Definition: unocoll.hxx:208
o3tl::sorted_vector::empty
bool empty() const
SwFormat::GetDoc
const SwDoc * GetDoc() const
The document is set in SwAttrPool now, therefore you always can access it.
Definition: format.hxx:119
SwXFrames::getImplementationName
virtual OUString SAL_CALL getImplementationName() override
Definition: unocoll.cxx:1134
eType
DocumentType const eType
SwXReferenceMark::CreateXReferenceMark
static css::uno::Reference< css::text::XTextContent > CreateXReferenceMark(SwDoc &rDoc, SwFormatRefMark *pMarkFormat)
Definition: unorefmk.cxx:128
CSS_TEXT_TEXTFIELD_DATABASE_NUMBER_OF_SET
#define CSS_TEXT_TEXTFIELD_DATABASE_NUMBER_OF_SET
Definition: unocoll.hxx:207
SwDoc::getIDocumentChartDataProviderAccess
IDocumentChartDataProviderAccess const & getIDocumentChartDataProviderAccess() const
Definition: doc.cxx:226
SwXReferenceMarks::getCount
virtual sal_Int32 SAL_CALL getCount() override
Definition: unocoll.cxx:1846
SwXTextSections::getByIndex
virtual css::uno::Any SAL_CALL getByIndex(sal_Int32 nIndex) override
Definition: unocoll.cxx:1393
BasicManager::SetGlobalUNOConstant
css::uno::Any SetGlobalUNOConstant(const OUString &rName, const css::uno::Any &_rValue)
SwTextAttr::GetFootnote
const SwFormatFootnote & GetFootnote() const
Definition: txatbase.hxx:200
SwXTextSections::~SwXTextSections
virtual ~SwXTextSections() override
Definition: unocoll.cxx:1374
CSS_TEXT_TEXTFIELD_REFERENCE_PAGE_GET
#define CSS_TEXT_TEXTFIELD_REFERENCE_PAGE_GET
Definition: unocoll.hxx:203
SwXStyleFamilies::CreateStyle
static css::uno::Reference< css::style::XStyle > CreateStyle(SfxStyleFamily eFamily, SwDoc &rDoc)
Definition: unostyle.cxx:797
SwXBookmarks::getElementType
virtual css::uno::Type SAL_CALL getElementType() override
Definition: unocoll.cxx:1652
SwXBookmarks::getByIndex
virtual css::uno::Any SAL_CALL getByIndex(sal_Int32 nIndex) override
Definition: unocoll.cxx:1572
SwXFrames::hasElements
virtual sal_Bool SAL_CALL hasElements() override
Definition: unocoll.cxx:1273
CSS_TEXT_TEXTFIELD_DOCINFO_EDIT_TIME
#define CSS_TEXT_TEXTFIELD_DOCINFO_EDIT_TIME
Definition: unocoll.hxx:221
SwXTextGraphicObjects::SwXTextGraphicObjects
SwXTextGraphicObjects(SwDoc *pDoc)
Definition: unocoll.cxx:1321
CSS_TEXT_TEXTFIELD_GET_REFERENCE
#define CSS_TEXT_TEXTFIELD_GET_REFERENCE
Definition: unocoll.hxx:193
SwXTextSections::getElementNames
virtual css::uno::Sequence< OUString > SAL_CALL getElementNames() override
Definition: unocoll.cxx:1448
SwXBookmarks::SwXBookmarks
SwXBookmarks(SwDoc *pDoc)
Definition: unocoll.cxx:1544
CSS_TEXT_TEXTFIELD_GET_EXPRESSION
#define CSS_TEXT_TEXTFIELD_GET_EXPRESSION
Definition: unocoll.hxx:188
SwXTextSections::getSupportedServiceNames
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
Definition: unocoll.cxx:1364
SwXFrames::m_eType
const FlyCntType m_eType
Definition: unocoll.hxx:301
CSS_TEXT_TEXTFIELD_HIDDEN_PARAGRAPH
#define CSS_TEXT_TEXTFIELD_HIDDEN_PARAGRAPH
Definition: unocoll.hxx:199
SwXFrames::SwXFrames
SwXFrames(SwDoc *pDoc, FlyCntType eSet)
Definition: unocoll.cxx:1149
CSS_TEXT_TEXTFIELD_BIBLIOGRAPHY
#define CSS_TEXT_TEXTFIELD_BIBLIOGRAPHY
Definition: unocoll.hxx:232
SwNodeIndex::GetNodes
const SwNodes & GetNodes() const
Definition: ndindex.hxx:156
IDocumentFieldsAccess::InsertFieldType
virtual SwFieldType * InsertFieldType(const SwFieldType &)=0
SwXTextSections::hasElements
virtual sal_Bool SAL_CALL hasElements() override
Definition: unocoll.cxx:1511
CSS_TEXT_TEXTFIELD_INPUT
#define CSS_TEXT_TEXTFIELD_INPUT
Definition: unocoll.hxx:196
SwXTextGraphicObjects::supportsService
virtual sal_Bool SAL_CALL supportsService(const OUString &ServiceName) override
Definition: unocoll.cxx:1311
comphelper::containerToSequence
css::uno::Sequence< DstElementType > containerToSequence(const SrcType &i_Container)
SwDoc::GetNumRuleTable
const SwNumRuleTable & GetNumRuleTable() const
Definition: doc.hxx:1061
BasicManager::GetGlobalUNOConstant
bool GetGlobalUNOConstant(const OUString &rName, css::uno::Any &aOut)
SwXFootnotes::hasElements
virtual sal_Bool SAL_CALL hasElements() override
Definition: unocoll.cxx:1809
IDocumentMarkAccess::getBookmarksBegin
virtual const_iterator_t getBookmarksBegin() const =0
returns a STL-like random access iterator to the begin of the sequence the IBookmarks.
SwDoc::GetVBATemplateToProjectCache
const css::uno::Reference< css::container::XNameContainer > & GetVBATemplateToProjectCache() const
Definition: doc.hxx:1613
SwXBookmarks::getImplementationName
virtual OUString SAL_CALL getImplementationName() override
Definition: unocoll.cxx:1529
SAL_INFO
#define SAL_INFO(area, stream)
BasicManager::GetName
const OUString & GetName() const
CSS_TEXT_TEXTFIELD_DOCINFO_CHANGE_AUTHOR
#define CSS_TEXT_TEXTFIELD_DOCINFO_CHANGE_AUTHOR
Definition: unocoll.hxx:219
SwXServiceProvider::GetProviderType
static SwServiceType GetProviderType(const OUString &rServiceName)
Definition: unocoll.cxx:499
CSS_TEXT_TEXTFIELD_GRAPHIC_OBJECT_COUNT
#define CSS_TEXT_TEXTFIELD_GRAPHIC_OBJECT_COUNT
Definition: unocoll.hxx:217
SwDoc::GetNodes
SwNodes & GetNodes()
Definition: doc.hxx:403
SwUnoCollection::Invalidate
virtual void Invalidate()
Definition: unocoll.cxx:1933
SwXFrames::getCount
virtual sal_Int32 SAL_CALL getCount() override
Definition: unocoll.cxx:1178
SwDoc::GetFlyCount
size_t GetFlyCount(FlyCntType eType, bool bIgnoreTextBoxes=false) const
Access to frames.
Definition: docfly.cxx:67
SwUnoCollection::m_pDoc
SwDoc * m_pDoc
Definition: unocoll.hxx:46
CSS_TEXT_TEXTFIELD_AUTHOR
#define CSS_TEXT_TEXTFIELD_AUTHOR
Definition: unocoll.hxx:191
SwXTextFrame::CreateXTextFrame
static SW_DLLPUBLIC css::uno::Reference< css::text::XTextFrame > CreateXTextFrame(SwDoc &rDoc, SwFrameFormat *pFrameFormat)
Definition: unoframe.cxx:3153
CSS_TEXT_TEXTFIELD_SCRIPT
#define CSS_TEXT_TEXTFIELD_SCRIPT
Definition: unocoll.hxx:205
CSS_TEXT_TEXTFIELD_DOCINFO_TITLE
#define CSS_TEXT_TEXTFIELD_DOCINFO_TITLE
Definition: unocoll.hxx:229
SwXFrames::getByName
virtual css::uno::Any SAL_CALL getByName(const OUString &Name) override
Definition: unocoll.cxx:1201
SwXServiceProvider::MakeInstance
static css::uno::Reference< css::uno::XInterface > MakeInstance(SwServiceType nObjectType, SwDoc &rDoc)
Definition: unocoll.cxx:510
SwXFootnotes::getElementType
virtual css::uno::Type SAL_CALL getElementType() override
Definition: unocoll.cxx:1804
aSeq
Sequence< sal_Int8 > aSeq
SwXFrames::getElementNames
virtual css::uno::Sequence< OUString > SAL_CALL getElementNames() override
Definition: unocoll.cxx:1224
SwDoc::GetTableFrameFormatCount
size_t GetTableFrameFormatCount(bool bUsed) const
Definition: docfmt.cxx:750
CSS_TEXT_TEXTFIELD_HIDDEN_TEXT
#define CSS_TEXT_TEXTFIELD_HIDDEN_TEXT
Definition: unocoll.hxx:236
CSS_TEXT_TEXTFIELD_SET_EXPRESSION
#define CSS_TEXT_TEXTFIELD_SET_EXPRESSION
Definition: unocoll.hxx:187
SwXServiceProvider::GetAllServiceNames
static css::uno::Sequence< OUString > GetAllServiceNames()
Definition: unocoll.cxx:479
SwXFrames::hasByName
virtual sal_Bool SAL_CALL hasByName(const OUString &Name) override
Definition: unocoll.cxx:1241
SwXTextEmbeddedObjects::~SwXTextEmbeddedObjects
virtual ~SwXTextEmbeddedObjects() override
Definition: unocoll.cxx:1350
SwXFootnote::CreateXFootnote
static css::uno::Reference< css::text::XFootnote > CreateXFootnote(SwDoc &rDoc, SwFormatFootnote *pFootnoteFormat, bool isEndnote=false)
Definition: unoftn.cxx:144
SwDoc::GetTableFrameFormat
SwFrameFormat & GetTableFrameFormat(size_t nFormat, bool bUsed) const
Definition: docfmt.cxx:767
SwXFootnotes::supportsService
virtual sal_Bool SAL_CALL supportsService(const OUString &ServiceName) override
Definition: unocoll.cxx:1732
SwXTextGraphicObjects::~SwXTextGraphicObjects
virtual ~SwXTextGraphicObjects() override
Definition: unocoll.cxx:1326
ooo::vba::isAlienWordDoc
bool isAlienWordDoc(SfxObjectShell const &rDocShell)
SwXFrames::getSupportedServiceNames
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
Definition: unocoll.cxx:1144
CSS_TEXT_TEXTFIELD_DOCINFO_SUBJECT
#define CSS_TEXT_TEXTFIELD_DOCINFO_SUBJECT
Definition: unocoll.hxx:228
CSS_TEXT_TEXTFIELD_PAGE_COUNT
#define CSS_TEXT_TEXTFIELD_PAGE_COUNT
Definition: unocoll.hxx:212
SwDoc::GetFootnoteIdxs
SwFootnoteIdxs & GetFootnoteIdxs()
Definition: doc.hxx:628
SwXTextFrames::SwXTextFrames
SwXTextFrames(SwDoc *pDoc)
Definition: unocoll.cxx:1297
SwXTextSections::getCount
virtual sal_Int32 SAL_CALL getCount() override
Definition: unocoll.cxx:1378
SAL_WARN
#define SAL_WARN(area, stream)
CSS_TEXT_TEXTFIELD_ANNOTATION
#define CSS_TEXT_TEXTFIELD_ANNOTATION
Definition: unocoll.hxx:195
SwNodes::IsDocNodes
bool IsDocNodes() const
Is the NodesArray the regular one of Doc? (and not the UndoNds, ...) Implementation in doc...
Definition: nodes.cxx:2313
SwFrameFormats::size
size_t size() const
Definition: docary.hxx:225
CSS_TEXT_TEXTFIELD_TEMPLATE_NAME
#define CSS_TEXT_TEXTFIELD_TEMPLATE_NAME
Definition: unocoll.hxx:200
SwXBookmarks::supportsService
virtual sal_Bool SAL_CALL supportsService(const OUString &ServiceName) override
Definition: unocoll.cxx:1534
SwXTextEmbeddedObject::CreateXTextEmbeddedObject
static css::uno::Reference< css::text::XTextContent > CreateXTextEmbeddedObject(SwDoc &rDoc, SwFrameFormat *pFrameFormat)
Definition: unoframe.cxx:3445
SwXTextGraphicObjects::getSupportedServiceNames
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
Definition: unocoll.cxx:1316
SwXTextGraphicObject::CreateXTextGraphicObject
static css::uno::Reference< css::text::XTextContent > CreateXTextGraphicObject(SwDoc &rDoc, SwFrameFormat *pFrameFormat)
Definition: unoframe.cxx:3398
m_eType
const EnumerationType m_eType
SwXFootnotes::m_bEndnote
const bool m_bEndnote
Definition: unocoll.hxx:454
SwXTextSections::GetObject
static css::uno::Reference< css::text::XTextSection > GetObject(SwSectionFormat &rFormat)
Definition: unocoll.cxx:1524
SwXReferenceMarks::hasElements
virtual sal_Bool SAL_CALL hasElements() override
Definition: unocoll.cxx:1925
SwSectionFormat::GetSection
SwSection * GetSection() const
Definition: section.cxx:671
aProvNamesId
const ProvNamesId_Type aProvNamesId[]
Definition: unocoll.cxx:278
SwXTextTables::getByIndex
virtual css::uno::Any SAL_CALL getByIndex(sal_Int32 nIndex) override
Definition: unocoll.cxx:855
SwXTextSections::getImplementationName
virtual OUString SAL_CALL getImplementationName() override
Definition: unocoll.cxx:1354
SwXTextSections::SwXTextSections
SwXTextSections(SwDoc *pDoc)
Definition: unocoll.cxx:1369
SwXFootnotes::SwXFootnotes
SwXFootnotes(bool bEnd, SwDoc *pDoc)
Definition: unocoll.cxx:1742
SvUnoImageMapPolygonObject_createInstance
Reference< XInterface > SvUnoImageMapPolygonObject_createInstance(const SvEventDescription *pSupportedMacroItems)
CSS_TEXT_TEXTFIELD_MACRO
#define CSS_TEXT_TEXTFIELD_MACRO
Definition: unocoll.hxx:197
SwXFrames::getElementType
virtual css::uno::Type SAL_CALL getElementType() override
Definition: unocoll.cxx:1257
SwDoc::GetSections
SwSectionFormats & GetSections()
Definition: doc.hxx:1332
SwXFootnotes::getByIndex
virtual css::uno::Any SAL_CALL getByIndex(sal_Int32 nIndex) override
Definition: unocoll.cxx:1771
SwXBookmarks::getCount
virtual sal_Int32 SAL_CALL getCount() override
Definition: unocoll.cxx:1551
CSS_TEXT_FIELDMASTER_DATABASE
#define CSS_TEXT_FIELDMASTER_DATABASE
Definition: unocoll.hxx:240
sw_GetSupportedMacroItems
const SvEventDescription * sw_GetSupportedMacroItems()
Definition: unocoll.cxx:457
SwXTextFrames::getSupportedServiceNames
virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override
Definition: unocoll.cxx:1292
SwXTextTables::getCount
virtual sal_Int32 SAL_CALL getCount() override
Definition: unocoll.cxx:846
SwXReferenceMarks::SwXReferenceMarks
SwXReferenceMarks(SwDoc *pDoc)
Definition: unocoll.cxx:1837
CSS_TEXT_TEXTFIELD_DATABASE
#define CSS_TEXT_TEXTFIELD_DATABASE
Definition: unocoll.hxx:209
SwServiceType
SwServiceType
entries in this enum are mapped in an array in unocoll.cxx
Definition: unocoll.hxx:63
SfxObjectShell::GetBasicManager
BasicManager * GetBasicManager() const
comphelper::mapKeysToSequence
css::uno::Sequence< typename M::key_type > mapKeysToSequence(M const &map)
SwXTextTables::SwXTextTables
SwXTextTables(SwDoc *pDoc)
Definition: unocoll.cxx:835
SwXFootnotes::getCount
virtual sal_Int32 SAL_CALL getCount() override
Definition: unocoll.cxx:1752
SwXFootnotes::GetObject
static css::uno::Reference< css::text::XFootnote > GetObject(SwDoc &rDoc, const SwFormatFootnote &rFormat)
Definition: unocoll.cxx:1817
CSS_TEXT_FIELDMASTER_USER
#define CSS_TEXT_FIELDMASTER_USER
Definition: unocoll.hxx:237
SwDoc::SetVBATemplateToProjectCache
void SetVBATemplateToProjectCache(css::uno::Reference< css::container::XNameContainer > const &xCache)
Definition: doc.hxx:1612
SwXFieldMaster::CreateXFieldMaster
static css::uno::Reference< css::beans::XPropertySet > CreateXFieldMaster(SwDoc *pDoc, SwFieldType *pType, SwFieldIds nResId=SwFieldIds::Unknown)
Definition: unofield.cxx:541
CSS_TEXT_TEXTFIELD_PAGE_NUMBER
#define CSS_TEXT_TEXTFIELD_PAGE_NUMBER
Definition: unocoll.hxx:190
SwSectionFormat::IsInNodesArr
bool IsInNodesArr() const
Definition: section.cxx:915
CSS_TEXT_TEXTFIELD_DOCINFO_CREATE_AUTHOR
#define CSS_TEXT_TEXTFIELD_DOCINFO_CREATE_AUTHOR
Definition: unocoll.hxx:223
SwNode
Base class of the Writer document model elements.
Definition: node.hxx:79
makeAny
css::uno::Any SAL_CALL makeAny(const SharedUNOComponent< INTERFACE, COMPONENT > &value)
Generated on Wed Jan 22 2020 09:10:45 for LibreOffice Module sw (master) by   doxygen 1.8.10