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