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