?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
resolves tdf#164985 Incorrect bookmarks list in bookmark dialog after
[LibreOffice.git] / sw / source / core / unocore / unoidx.cxx
blobaa4f2d171c937966381cd4a77a06be0fc0d96094
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 <memory>
21 #include <unoidx.hxx>
22 #include <unoidxcoll.hxx>
23
24 #include <com/sun/star/beans/PropertyAttribute.hpp>
25 #include <com/sun/star/container/XIndexReplace.hpp>
26 #include <com/sun/star/frame/XModel.hpp>
27 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
28 #include <com/sun/star/text/ChapterFormat.hpp>
29 #include <com/sun/star/text/ReferenceFieldPart.hpp>
30 #include <com/sun/star/text/BibliographyDataField.hpp>
31 #include <com/sun/star/text/XTextDocument.hpp>
32
33 #include <comphelper/interfacecontainer4.hxx>
34 #include <cppuhelper/supportsservice.hxx>
35 #include <tools/UnitConversion.hxx>
36 #include <vcl/svapp.hxx>
37 #include <i18nlangtag/languagetag.hxx>
38 #include <editeng/memberids.h>
39 #include <swtypes.hxx>
40 #include <shellres.hxx>
41 #include <viewsh.hxx>
42 #include <doc.hxx>
43 #include <IDocumentLayoutAccess.hxx>
44 #include <docary.hxx>
45 #include <fmtcntnt.hxx>
46 #include <unomap.hxx>
47 #include <unotextrange.hxx>
48 #include <unotextcursor.hxx>
49 #include <unosection.hxx>
50 #include <doctxm.hxx>
51 #include <txttxmrk.hxx>
52 #include <ndtxt.hxx>
53 #include <docsh.hxx>
54 #include <chpfld.hxx>
55 #include <editsh.hxx>
56 #include <SwStyleNameMapper.hxx>
57 #include <strings.hrc>
58 #include <comphelper/servicehelper.hxx>
59 #include <comphelper/string.hxx>
60 #include <cppuhelper/implbase.hxx>
61 #include <svl/itemprop.hxx>
62 #include <svl/listener.hxx>
63 #include <mutex>
64 #include <unotxdoc.hxx>
65 #include <names.hxx>
66
67 using namespace ::com::sun::star;
68
69 /// @throws lang::IllegalArgumentException
70 template<typename T>
71 static T
72 lcl_AnyToType(uno::Any const& rVal)
73 {
74 T aRet{};
75 if(!(rVal >>= aRet))
76 {
77 throw lang::IllegalArgumentException();
78 }
79 return aRet;
80 }
81
82 /// @throws lang::IllegalArgumentException
83 template<typename T>
84 static void lcl_AnyToBitMask(uno::Any const& rValue,
85 T & rBitMask, const T nBit)
86 {
87 rBitMask = lcl_AnyToType<bool>(rValue)
88 ? (rBitMask | nBit)
89 : (rBitMask & ~nBit);
90 }
91
92 template<typename T>
93 static void lcl_BitMaskToAny(uno::Any & o_rValue,
94 const T nBitMask, const T nBit)
95 {
96 const bool bRet(nBitMask & nBit);
97 o_rValue <<= bRet;
98 }
99
100 static void
101 lcl_ReAssignTOXType(SwDoc& rDoc, SwTOXBase& rTOXBase, const OUString& rNewName)
102 {
103 const sal_uInt16 nUserCount = rDoc.GetTOXTypeCount( TOX_USER );
104 const SwTOXType* pNewType = nullptr;
105 for(sal_uInt16 nUser = 0; nUser < nUserCount; nUser++)
106 {
107 const SwTOXType* pType = rDoc.GetTOXType( TOX_USER, nUser );
108 if (pType->GetTypeName()==rNewName)
109 {
110 pNewType = pType;
111 break;
112 }
113 }
114 if(!pNewType)
115 {
116 SwTOXType aNewType(rDoc, TOX_USER, rNewName);
117 pNewType = rDoc.InsertTOXType( aNewType );
118 }
119
120 rTOXBase.RegisterToTOXType( *const_cast<SwTOXType*>(pNewType) );
121 }
122
123 constexpr OUString cUserDefined = u"User-Defined"_ustr;
124 const char cUserSuffix[] = " (user)";
125 #define USER_LEN 12
126 #define USER_AND_SUFFIXLEN 19
127
128 static void lcl_ConvertTOUNameToProgrammaticName(OUString& rTmp)
129 {
130 ShellResource* pShellRes = SwViewShell::GetShellRes();
131
132 if(rTmp==pShellRes->aTOXUserName)
133 {
134 rTmp = cUserDefined;
135 }
136 // if the version is not English but the alternative index's name is
137 // "User-Defined" a " (user)" is appended
138 else if(rTmp == cUserDefined)
139 {
140 rTmp += cUserSuffix;
141 }
142 }
143
144 static void
145 lcl_ConvertTOUNameToUserName(OUString& rTmp)
146 {
147 ShellResource* pShellRes = SwViewShell::GetShellRes();
148 if (rTmp == cUserDefined)
149 {
150 rTmp = pShellRes->aTOXUserName;
151 }
152 else if (pShellRes->aTOXUserName != cUserDefined &&
153 USER_AND_SUFFIXLEN == rTmp.getLength())
154 {
155 //make sure that in non-English versions the " (user)" suffix is removed
156 if (rTmp.startsWith(cUserDefined) &&
157 rTmp.match(cUserSuffix, USER_LEN))
158 {
159 rTmp = cUserDefined;
160 }
161 }
162 }
163
164 typedef ::cppu::WeakImplHelper
165 < lang::XServiceInfo
166 , container::XIndexReplace
167 > SwXDocumentIndexStyleAccess_Base;
168
169 class SwXDocumentIndex::StyleAccess_Impl
170 : public SwXDocumentIndexStyleAccess_Base
171 {
172
173 private:
174 /// can be destroyed threadsafely, so no UnoImplPtr here
175 ::rtl::Reference<SwXDocumentIndex> m_xParent;
176
177 virtual ~StyleAccess_Impl() override;
178
179 public:
180 explicit StyleAccess_Impl(SwXDocumentIndex& rParentIdx);
181
182 // XServiceInfo
183 virtual OUString SAL_CALL getImplementationName() override;
184 virtual sal_Bool SAL_CALL
185 supportsService(const OUString& rServiceName) override;
186 virtual uno::Sequence< OUString > SAL_CALL
187 getSupportedServiceNames() override;
188
189 // XElementAccess
190 virtual uno::Type SAL_CALL getElementType() override;
191 virtual sal_Bool SAL_CALL hasElements() override;
192
193 // XIndexAccess
194 virtual sal_Int32 SAL_CALL getCount() override;
195 virtual uno::Any SAL_CALL getByIndex(sal_Int32 nIndex) override;
196
197 // XIndexReplace
198 virtual void SAL_CALL
199 replaceByIndex(sal_Int32 Index, const uno::Any& rElement) override;
200
201 };
202
203 typedef ::cppu::WeakImplHelper
204 < lang::XServiceInfo
205 , container::XIndexReplace
206 > SwXDocumentIndexTokenAccess_Base;
207
208 class SwXDocumentIndex::TokenAccess_Impl
209 : public SwXDocumentIndexTokenAccess_Base
210 {
211
212 private:
213 /// can be destroyed threadsafely, so no UnoImplPtr here
214 ::rtl::Reference<SwXDocumentIndex> m_xParent;
215
216 virtual ~TokenAccess_Impl() override;
217
218 public:
219
220 explicit TokenAccess_Impl(SwXDocumentIndex& rParentIdx);
221
222 // XServiceInfo
223 virtual OUString SAL_CALL getImplementationName() override;
224 virtual sal_Bool SAL_CALL
225 supportsService(const OUString& rServiceName) override;
226 virtual uno::Sequence< OUString > SAL_CALL
227 getSupportedServiceNames() override;
228
229 // XElementAccess
230 virtual uno::Type SAL_CALL getElementType() override;
231 virtual sal_Bool SAL_CALL hasElements() override;
232
233 // XIndexAccess
234 virtual sal_Int32 SAL_CALL getCount() override;
235 virtual uno::Any SAL_CALL getByIndex(sal_Int32 nIndex) override;
236
237 // XIndexReplace
238 virtual void SAL_CALL
239 replaceByIndex(sal_Int32 Index, const uno::Any& rElement) override;
240
241 };
242
243 namespace {
244
245 class SwDocIndexDescriptorProperties_Impl
246 {
247 private:
248 std::unique_ptr<SwTOXBase> m_pTOXBase;
249 OUString m_sUserTOXTypeName;
250
251 public:
252 explicit SwDocIndexDescriptorProperties_Impl(SwTOXType const*const pType);
253
254 SwTOXBase & GetTOXBase() { return *m_pTOXBase; }
255 const OUString& GetTypeName() const { return m_sUserTOXTypeName; }
256 void SetTypeName(const OUString& rSet) { m_sUserTOXTypeName = rSet; }
257 };
258
259 }
260
261 SwDocIndexDescriptorProperties_Impl::SwDocIndexDescriptorProperties_Impl(
262 SwTOXType const*const pType)
263 {
264 SwForm aForm(pType->GetType());
265 m_pTOXBase.reset(new SwTOXBase(pType, aForm,
266 SwTOXElement::Mark, pType->GetTypeName()));
267 if(pType->GetType() == TOX_CONTENT || pType->GetType() == TOX_USER)
268 {
269 m_pTOXBase->SetLevel(MAXLEVEL);
270 }
271 m_sUserTOXTypeName = pType->GetTypeName();
272 }
273
274 static sal_uInt16
275 lcl_TypeToPropertyMap_Index(const TOXTypes eType)
276 {
277 switch (eType)
278 {
279 case TOX_INDEX: return PROPERTY_MAP_INDEX_IDX;
280 case TOX_CONTENT: return PROPERTY_MAP_INDEX_CNTNT;
281 case TOX_TABLES: return PROPERTY_MAP_INDEX_TABLES;
282 case TOX_ILLUSTRATIONS: return PROPERTY_MAP_INDEX_ILLUSTRATIONS;
283 case TOX_OBJECTS: return PROPERTY_MAP_INDEX_OBJECTS;
284 case TOX_AUTHORITIES: return PROPERTY_MAP_BIBLIOGRAPHY;
285 //case TOX_USER:
286 default:
287 return PROPERTY_MAP_INDEX_USER;
288 }
289 }
290
291 class SwXDocumentIndex::Impl final: public SvtListener
292 {
293 private:
294 SwSectionFormat* m_pFormat;
295
296 public:
297 unotools::WeakReference<SwXDocumentIndex> m_wThis;
298 std::mutex m_Mutex; // just for OInterfaceContainerHelper4
299 ::comphelper::OInterfaceContainerHelper4<util::XRefreshListener> m_RefreshListeners;
300 ::comphelper::OInterfaceContainerHelper4<lang::XEventListener> m_EventListeners;
301 SfxItemPropertySet const& m_rPropSet;
302 const TOXTypes m_eTOXType;
303 bool m_bIsDescriptor;
304 SwDoc* m_pDoc;
305 std::optional<SwDocIndexDescriptorProperties_Impl> m_oProps;
306 unotools::WeakReference<StyleAccess_Impl> m_wStyleAccess;
307 unotools::WeakReference<TokenAccess_Impl> m_wTokenAccess;
308
309 Impl(SwDoc& rDoc, const TOXTypes eType, SwTOXBaseSection *const pBaseSection)
310 : m_pFormat(pBaseSection ? pBaseSection->GetFormat() : nullptr)
311 , m_rPropSet(*aSwMapProvider.GetPropertySet(lcl_TypeToPropertyMap_Index(eType)))
312 , m_eTOXType(eType)
313 , m_bIsDescriptor(nullptr == pBaseSection)
314 , m_pDoc(&rDoc)
315 , m_oProps(m_bIsDescriptor
316 ? std::optional<SwDocIndexDescriptorProperties_Impl>(rDoc.GetTOXType(eType, 0))
317 : std::nullopt)
318 {
319 if(m_pFormat)
320 StartListening(m_pFormat->GetNotifier());
321 }
322
323 void SetSectionFormat(SwSectionFormat& rFormat)
324 {
325 EndListeningAll();
326 m_pFormat = &rFormat;
327 StartListening(rFormat.GetNotifier());
328 }
329
330 SwSectionFormat* GetSectionFormat() const {
331 return m_pFormat;
332 }
333
334 SwTOXBase & GetTOXSectionOrThrow() const
335 {
336 SwSectionFormat *const pSectionFormat(GetSectionFormat());
337 SwTOXBase *const pTOXSection( m_bIsDescriptor
338 ? &const_cast<SwDocIndexDescriptorProperties_Impl&>(*m_oProps).GetTOXBase()
339 : (pSectionFormat
340 ? static_cast<SwTOXBaseSection*>(pSectionFormat->GetSection())
341 : nullptr));
342 if (!pTOXSection)
343 {
344 throw uno::RuntimeException(
345 u"SwXDocumentIndex: disposed or invalid"_ustr, nullptr);
346 }
347 return *pTOXSection;
348 }
349
350 sal_Int32 GetFormMax() const
351 {
352 SwTOXBase & rSection( GetTOXSectionOrThrow() );
353 return m_bIsDescriptor
354 ? SwForm::GetFormMaxLevel(m_eTOXType)
355 : rSection.GetTOXForm().GetFormMax();
356 }
357 virtual void Notify(const SfxHint&) override;
358
359 };
360
361 void SwXDocumentIndex::Impl::Notify(const SfxHint& rHint)
362 {
363 if(SfxHintId::SwRemoveUnoObject == rHint.GetId())
364 m_pFormat = nullptr;
365 else if(rHint.GetId() == SfxHintId::Dying)
366 m_pFormat = nullptr;
367 if(!m_pFormat)
368 {
369 EndListeningAll();
370 rtl::Reference<SwXDocumentIndex> const xThis(m_wThis);
371 if (!xThis.is())
372 { // fdo#72695: if UNO object is already dead, don't revive it with event
373 return;
374 }
375 std::unique_lock g(m_Mutex);
376 lang::EventObject const ev(xThis->getXWeak());
377 m_RefreshListeners.disposeAndClear(g, ev);
378 m_EventListeners.disposeAndClear(g, ev);
379 }
380 }
381
382 SwXDocumentIndex::SwXDocumentIndex(
383 SwTOXBaseSection & rBaseSection, SwDoc & rDoc)
384 : m_pImpl( new SwXDocumentIndex::Impl(
385 rDoc, rBaseSection.SwTOXBase::GetType(), & rBaseSection) )
386 {
387 }
388
389 SwXDocumentIndex::SwXDocumentIndex(const TOXTypes eType, SwDoc& rDoc)
390 : m_pImpl( new SwXDocumentIndex::Impl(rDoc, eType, nullptr) )
391 {
392 }
393
394 SwXDocumentIndex::~SwXDocumentIndex()
395 {
396 }
397
398 rtl::Reference<SwXDocumentIndex>
399 SwXDocumentIndex::CreateXDocumentIndex(
400 SwDoc & rDoc, SwTOXBaseSection * pSection, TOXTypes const eTypes)
401 {
402 // re-use existing SwXDocumentIndex
403 // #i105557#: do not iterate over the registered clients: race condition
404 rtl::Reference<SwXDocumentIndex> xIndex;
405 if (pSection)
406 {
407 SwSectionFormat const *const pFormat = pSection->GetFormat();
408 xIndex = dynamic_cast<SwXDocumentIndex*>(pFormat->GetXObject().get().get());
409 }
410 if (!xIndex.is())
411 {
412 if (pSection)
413 {
414 xIndex = new SwXDocumentIndex(*pSection, rDoc);
415 pSection->GetFormat()->SetXObject(xIndex->getXWeak());
416 }
417 else
418 xIndex = new SwXDocumentIndex(eTypes, rDoc);
419
420 // need a permanent Reference to initialize m_wThis
421 xIndex->m_pImpl->m_wThis = xIndex.get();
422 }
423 return xIndex;
424 }
425
426 OUString SAL_CALL
427 SwXDocumentIndex::getImplementationName()
428 {
429 return u"SwXDocumentIndex"_ustr;
430 }
431
432 sal_Bool SAL_CALL
433 SwXDocumentIndex::supportsService(const OUString& rServiceName)
434 {
435 return cppu::supportsService(this, rServiceName);
436 }
437
438 uno::Sequence< OUString > SAL_CALL
439 SwXDocumentIndex::getSupportedServiceNames()
440 {
441 SolarMutexGuard g;
442
443 uno::Sequence< OUString > aRet(2);
444 OUString* pArray = aRet.getArray();
445 pArray[0] = "com.sun.star.text.BaseIndex";
446 switch (m_pImpl->m_eTOXType)
447 {
448 case TOX_INDEX:
449 pArray[1] = "com.sun.star.text.DocumentIndex";
450 break;
451 case TOX_CONTENT:
452 pArray[1] = "com.sun.star.text.ContentIndex";
453 break;
454 case TOX_TABLES:
455 pArray[1] = "com.sun.star.text.TableIndex";
456 break;
457 case TOX_ILLUSTRATIONS:
458 pArray[1] = "com.sun.star.text.IllustrationsIndex";
459 break;
460 case TOX_OBJECTS:
461 pArray[1] = "com.sun.star.text.ObjectIndex";
462 break;
463 case TOX_AUTHORITIES:
464 pArray[1] = "com.sun.star.text.Bibliography";
465 break;
466 //case TOX_USER:
467 default:
468 pArray[1] = "com.sun.star.text.UserDefinedIndex";
469 }
470 return aRet;
471 }
472
473 OUString SAL_CALL SwXDocumentIndex::getServiceName()
474 {
475 SolarMutexGuard g;
476
477 SwServiceType nObjectType = SwServiceType::TypeIndex;
478 switch (m_pImpl->m_eTOXType)
479 {
480 case TOX_USER: nObjectType = SwServiceType::UserIndex;
481 break;
482 case TOX_CONTENT: nObjectType = SwServiceType::ContentIndex;
483 break;
484 case TOX_ILLUSTRATIONS: nObjectType = SwServiceType::IndexIllustrations;
485 break;
486 case TOX_OBJECTS: nObjectType = SwServiceType::IndexObjects;
487 break;
488 case TOX_TABLES: nObjectType = SwServiceType::IndexTables;
489 break;
490 case TOX_AUTHORITIES: nObjectType = SwServiceType::IndexBibliography;
491 break;
492 default:
493 break;
494 }
495 return SwXServiceProvider::GetProviderName(nObjectType);
496 }
497
498 void SAL_CALL SwXDocumentIndex::update()
499 {
500 return refresh(); // update is from deprecated XDocumentIndex
501 }
502
503 uno::Reference< beans::XPropertySetInfo > SAL_CALL
504 SwXDocumentIndex::getPropertySetInfo()
505 {
506 SolarMutexGuard g;
507
508 const uno::Reference< beans::XPropertySetInfo > xRef =
509 m_pImpl->m_rPropSet.getPropertySetInfo();
510 return xRef;
511 }
512
513 void SAL_CALL
514 SwXDocumentIndex::setPropertyValue(
515 const OUString& rPropertyName, const uno::Any& rValue)
516 {
517 SolarMutexGuard aGuard;
518
519 SfxItemPropertyMapEntry const*const pEntry =
520 m_pImpl->m_rPropSet.getPropertyMap().getByName(rPropertyName);
521 if (!pEntry)
522 {
523 throw beans::UnknownPropertyException(
524 "Unknown property: " + rPropertyName,
525 getXWeak());
526 }
527 if (pEntry->nFlags & beans::PropertyAttribute::READONLY)
528 {
529 throw beans::PropertyVetoException(
530 "Property is read-only: " + rPropertyName,
531 getXWeak());
532 }
533
534 SwSectionFormat *const pSectionFormat(m_pImpl->GetSectionFormat());
535 SwTOXBase & rTOXBase( m_pImpl->GetTOXSectionOrThrow() );
536
537 SwTOXElement nCreate = rTOXBase.GetCreateType();
538 SwTOOElements nOLEOptions = rTOXBase.GetOLEOptions();
539 const TOXTypes eTxBaseType = rTOXBase.GetTOXType()->GetType();
540 SwTOIOptions nTOIOptions = (eTxBaseType == TOX_INDEX)
541 ? rTOXBase.GetOptions() : SwTOIOptions::NONE;
542 SwForm aForm(rTOXBase.GetTOXForm());
543 bool bForm = false;
544 switch (pEntry->nWID)
545 {
546 case WID_IDX_TITLE:
547 {
548 OUString sNewName;
549 if (!(rValue >>= sNewName))
550 {
551 throw lang::IllegalArgumentException();
552 }
553 rTOXBase.SetTitle(sNewName);
554 }
555 break;
556 case WID_IDX_NAME:
557 {
558 OUString sNewName;
559 if (!(rValue >>= sNewName))
560 {
561 throw lang::IllegalArgumentException();
562 }
563 rTOXBase.SetTOXName(sNewName);
564 }
565 break;
566 case WID_USER_IDX_NAME:
567 {
568 OUString sNewName;
569 if (!(rValue >>= sNewName))
570 {
571 throw lang::IllegalArgumentException();
572 }
573 lcl_ConvertTOUNameToUserName(sNewName);
574 OSL_ENSURE(TOX_USER == eTxBaseType,
575 "tox type name can only be changed for user indexes");
576 if (pSectionFormat)
577 {
578 if (rTOXBase.GetTOXType()->GetTypeName() != sNewName)
579 {
580 lcl_ReAssignTOXType(*pSectionFormat->GetDoc(),
581 rTOXBase, sNewName);
582 }
583 }
584 else
585 {
586 m_pImpl->m_oProps->SetTypeName(sNewName);
587 }
588 }
589 break;
590 case WID_IDX_LOCALE:
591 {
592 lang::Locale aLocale;
593 if (!(rValue>>= aLocale))
594 {
595 throw lang::IllegalArgumentException();
596 }
597 rTOXBase.SetLanguage( LanguageTag::convertToLanguageType(aLocale));
598 }
599 break;
600 case WID_IDX_SORT_ALGORITHM:
601 {
602 OUString sTmp;
603 if (!(rValue >>= sTmp))
604 {
605 throw lang::IllegalArgumentException();
606 }
607 rTOXBase.SetSortAlgorithm(sTmp);
608 }
609 break;
610 case WID_LEVEL:
611 {
612 rTOXBase.SetLevel(lcl_AnyToType<sal_Int16>(rValue));
613 }
614 break;
615 case WID_TOC_BOOKMARK:
616 {
617 rTOXBase.SetBookmarkName(lcl_AnyToType<OUString>(rValue));
618 nCreate = SwTOXElement::Bookmark;
619 rTOXBase.SetCreate(nCreate);
620 }
621 break;
622 case WID_CREATE_FROM_MARKS:
623 lcl_AnyToBitMask(rValue, nCreate, SwTOXElement::Mark);
624 break;
625 case WID_CREATE_FROM_OUTLINE:
626 lcl_AnyToBitMask(rValue, nCreate, SwTOXElement::OutlineLevel);
627 break;
628 case WID_TOC_PARAGRAPH_OUTLINE_LEVEL:
629 lcl_AnyToBitMask(rValue, nCreate, SwTOXElement::ParagraphOutlineLevel);
630 break;
631 case WID_TAB_IN_TOC:
632 lcl_AnyToBitMask(rValue, nCreate, SwTOXElement::TableInToc);
633 break;
634 case WID_TOC_NEWLINE:
635 lcl_AnyToBitMask(rValue, nCreate, SwTOXElement::Newline);
636 break;
637 // case WID_PARAGRAPH_STYLE_NAMES :OSL_FAIL("not implemented")
638 // break;
639 case WID_HIDE_TABLEADER_PAGENUMBERS:
640 lcl_AnyToBitMask(rValue, nCreate, SwTOXElement::TableLeader);
641 break ;
642 case WID_CREATE_FROM_CHAPTER:
643 rTOXBase.SetFromChapter(lcl_AnyToType<bool>(rValue));
644 break;
645 case WID_CREATE_FROM_LABELS:
646 rTOXBase.SetFromObjectNames(! lcl_AnyToType<bool>(rValue));
647 break;
648 case WID_PROTECTED:
649 {
650 bool bSet = lcl_AnyToType<bool>(rValue);
651 rTOXBase.SetProtected(bSet);
652 if (pSectionFormat)
653 {
654 static_cast<SwTOXBaseSection &>(rTOXBase).SetProtect(bSet);
655 }
656 }
657 break;
658 case WID_USE_ALPHABETICAL_SEPARATORS:
659 lcl_AnyToBitMask(rValue, nTOIOptions,
660 SwTOIOptions::AlphaDelimiter);
661 break;
662 case WID_USE_KEY_AS_ENTRY:
663 lcl_AnyToBitMask(rValue, nTOIOptions,
664 SwTOIOptions::KeyAsEntry);
665 break;
666 case WID_USE_COMBINED_ENTRIES:
667 lcl_AnyToBitMask(rValue, nTOIOptions,
668 SwTOIOptions::SameEntry);
669 break;
670 case WID_IS_CASE_SENSITIVE:
671 lcl_AnyToBitMask(rValue, nTOIOptions,
672 SwTOIOptions::CaseSensitive);
673 break;
674 case WID_USE_P_P:
675 lcl_AnyToBitMask(rValue, nTOIOptions, SwTOIOptions::FF);
676 break;
677 case WID_USE_DASH:
678 lcl_AnyToBitMask(rValue, nTOIOptions, SwTOIOptions::Dash);
679 break;
680 case WID_USE_UPPER_CASE:
681 lcl_AnyToBitMask(rValue, nTOIOptions,
682 SwTOIOptions::InitialCaps);
683 break;
684 case WID_IS_COMMA_SEPARATED:
685 bForm = true;
686 aForm.SetCommaSeparated(lcl_AnyToType<bool>(rValue));
687 break;
688 case WID_LABEL_CATEGORY:
689 {
690 // convert file-format/API/external programmatic english name
691 // to internal UI name before usage
692 rTOXBase.SetSequenceName( SwStyleNameMapper::GetSpecialExtraUIName(
693 ProgName(lcl_AnyToType<OUString>(rValue)) ) );
694 }
695 break;
696 case WID_LABEL_DISPLAY_TYPE:
697 {
698 const sal_Int16 nVal = lcl_AnyToType<sal_Int16>(rValue);
699 sal_uInt16 nSet = CAPTION_COMPLETE;
700 switch (nVal)
701 {
702 case text::ReferenceFieldPart::TEXT:
703 nSet = CAPTION_COMPLETE;
704 break;
705 case text::ReferenceFieldPart::CATEGORY_AND_NUMBER:
706 nSet = CAPTION_NUMBER;
707 break;
708 case text::ReferenceFieldPart::ONLY_CAPTION:
709 nSet = CAPTION_TEXT;
710 break;
711 default:
712 throw lang::IllegalArgumentException();
713 }
714 rTOXBase.SetCaptionDisplay(static_cast<SwCaptionDisplay>(nSet));
715 }
716 break;
717 case WID_USE_LEVEL_FROM_SOURCE:
718 rTOXBase.SetLevelFromChapter(lcl_AnyToType<bool>(rValue));
719 break;
720 case WID_MAIN_ENTRY_CHARACTER_STYLE_NAME:
721 {
722 OUString aString;
723 SwStyleNameMapper::FillUIName(ProgName(lcl_AnyToType<OUString>(rValue)),
724 aString, SwGetPoolIdFromName::ChrFmt);
725 rTOXBase.SetMainEntryCharStyle( aString );
726 }
727 break;
728 case WID_CREATE_FROM_TABLES:
729 lcl_AnyToBitMask(rValue, nCreate, SwTOXElement::Table);
730 break;
731 case WID_CREATE_FROM_TEXT_FRAMES:
732 lcl_AnyToBitMask(rValue, nCreate, SwTOXElement::Frame);
733 break;
734 case WID_CREATE_FROM_GRAPHIC_OBJECTS:
735 lcl_AnyToBitMask(rValue, nCreate, SwTOXElement::Graphic);
736 break;
737 case WID_CREATE_FROM_EMBEDDED_OBJECTS:
738 lcl_AnyToBitMask(rValue, nCreate, SwTOXElement::Ole);
739 break;
740 case WID_CREATE_FROM_STAR_MATH:
741 lcl_AnyToBitMask(rValue, nOLEOptions, SwTOOElements::Math);
742 break;
743 case WID_CREATE_FROM_STAR_CHART:
744 lcl_AnyToBitMask(rValue, nOLEOptions, SwTOOElements::Chart);
745 break;
746 case WID_CREATE_FROM_STAR_CALC:
747 lcl_AnyToBitMask(rValue, nOLEOptions, SwTOOElements::Calc);
748 break;
749 case WID_CREATE_FROM_STAR_DRAW:
750 lcl_AnyToBitMask(rValue, nOLEOptions,
751 SwTOOElements::DrawImpress);
752 break;
753 case WID_CREATE_FROM_OTHER_EMBEDDED_OBJECTS:
754 lcl_AnyToBitMask(rValue, nOLEOptions, SwTOOElements::Other);
755 break;
756 case WID_PARA_HEAD:
757 {
758 OUString aString;
759 SwStyleNameMapper::FillUIName( ProgName(lcl_AnyToType<OUString>(rValue)),
760 aString, SwGetPoolIdFromName::TxtColl);
761 bForm = true;
762 // Header is on Pos 0
763 aForm.SetTemplate( 0, aString );
764 }
765 break;
766 case WID_IS_RELATIVE_TABSTOPS:
767 bForm = true;
768 aForm.SetRelTabPos(lcl_AnyToType<bool>(rValue));
769 break;
770 case WID_PARA_SEP:
771 {
772 OUString aString;
773 bForm = true;
774 SwStyleNameMapper::FillUIName( ProgName(lcl_AnyToType<OUString>(rValue)),
775 aString, SwGetPoolIdFromName::TxtColl);
776 aForm.SetTemplate( 1, aString );
777 }
778 break;
779 case WID_CREATE_FROM_PARAGRAPH_STYLES:
780 lcl_AnyToBitMask(rValue, nCreate, SwTOXElement::Template);
781 break;
782 case WID_CREATE_FROM_PARAGRAPH_STYLE:
783 {
784 OUString style;
785 if (rValue >>= style)
786 {
787 if (style.indexOf(TOX_STYLE_DELIMITER) != -1)
788 {
789 throw lang::IllegalArgumentException();
790 }
791 lcl_AnyToBitMask(uno::Any(true), nCreate, SwTOXElement::Template);
792 OUString uiStyle;
793 SwStyleNameMapper::FillUIName(ProgName(style), uiStyle, SwGetPoolIdFromName::TxtColl);
794 rTOXBase.SetStyleNames(uiStyle, 0);
795 }
796 else if (!rValue.hasValue())
797 {
798 lcl_AnyToBitMask(uno::Any(false), nCreate, SwTOXElement::Template);
799 }
800 else
801 {
802 throw lang::IllegalArgumentException();
803 }
804 }
805 break;
806
807 case WID_PARA_LEV1:
808 case WID_PARA_LEV2:
809 case WID_PARA_LEV3:
810 case WID_PARA_LEV4:
811 case WID_PARA_LEV5:
812 case WID_PARA_LEV6:
813 case WID_PARA_LEV7:
814 case WID_PARA_LEV8:
815 case WID_PARA_LEV9:
816 case WID_PARA_LEV10:
817 {
818 bForm = true;
819 // in sdbcx::Index Label 1 begins at Pos 2 otherwise at Pos 1
820 const sal_uInt16 nLPos = rTOXBase.GetType() == TOX_INDEX ? 2 : 1;
821 OUString aString;
822 SwStyleNameMapper::FillUIName( ProgName(lcl_AnyToType<OUString>(rValue)),
823 aString, SwGetPoolIdFromName::TxtColl);
824 aForm.SetTemplate(nLPos + pEntry->nWID - WID_PARA_LEV1, aString );
825 }
826 break;
827 default:
828 //this is for items only
829 if (WID_PRIMARY_KEY > pEntry->nWID)
830 {
831 const SwAttrSet& rSet =
832 SwDoc::GetTOXBaseAttrSet(rTOXBase);
833 SfxItemSet aAttrSet(rSet);
834 m_pImpl->m_rPropSet.setPropertyValue(
835 rPropertyName, rValue, aAttrSet);
836
837 const SwSectionFormats& rSects = m_pImpl->m_pDoc->GetSections();
838 for (size_t i = 0; i < rSects.size(); ++i)
839 {
840 const SwSectionFormat* pTmpFormat = rSects[ i ];
841 if (pTmpFormat == pSectionFormat)
842 {
843 SwSectionData tmpData(
844 static_cast<SwTOXBaseSection&>(rTOXBase));
845 m_pImpl->m_pDoc->UpdateSection(i, tmpData, & aAttrSet);
846 break;
847 }
848 }
849 }
850 }
851 rTOXBase.SetCreate(nCreate);
852 rTOXBase.SetOLEOptions(nOLEOptions);
853 if (rTOXBase.GetTOXType()->GetType() == TOX_INDEX)
854 {
855 rTOXBase.SetOptions(nTOIOptions);
856 }
857 if (bForm)
858 {
859 rTOXBase.SetTOXForm(aForm);
860 }
861 }
862
863 uno::Any SAL_CALL
864 SwXDocumentIndex::getPropertyValue(const OUString& rPropertyName)
865 {
866 SolarMutexGuard aGuard;
867
868 uno::Any aRet;
869 SfxItemPropertyMapEntry const*const pEntry =
870 m_pImpl->m_rPropSet.getPropertyMap().getByName(rPropertyName);
871 if (!pEntry)
872 {
873 throw beans::UnknownPropertyException(
874 "Unknown property: " + rPropertyName,
875 getXWeak());
876 }
877 // TODO: is this the best approach to tell API clients about the change?
878 if (pEntry->nWID == RES_BACKGROUND && pEntry->nMemberId == MID_GRAPHIC_URL)
879 {
880 throw uno::RuntimeException(u"Getting GraphicURL property is not supported"_ustr);
881 }
882
883 SwSectionFormat *const pSectionFormat( m_pImpl->GetSectionFormat() );
884 SwTOXBase* pTOXBase = nullptr;
885 if (pSectionFormat)
886 {
887 pTOXBase = static_cast<SwTOXBaseSection*>(pSectionFormat->GetSection());
888 }
889 else if (m_pImpl->m_bIsDescriptor)
890 {
891 pTOXBase = &m_pImpl->m_oProps->GetTOXBase();
892 }
893 if(pTOXBase)
894 {
895 const SwTOXElement nCreate = pTOXBase->GetCreateType();
896 const SwTOOElements nOLEOptions = pTOXBase->GetOLEOptions();
897 const SwTOIOptions nTOIOptions =
898 (pTOXBase->GetTOXType()->GetType() == TOX_INDEX)
899 ? pTOXBase->GetOptions()
900 : SwTOIOptions::NONE;
901 const SwForm& rForm = pTOXBase->GetTOXForm();
902 switch(pEntry->nWID)
903 {
904 case WID_IDX_CONTENT_SECTION:
905 case WID_IDX_HEADER_SECTION :
906 if(WID_IDX_CONTENT_SECTION == pEntry->nWID)
907 {
908 const uno::Reference <text::XTextSection> xContentSect =
909 SwXTextSection::CreateXTextSection( pSectionFormat );
910 aRet <<= xContentSect;
911 }
912 else if (pSectionFormat)
913 {
914 SwSections aSectArr;
915 pSectionFormat->GetChildSections(aSectArr,
916 SectionSort::Not, false);
917 for(SwSection* pSect : aSectArr)
918 {
919 if(pSect->GetType() == SectionType::ToxHeader)
920 {
921 const uno::Reference <text::XTextSection> xHeader =
922 SwXTextSection::CreateXTextSection(
923 pSect->GetFormat() );
924 aRet <<= xHeader;
925 break;
926 }
927 }
928 }
929 break;
930 case WID_IDX_TITLE :
931 {
932 aRet <<= pTOXBase->GetTitle();
933 break;
934 }
935 case WID_IDX_NAME:
936 aRet <<= pTOXBase->GetTOXName();
937 break;
938 case WID_USER_IDX_NAME:
939 {
940 OUString sTmp((!m_pImpl->m_bIsDescriptor)
941 ? pTOXBase->GetTOXType()->GetTypeName()
942 : m_pImpl->m_oProps->GetTypeName());
943 //I18N
944 lcl_ConvertTOUNameToProgrammaticName(sTmp);
945 aRet <<= sTmp;
946 }
947 break;
948 case WID_IDX_LOCALE:
949 aRet <<= LanguageTag(pTOXBase->GetLanguage()).getLocale();
950 break;
951 case WID_IDX_SORT_ALGORITHM:
952 aRet <<= pTOXBase->GetSortAlgorithm();
953 break;
954 case WID_LEVEL :
955 aRet <<= static_cast<sal_Int16>(pTOXBase->GetLevel());
956 break;
957 case WID_TOC_BOOKMARK :
958 aRet <<= pTOXBase->GetBookmarkName();
959 break;
960 case WID_CREATE_FROM_MARKS:
961 lcl_BitMaskToAny(aRet, nCreate, SwTOXElement::Mark);
962 break;
963 case WID_CREATE_FROM_OUTLINE:
964 lcl_BitMaskToAny(aRet, nCreate,
965 SwTOXElement::OutlineLevel);
966 break;
967 case WID_CREATE_FROM_CHAPTER:
968 {
969 const bool bRet = pTOXBase->IsFromChapter();
970 aRet <<= bRet;
971 }
972 break;
973 case WID_CREATE_FROM_LABELS:
974 {
975 const bool bRet = ! pTOXBase->IsFromObjectNames();
976 aRet <<= bRet;
977 }
978 break;
979 case WID_PROTECTED:
980 {
981 const bool bRet = pTOXBase->IsProtected();
982 aRet <<= bRet;
983 }
984 break;
985 case WID_USE_ALPHABETICAL_SEPARATORS:
986 lcl_BitMaskToAny(aRet, nTOIOptions,
987 SwTOIOptions::AlphaDelimiter);
988 break;
989 case WID_USE_KEY_AS_ENTRY:
990 lcl_BitMaskToAny(aRet, nTOIOptions,
991 SwTOIOptions::KeyAsEntry);
992 break;
993 case WID_USE_COMBINED_ENTRIES:
994 lcl_BitMaskToAny(aRet, nTOIOptions,
995 SwTOIOptions::SameEntry);
996 break;
997 case WID_IS_CASE_SENSITIVE:
998 lcl_BitMaskToAny(aRet, nTOIOptions,
999 SwTOIOptions::CaseSensitive);
1000 break;
1001 case WID_USE_P_P:
1002 lcl_BitMaskToAny(aRet, nTOIOptions, SwTOIOptions::FF);
1003 break;
1004 case WID_USE_DASH:
1005 lcl_BitMaskToAny(aRet, nTOIOptions, SwTOIOptions::Dash);
1006 break;
1007 case WID_USE_UPPER_CASE:
1008 lcl_BitMaskToAny(aRet, nTOIOptions,
1009 SwTOIOptions::InitialCaps);
1010 break;
1011 case WID_IS_COMMA_SEPARATED:
1012 {
1013 const bool bRet = rForm.IsCommaSeparated();
1014 aRet <<= bRet;
1015 }
1016 break;
1017 case WID_LABEL_CATEGORY:
1018 {
1019 // convert internal UI name to
1020 // file-format/API/external programmatic english name
1021 // before usage
1022 aRet <<= SwStyleNameMapper::GetSpecialExtraProgName(
1023 pTOXBase->GetSequenceName() ).toString();
1024 }
1025 break;
1026 case WID_LABEL_DISPLAY_TYPE:
1027 {
1028 sal_Int16 nSet = text::ReferenceFieldPart::TEXT;
1029 switch (pTOXBase->GetCaptionDisplay())
1030 {
1031 case CAPTION_COMPLETE:
1032 nSet = text::ReferenceFieldPart::TEXT;
1033 break;
1034 case CAPTION_NUMBER:
1035 nSet = text::ReferenceFieldPart::CATEGORY_AND_NUMBER;
1036 break;
1037 case CAPTION_TEXT:
1038 nSet = text::ReferenceFieldPart::ONLY_CAPTION;
1039 break;
1040 }
1041 aRet <<= nSet;
1042 }
1043 break;
1044 case WID_USE_LEVEL_FROM_SOURCE:
1045 {
1046 const bool bRet = pTOXBase->IsLevelFromChapter();
1047 aRet <<= bRet;
1048 }
1049 break;
1050 case WID_LEVEL_FORMAT:
1051 {
1052 rtl::Reference< TokenAccess_Impl > xTokenAccess(
1053 m_pImpl->m_wTokenAccess.get());
1054 if (!xTokenAccess.is())
1055 {
1056 xTokenAccess = new TokenAccess_Impl(*this);
1057 m_pImpl->m_wTokenAccess = xTokenAccess.get();
1058 }
1059 aRet <<= uno::Reference< container::XIndexReplace >(xTokenAccess);
1060 }
1061 break;
1062 case WID_LEVEL_PARAGRAPH_STYLES:
1063 {
1064 rtl::Reference< StyleAccess_Impl > xStyleAccess(
1065 m_pImpl->m_wStyleAccess.get());
1066 if (!xStyleAccess.is())
1067 {
1068 xStyleAccess = new StyleAccess_Impl(*this);
1069 m_pImpl->m_wStyleAccess = xStyleAccess.get();
1070 }
1071 aRet <<= uno::Reference< container::XIndexReplace >(xStyleAccess);
1072 }
1073 break;
1074 case WID_MAIN_ENTRY_CHARACTER_STYLE_NAME:
1075 {
1076 ProgName aString;
1077 SwStyleNameMapper::FillProgName(
1078 pTOXBase->GetMainEntryCharStyle(),
1079 aString,
1080 SwGetPoolIdFromName::ChrFmt);
1081 aRet <<= aString.toString();
1082 }
1083 break;
1084 case WID_CREATE_FROM_TABLES:
1085 lcl_BitMaskToAny(aRet, nCreate, SwTOXElement::Table);
1086 break;
1087 case WID_CREATE_FROM_TEXT_FRAMES:
1088 lcl_BitMaskToAny(aRet, nCreate, SwTOXElement::Frame);
1089 break;
1090 case WID_CREATE_FROM_GRAPHIC_OBJECTS:
1091 lcl_BitMaskToAny(aRet, nCreate, SwTOXElement::Graphic);
1092 break;
1093 case WID_CREATE_FROM_EMBEDDED_OBJECTS:
1094 lcl_BitMaskToAny(aRet, nCreate, SwTOXElement::Ole);
1095 break;
1096 case WID_CREATE_FROM_STAR_MATH:
1097 lcl_BitMaskToAny(aRet, nOLEOptions, SwTOOElements::Math);
1098 break;
1099 case WID_CREATE_FROM_STAR_CHART:
1100 lcl_BitMaskToAny(aRet, nOLEOptions, SwTOOElements::Chart);
1101 break;
1102 case WID_CREATE_FROM_STAR_CALC:
1103 lcl_BitMaskToAny(aRet, nOLEOptions, SwTOOElements::Calc);
1104 break;
1105 case WID_CREATE_FROM_STAR_DRAW:
1106 lcl_BitMaskToAny(aRet, nOLEOptions,
1107 SwTOOElements::DrawImpress);
1108 break;
1109 case WID_CREATE_FROM_OTHER_EMBEDDED_OBJECTS:
1110 lcl_BitMaskToAny(aRet, nOLEOptions, SwTOOElements::Other);
1111 break;
1112 case WID_CREATE_FROM_PARAGRAPH_STYLES:
1113 lcl_BitMaskToAny(aRet, nCreate, SwTOXElement::Template);
1114 break;
1115 case WID_CREATE_FROM_PARAGRAPH_STYLE:
1116 {
1117 if (nCreate & SwTOXElement::Template)
1118 { // there is only one style, at top level
1119 OUString const& rStyle(pTOXBase->GetStyleNames(0));
1120 if (!rStyle.isEmpty())
1121 {
1122 assert(rStyle.indexOf(TOX_STYLE_DELIMITER) == -1);
1123 ProgName ret;
1124 SwStyleNameMapper::FillProgName(rStyle, ret,
1125 SwGetPoolIdFromName::TxtColl);
1126 aRet <<= ret.toString();
1127 }
1128 }
1129 }
1130 break;
1131
1132 case WID_PARA_HEAD:
1133 {
1134 //Header is at position 0
1135 ProgName aString;
1136 SwStyleNameMapper::FillProgName(rForm.GetTemplate( 0 ), aString,
1137 SwGetPoolIdFromName::TxtColl );
1138 aRet <<= aString.toString();
1139 }
1140 break;
1141 case WID_PARA_SEP:
1142 {
1143 ProgName aString;
1144 SwStyleNameMapper::FillProgName(
1145 rForm.GetTemplate( 1 ),
1146 aString,
1147 SwGetPoolIdFromName::TxtColl);
1148 aRet <<= aString.toString();
1149 }
1150 break;
1151 case WID_PARA_LEV1:
1152 case WID_PARA_LEV2:
1153 case WID_PARA_LEV3:
1154 case WID_PARA_LEV4:
1155 case WID_PARA_LEV5:
1156 case WID_PARA_LEV6:
1157 case WID_PARA_LEV7:
1158 case WID_PARA_LEV8:
1159 case WID_PARA_LEV9:
1160 case WID_PARA_LEV10:
1161 {
1162 // in sdbcx::Index Label 1 begins at Pos 2 otherwise at Pos 1
1163 const sal_uInt16 nLPos = pTOXBase->GetType() == TOX_INDEX ? 2 : 1;
1164 ProgName aString;
1165 SwStyleNameMapper::FillProgName(
1166 rForm.GetTemplate(nLPos + pEntry->nWID - WID_PARA_LEV1),
1167 aString,
1168 SwGetPoolIdFromName::TxtColl);
1169 aRet <<= aString.toString();
1170 }
1171 break;
1172 case WID_IS_RELATIVE_TABSTOPS:
1173 {
1174 const bool bRet = rForm.IsRelTabPos();
1175 aRet <<= bRet;
1176 }
1177 break;
1178 case WID_INDEX_MARKS:
1179 {
1180 SwTOXMarks aMarks;
1181 const SwTOXType* pType = pTOXBase->GetTOXType();
1182 pType->CollectTextMarks(aMarks);
1183 uno::Sequence< uno::Reference<text::XDocumentIndexMark> > aXMarks(aMarks.size());
1184 uno::Reference<text::XDocumentIndexMark>* pxMarks = aXMarks.getArray();
1185 for(size_t i = 0; i < aMarks.size(); ++i)
1186 {
1187 SwTOXMark* pMark = aMarks[i];
1188 pxMarks[i] = SwXDocumentIndexMark::CreateXDocumentIndexMark(
1189 *m_pImpl->m_pDoc, pMark);
1190 }
1191 aRet <<= aXMarks;
1192 }
1193 break;
1194 default:
1195 //this is for items only
1196 if(WID_PRIMARY_KEY > pEntry->nWID)
1197 {
1198 const SwAttrSet& rSet =
1199 SwDoc::GetTOXBaseAttrSet(*pTOXBase);
1200 aRet = m_pImpl->m_rPropSet.getPropertyValue(
1201 rPropertyName, rSet);
1202 }
1203 }
1204 }
1205 return aRet;
1206 }
1207
1208 void SAL_CALL
1209 SwXDocumentIndex::addPropertyChangeListener(
1210 const OUString& /*rPropertyName*/,
1211 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
1212 {
1213 OSL_FAIL("SwXDocumentIndex::addPropertyChangeListener(): not implemented");
1214 }
1215
1216 void SAL_CALL
1217 SwXDocumentIndex::removePropertyChangeListener(
1218 const OUString& /*rPropertyName*/,
1219 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
1220 {
1221 OSL_FAIL("SwXDocumentIndex::removePropertyChangeListener(): not implemented");
1222 }
1223
1224 void SAL_CALL
1225 SwXDocumentIndex::addVetoableChangeListener(
1226 const OUString& /*rPropertyName*/,
1227 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
1228 {
1229 OSL_FAIL("SwXDocumentIndex::addVetoableChangeListener(): not implemented");
1230 }
1231
1232 void SAL_CALL
1233 SwXDocumentIndex::removeVetoableChangeListener(
1234 const OUString& /*rPropertyName*/,
1235 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
1236 {
1237 OSL_FAIL("SwXDocumentIndex::removeVetoableChangeListener(): not implemented");
1238 }
1239
1240 static void lcl_CalcLayout(SwDoc *pDoc)
1241 {
1242 SwViewShell *pViewShell = nullptr;
1243 SwEditShell* pEditShell = nullptr;
1244 if( pDoc )
1245 {
1246 pViewShell = pDoc->getIDocumentLayoutAccess().GetCurrentViewShell();
1247 pEditShell = pDoc->GetEditShell();
1248 }
1249
1250 if (pEditShell)
1251 {
1252 pEditShell->CalcLayout();
1253 }
1254 else if (pViewShell)
1255 {
1256 pViewShell->CalcLayout();
1257 }
1258 }
1259
1260 // XRefreshable
1261 void SAL_CALL SwXDocumentIndex::refresh()
1262 {
1263 {
1264 SolarMutexGuard g;
1265
1266 SwSectionFormat *const pFormat = m_pImpl->GetSectionFormat();
1267 SwTOXBaseSection *const pTOXBase = pFormat ?
1268 static_cast<SwTOXBaseSection*>(pFormat->GetSection()) : nullptr;
1269 if (!pTOXBase)
1270 {
1271 throw uno::RuntimeException(
1272 u"SwXDocumentIndex::refresh: must be in attached state"_ustr,
1273 getXWeak());
1274 }
1275 pTOXBase->Update(nullptr, m_pImpl->m_pDoc->getIDocumentLayoutAccess().GetCurrentLayout());
1276
1277 // the insertion of TOC will affect the document layout
1278 lcl_CalcLayout(m_pImpl->m_pDoc);
1279
1280 // page numbers
1281 pTOXBase->UpdatePageNum();
1282 }
1283
1284 std::unique_lock g(m_pImpl->m_Mutex);
1285 if (m_pImpl->m_RefreshListeners.getLength(g))
1286 {
1287 lang::EventObject const event(getXWeak());
1288 m_pImpl->m_RefreshListeners.notifyEach(g, & util::XRefreshListener::refreshed, event);
1289 }
1290 }
1291
1292 void SAL_CALL SwXDocumentIndex::addRefreshListener(
1293 const uno::Reference<util::XRefreshListener>& xListener)
1294 {
1295 // no need to lock here as m_pImpl is const and container threadsafe
1296 std::unique_lock g(m_pImpl->m_Mutex);
1297 m_pImpl->m_RefreshListeners.addInterface(g, xListener);
1298 }
1299
1300 void SAL_CALL SwXDocumentIndex::removeRefreshListener(
1301 const uno::Reference<util::XRefreshListener>& xListener)
1302 {
1303 // no need to lock here as m_pImpl is const and container threadsafe
1304 std::unique_lock g(m_pImpl->m_Mutex);
1305 m_pImpl->m_RefreshListeners.removeInterface(g, xListener);
1306 }
1307
1308 void SAL_CALL
1309 SwXDocumentIndex::attach(const uno::Reference< text::XTextRange > & xTextRange)
1310 {
1311 SolarMutexGuard aGuard;
1312
1313 if (!m_pImpl->m_bIsDescriptor)
1314 {
1315 throw uno::RuntimeException();
1316 }
1317 SwXTextRange *const pRange = dynamic_cast<SwXTextRange*>(xTextRange.get());
1318 OTextCursorHelper *const pCursor = dynamic_cast<OTextCursorHelper*>(xTextRange.get());
1319
1320 SwDoc *const pDoc =
1321 pRange ? &pRange->GetDoc() : (pCursor ? pCursor->GetDoc() : nullptr);
1322 if (!pDoc)
1323 {
1324 throw lang::IllegalArgumentException();
1325 }
1326
1327 SwUnoInternalPaM aPam(*pDoc);
1328 // this now needs to return TRUE
1329 ::sw::XTextRangeToSwPaM(aPam, xTextRange);
1330
1331 const SwTOXBase* pOld = SwDoc::GetCurTOX( *aPam.Start() );
1332 if (pOld)
1333 {
1334 throw lang::IllegalArgumentException();
1335 }
1336
1337 UnoActionContext aAction(pDoc);
1338
1339 SwTOXBase & rTOXBase = m_pImpl->m_oProps->GetTOXBase();
1340 SwTOXType const*const pTOXType = rTOXBase.GetTOXType();
1341 if ((TOX_USER == pTOXType->GetType()) &&
1342 m_pImpl->m_oProps->GetTypeName() != pTOXType->GetTypeName())
1343 {
1344 lcl_ReAssignTOXType(*pDoc, rTOXBase, m_pImpl->m_oProps->GetTypeName());
1345 }
1346 //TODO: apply Section attributes (columns and background)
1347 SwTOXBaseSection *const pTOX =
1348 pDoc->InsertTableOf( aPam, rTOXBase, nullptr, false,
1349 m_pImpl->m_pDoc->getIDocumentLayoutAccess().GetCurrentLayout());
1350
1351 pDoc->SetTOXBaseName(*pTOX, m_pImpl->m_oProps->GetTOXBase().GetTOXName());
1352
1353 // update page numbers
1354 m_pImpl->SetSectionFormat(*pTOX->GetFormat());
1355 pTOX->GetFormat()->SetXObject(getXWeak());
1356 pTOX->UpdatePageNum();
1357
1358 m_pImpl->m_oProps.reset();
1359 m_pImpl->m_pDoc = pDoc;
1360 m_pImpl->m_bIsDescriptor = false;
1361 }
1362
1363 uno::Reference< text::XTextRange > SAL_CALL
1364 SwXDocumentIndex::getAnchor()
1365 {
1366 SolarMutexGuard aGuard;
1367
1368 SwSectionFormat *const pSectionFormat( m_pImpl->GetSectionFormat() );
1369 if (!pSectionFormat)
1370 {
1371 throw uno::RuntimeException();
1372 }
1373
1374 rtl::Reference<SwXTextRange> xRet;
1375 SwNodeIndex const*const pIdx( pSectionFormat->GetContent().GetContentIdx() );
1376 if (pIdx && pIdx->GetNode().GetNodes().IsDocNodes())
1377 {
1378 SwPaM aPaM(*pIdx);
1379 aPaM.Move( fnMoveForward, GoInContent );
1380 aPaM.SetMark();
1381 aPaM.GetPoint()->Assign( *pIdx->GetNode().EndOfSectionNode() );
1382 aPaM.Move( fnMoveBackward, GoInContent );
1383 xRet = SwXTextRange::CreateXTextRange(*pSectionFormat->GetDoc(),
1384 *aPaM.GetMark(), aPaM.GetPoint());
1385 }
1386 return xRet;
1387 }
1388
1389 void SAL_CALL SwXDocumentIndex::dispose()
1390 {
1391 SolarMutexGuard aGuard;
1392
1393 SwSectionFormat *const pSectionFormat( m_pImpl->GetSectionFormat() );
1394 if (pSectionFormat)
1395 {
1396 pSectionFormat->GetDoc()->DeleteTOX(
1397 *static_cast<SwTOXBaseSection*>(pSectionFormat->GetSection()),
1398 true);
1399 }
1400 }
1401
1402 void SAL_CALL
1403 SwXDocumentIndex::addEventListener(
1404 const uno::Reference< lang::XEventListener > & xListener)
1405 {
1406 // no need to lock here as m_pImpl is const and container threadsafe
1407 std::unique_lock g(m_pImpl->m_Mutex);
1408 m_pImpl->m_EventListeners.addInterface(g, xListener);
1409 }
1410
1411 void SAL_CALL
1412 SwXDocumentIndex::removeEventListener(
1413 const uno::Reference< lang::XEventListener > & xListener)
1414 {
1415 // no need to lock here as m_pImpl is const and container threadsafe
1416 std::unique_lock g(m_pImpl->m_Mutex);
1417 m_pImpl->m_EventListeners.removeInterface(g, xListener);
1418 }
1419
1420 OUString SAL_CALL SwXDocumentIndex::getName()
1421 {
1422 SolarMutexGuard g;
1423
1424 SwSectionFormat *const pSectionFormat( m_pImpl->GetSectionFormat() );
1425 if (m_pImpl->m_bIsDescriptor)
1426 {
1427 return m_pImpl->m_oProps->GetTOXBase().GetTOXName();
1428 }
1429
1430 if(!pSectionFormat)
1431 {
1432 throw uno::RuntimeException();
1433 }
1434
1435 return pSectionFormat->GetSection()->GetSectionName();
1436 }
1437
1438 void SAL_CALL
1439 SwXDocumentIndex::setName(const OUString& rName)
1440 {
1441 SolarMutexGuard g;
1442
1443 if (rName.isEmpty())
1444 {
1445 throw uno::RuntimeException();
1446 }
1447
1448 SwSectionFormat *const pSectionFormat( m_pImpl->GetSectionFormat() );
1449 if (m_pImpl->m_bIsDescriptor)
1450 {
1451 m_pImpl->m_oProps->GetTOXBase().SetTOXName(rName);
1452 }
1453 else if (pSectionFormat)
1454 {
1455 const bool bSuccess = pSectionFormat->GetDoc()->SetTOXBaseName(
1456 *static_cast<SwTOXBaseSection*>(pSectionFormat->GetSection()), rName);
1457 if (!bSuccess)
1458 {
1459 throw uno::RuntimeException();
1460 }
1461 }
1462 else
1463 {
1464 throw uno::RuntimeException();
1465 }
1466 }
1467
1468 // MetadatableMixin
1469 ::sfx2::Metadatable* SwXDocumentIndex::GetCoreObject()
1470 {
1471 SwSectionFormat *const pSectionFormat( m_pImpl->GetSectionFormat() );
1472 return pSectionFormat;
1473 }
1474
1475 uno::Reference<frame::XModel> SwXDocumentIndex::GetModel()
1476 {
1477 SwSectionFormat *const pSectionFormat( m_pImpl->GetSectionFormat() );
1478 if (pSectionFormat)
1479 {
1480 SwDocShell const*const pShell( pSectionFormat->GetDoc()->GetDocShell() );
1481 return pShell ? pShell->GetModel() : nullptr;
1482 }
1483 return nullptr;
1484 }
1485
1486 static sal_uInt16
1487 lcl_TypeToPropertyMap_Mark(const TOXTypes eType)
1488 {
1489 switch (eType)
1490 {
1491 case TOX_INDEX: return PROPERTY_MAP_INDEX_MARK;
1492 case TOX_CONTENT: return PROPERTY_MAP_CNTIDX_MARK;
1493 case TOX_CITATION : return PROPERTY_MAP_FLDTYP_BIBLIOGRAPHY;
1494 //case TOX_USER:
1495 default:
1496 return PROPERTY_MAP_USER_MARK;
1497 }
1498 }
1499
1500 class SwXDocumentIndexMark::Impl final: public SvtListener
1501 {
1502 private:
1503 SwXDocumentIndexMark & m_rThis;
1504 bool m_bInReplaceMark;
1505
1506 public:
1507
1508 unotools::WeakReference<SwXDocumentIndexMark> m_wThis;
1509 SfxItemPropertySet const& m_rPropSet;
1510 const TOXTypes m_eTOXType;
1511 std::mutex m_Mutex; // just for OInterfaceContainerHelper4
1512 ::comphelper::OInterfaceContainerHelper4<css::lang::XEventListener> m_EventListeners;
1513 bool m_bIsDescriptor;
1514 const SwTOXType* m_pTOXType;
1515 const SwTOXMark* m_pTOXMark;
1516 SwDoc* m_pDoc;
1517
1518 bool m_bMainEntry;
1519 sal_uInt16 m_nLevel;
1520 OUString m_aBookmarkName;
1521 OUString m_sAltText;
1522 OUString m_sPrimaryKey;
1523 OUString m_sSecondaryKey;
1524 OUString m_sTextReading;
1525 OUString m_sPrimaryKeyReading;
1526 OUString m_sSecondaryKeyReading;
1527 OUString m_sUserIndexName;
1528
1529 Impl(SwXDocumentIndexMark& rThis,
1530 SwDoc* const pDoc,
1531 const enum TOXTypes eType,
1532 const SwTOXType* pType,
1533 SwTOXMark const* pMark)
1534 : m_rThis(rThis)
1535 , m_bInReplaceMark(false)
1536 , m_rPropSet(
1537 *aSwMapProvider.GetPropertySet(lcl_TypeToPropertyMap_Mark(eType)))
1538 , m_eTOXType(eType)
1539 , m_bIsDescriptor(nullptr == pMark)
1540 , m_pTOXType(pType)
1541 , m_pTOXMark(pMark)
1542 , m_pDoc(pDoc)
1543 , m_bMainEntry(false)
1544 , m_nLevel(0)
1545 {
1546 auto pTypeNonConst = const_cast<SwTOXType*>(m_pTOXType);
1547
1548 if(pTypeNonConst)
1549 StartListening(pTypeNonConst->GetNotifier());
1550 }
1551
1552 SwTOXType* GetTOXType() const {
1553 return const_cast<SwTOXType*>(m_pTOXType);
1554 }
1555
1556 void DeleteTOXMark()
1557 {
1558 m_pDoc->DeleteTOXMark(m_pTOXMark);
1559 Invalidate();
1560 }
1561
1562 void InsertTOXMark(const SwTOXType & rTOXType, SwTOXMark & rMark, SwPaM & rPam,
1563 SwXTextCursor const*const pTextCursor);
1564
1565 void ReplaceTOXMark(const SwTOXType & rTOXType, SwTOXMark & rMark, SwPaM & rPam)
1566 {
1567 m_bInReplaceMark = true;
1568 DeleteTOXMark();
1569 m_bInReplaceMark = false;
1570 try {
1571 InsertTOXMark(rTOXType, rMark, rPam, nullptr);
1572 } catch (...) {
1573 OSL_FAIL("ReplaceTOXMark() failed!");
1574 lang::EventObject const ev(m_rThis.getXWeak());
1575 std::unique_lock aGuard(m_Mutex);
1576 m_EventListeners.disposeAndClear(aGuard, ev);
1577 throw;
1578 }
1579 }
1580
1581 void Invalidate();
1582 virtual void Notify(const SfxHint&) override;
1583 };
1584
1585 void SwXDocumentIndexMark::Impl::Invalidate()
1586 {
1587 if (!m_bInReplaceMark) // #i109983# only dispose on delete, not on replace!
1588 {
1589 rtl::Reference<SwXDocumentIndexMark> const xThis(m_wThis);
1590 // fdo#72695: if UNO object is already dead, don't revive it with event
1591 if (xThis.is())
1592 {
1593 lang::EventObject const ev(xThis->getXWeak());
1594 std::unique_lock aGuard(m_Mutex);
1595 m_EventListeners.disposeAndClear(aGuard, ev);
1596 }
1597 }
1598 EndListeningAll();
1599 m_pDoc = nullptr;
1600 m_pTOXMark = nullptr;
1601 m_pTOXType = nullptr;
1602 }
1603
1604 void SwXDocumentIndexMark::Impl::Notify(const SfxHint& rHint)
1605 {
1606 if(rHint.GetId() == SfxHintId::SwModifyChanged)
1607 {
1608 auto pModifyChangedHint = static_cast<const sw::ModifyChangedHint*>(&rHint);
1609 if(auto pNewType = dynamic_cast<const SwTOXType*>(pModifyChangedHint->m_pNew))
1610 m_pTOXType = pNewType;
1611 }
1612 }
1613
1614 SwXDocumentIndexMark::SwXDocumentIndexMark(const TOXTypes eToxType)
1615 : m_pImpl( new SwXDocumentIndexMark::Impl(*this, nullptr, eToxType, nullptr, nullptr) )
1616 {
1617 }
1618
1619 SwXDocumentIndexMark::SwXDocumentIndexMark(SwDoc & rDoc,
1620 const SwTOXType & rType, const SwTOXMark & rMark)
1621 : m_pImpl( new SwXDocumentIndexMark::Impl(*this, &rDoc, rType.GetType(),
1622 &rType, &rMark) )
1623 {
1624 }
1625
1626 SwXDocumentIndexMark::~SwXDocumentIndexMark()
1627 {
1628 }
1629
1630 // called when the associated SwTOXMark is deleted
1631 void SwXDocumentIndexMark::OnSwTOXMarkDeleted()
1632 {
1633 m_pImpl->Invalidate();
1634 }
1635
1636 rtl::Reference<SwXDocumentIndexMark>
1637 SwXDocumentIndexMark::CreateXDocumentIndexMark(
1638 SwDoc & rDoc, SwTOXMark *const pMark, TOXTypes const eType)
1639 {
1640 // re-use existing SwXDocumentIndexMark
1641 // NB: xmloff depends on this caching to generate ID from the address!
1642 // #i105557#: do not iterate over the registered clients: race condition
1643 rtl::Reference<SwXDocumentIndexMark> xTOXMark;
1644 if (pMark)
1645 {
1646 xTOXMark = pMark->GetXTOXMark();
1647 }
1648 if (!xTOXMark.is())
1649 {
1650 if (pMark)
1651 {
1652 xTOXMark = new SwXDocumentIndexMark(rDoc,
1653 *const_cast<SwTOXType*>(pMark->GetTOXType()), *pMark);
1654 pMark->SetXTOXMark(xTOXMark);
1655 }
1656 else
1657 xTOXMark = new SwXDocumentIndexMark(eType);
1658
1659 // need a permanent Reference to initialize m_wThis
1660 xTOXMark->m_pImpl->m_wThis = xTOXMark.get();
1661 }
1662 return xTOXMark;
1663 }
1664
1665 namespace
1666 {
1667 }
1668
1669 OUString SAL_CALL
1670 SwXDocumentIndexMark::getImplementationName()
1671 {
1672 return u"SwXDocumentIndexMark"_ustr;
1673 }
1674
1675 sal_Bool SAL_CALL SwXDocumentIndexMark::supportsService(const OUString& rServiceName)
1676 {
1677 return cppu::supportsService(this, rServiceName);
1678 }
1679
1680 uno::Sequence< OUString > SAL_CALL
1681 SwXDocumentIndexMark::getSupportedServiceNames()
1682 {
1683 SolarMutexGuard g;
1684
1685 const sal_Int32 nCnt = (m_pImpl->m_eTOXType == TOX_INDEX) ? 4 : 3;
1686 uno::Sequence< OUString > aRet(nCnt);
1687 OUString* pArray = aRet.getArray();
1688 pArray[0] = "com.sun.star.text.BaseIndexMark";
1689 pArray[1] = "com.sun.star.text.TextContent";
1690 switch (m_pImpl->m_eTOXType)
1691 {
1692 case TOX_USER:
1693 pArray[2] = "com.sun.star.text.UserIndexMark";
1694 break;
1695 case TOX_CONTENT:
1696 pArray[2] = "com.sun.star.text.ContentIndexMark";
1697 break;
1698 case TOX_INDEX:
1699 pArray[2] = "com.sun.star.text.DocumentIndexMark";
1700 pArray[3] = "com.sun.star.text.DocumentIndexMarkAsian";
1701 break;
1702
1703 default:
1704 ;
1705 }
1706 return aRet;
1707 }
1708
1709 OUString SAL_CALL
1710 SwXDocumentIndexMark::getMarkEntry()
1711 {
1712 SolarMutexGuard aGuard;
1713
1714 SwTOXType *const pType = m_pImpl->GetTOXType();
1715 if (pType && m_pImpl->m_pTOXMark)
1716 {
1717 return m_pImpl->m_pTOXMark->GetAlternativeText();
1718 }
1719
1720 if (!m_pImpl->m_bIsDescriptor)
1721 {
1722 throw uno::RuntimeException();
1723 }
1724
1725 return m_pImpl->m_sAltText;
1726 }
1727
1728 void SAL_CALL
1729 SwXDocumentIndexMark::setMarkEntry(const OUString& rIndexEntry)
1730 {
1731 SolarMutexGuard aGuard;
1732
1733 SwTOXType *const pType = m_pImpl->GetTOXType();
1734 if (pType && m_pImpl->m_pTOXMark)
1735 {
1736 SwTOXMark aMark(*m_pImpl->m_pTOXMark);
1737 aMark.SetAlternativeText(rIndexEntry);
1738 SwTextTOXMark const*const pTextMark =
1739 m_pImpl->m_pTOXMark->GetTextTOXMark();
1740 SwPaM aPam(pTextMark->GetTextNode(), pTextMark->GetStart());
1741 aPam.SetMark();
1742 if(pTextMark->End())
1743 {
1744 aPam.GetPoint()->SetContent( *pTextMark->End() );
1745 }
1746 else
1747 aPam.GetPoint()->AdjustContent(1);
1748
1749 m_pImpl->ReplaceTOXMark(*pType, aMark, aPam);
1750 }
1751 else if (m_pImpl->m_bIsDescriptor)
1752 {
1753 m_pImpl->m_sAltText = rIndexEntry;
1754 }
1755 else
1756 {
1757 throw uno::RuntimeException();
1758 }
1759 }
1760
1761 void SAL_CALL
1762 SwXDocumentIndexMark::attach(
1763 const uno::Reference< text::XTextRange > & xTextRange)
1764 {
1765 SolarMutexGuard aGuard;
1766
1767 if (!m_pImpl->m_bIsDescriptor)
1768 {
1769 throw uno::RuntimeException();
1770 }
1771
1772 SwXTextRange *const pRange =
1773 dynamic_cast<SwXTextRange*>(xTextRange.get());
1774 OTextCursorHelper *const pCursor =
1775 dynamic_cast<OTextCursorHelper*>(xTextRange.get());
1776 SwDoc *const pDoc =
1777 pRange ? &pRange->GetDoc() : (pCursor ? pCursor->GetDoc() : nullptr);
1778 if (!pDoc)
1779 {
1780 throw lang::IllegalArgumentException();
1781 }
1782
1783 const SwTOXType* pTOXType = nullptr;
1784 switch (m_pImpl->m_eTOXType)
1785 {
1786 case TOX_INDEX:
1787 case TOX_CONTENT:
1788 case TOX_CITATION:
1789 pTOXType = pDoc->GetTOXType( m_pImpl->m_eTOXType, 0 );
1790 break;
1791 case TOX_USER:
1792 {
1793 if (m_pImpl->m_sUserIndexName.isEmpty())
1794 {
1795 pTOXType = pDoc->GetTOXType( m_pImpl->m_eTOXType, 0 );
1796 }
1797 else
1798 {
1799 const sal_uInt16 nCount =
1800 pDoc->GetTOXTypeCount(m_pImpl->m_eTOXType);
1801 for (sal_uInt16 i = 0; i < nCount; i++)
1802 {
1803 SwTOXType const*const pTemp =
1804 pDoc->GetTOXType( m_pImpl->m_eTOXType, i );
1805 if (m_pImpl->m_sUserIndexName == pTemp->GetTypeName())
1806 {
1807 pTOXType = pTemp;
1808 break;
1809 }
1810 }
1811 if (!pTOXType)
1812 {
1813 SwTOXType aUserType(*pDoc, TOX_USER, m_pImpl->m_sUserIndexName);
1814 pTOXType = pDoc->InsertTOXType(aUserType);
1815 }
1816 }
1817 }
1818 break;
1819
1820 default:
1821 break;
1822 }
1823 if (!pTOXType)
1824 {
1825 throw lang::IllegalArgumentException();
1826 }
1827
1828 SwUnoInternalPaM aPam(*pDoc);
1829 // this now needs to return TRUE
1830 ::sw::XTextRangeToSwPaM(aPam, xTextRange);
1831 SwTOXMark aMark (pTOXType);
1832 if (!m_pImpl->m_sAltText.isEmpty())
1833 {
1834 aMark.SetAlternativeText(m_pImpl->m_sAltText);
1835 }
1836 switch (m_pImpl->m_eTOXType)
1837 {
1838 case TOX_INDEX:
1839 if (!m_pImpl->m_sPrimaryKey.isEmpty())
1840 {
1841 aMark.SetPrimaryKey(m_pImpl->m_sPrimaryKey);
1842 }
1843 if (!m_pImpl->m_sSecondaryKey.isEmpty())
1844 {
1845 aMark.SetSecondaryKey(m_pImpl->m_sSecondaryKey);
1846 }
1847 if (!m_pImpl->m_sTextReading.isEmpty())
1848 {
1849 aMark.SetTextReading(m_pImpl->m_sTextReading);
1850 }
1851 if (!m_pImpl->m_sPrimaryKeyReading.isEmpty())
1852 {
1853 aMark.SetPrimaryKeyReading(m_pImpl->m_sPrimaryKeyReading);
1854 }
1855 if (!m_pImpl->m_sSecondaryKeyReading.isEmpty())
1856 {
1857 aMark.SetSecondaryKeyReading(m_pImpl->m_sSecondaryKeyReading);
1858 }
1859 aMark.SetMainEntry(m_pImpl->m_bMainEntry);
1860 break;
1861 case TOX_CITATION:
1862 aMark.SetMainEntry(m_pImpl->m_bMainEntry);
1863 break;
1864 case TOX_USER:
1865 case TOX_CONTENT:
1866 if (USHRT_MAX != m_pImpl->m_nLevel)
1867 {
1868 aMark.SetLevel(m_pImpl->m_nLevel+1);
1869 }
1870 break;
1871
1872 default:
1873 break;
1874 }
1875
1876 m_pImpl->InsertTOXMark(*const_cast<SwTOXType *>(pTOXType), aMark, aPam,
1877 dynamic_cast<SwXTextCursor const*>(pCursor));
1878
1879 m_pImpl->m_bIsDescriptor = false;
1880 }
1881
1882 namespace {
1883
1884 template<typename T> struct NotContainedIn
1885 {
1886 std::vector<T> const& m_rVector;
1887 explicit NotContainedIn(std::vector<T> const& rVector)
1888 : m_rVector(rVector) { }
1889 bool operator() (T const& rT) {
1890 return std::find(m_rVector.begin(), m_rVector.end(), rT)
1891 == m_rVector.end();
1892 }
1893 };
1894
1895 }
1896
1897 void SwXDocumentIndexMark::Impl::InsertTOXMark(
1898 const SwTOXType & rTOXType, SwTOXMark & rMark, SwPaM & rPam,
1899 SwXTextCursor const*const pTextCursor)
1900 {
1901 SwDoc& rDoc(rPam.GetDoc());
1902 UnoActionContext aAction(&rDoc);
1903 bool bMark = *rPam.GetPoint() != *rPam.GetMark();
1904 // n.b.: toxmarks must have either alternative text or an extent
1905 if (bMark && !rMark.GetAlternativeText().isEmpty())
1906 {
1907 rPam.Normalize();
1908 rPam.DeleteMark();
1909 bMark = false;
1910 }
1911 // Marks without alternative text and without selected text cannot be inserted,
1912 // thus use a space - is this really the ideal solution?
1913 if (!bMark && rMark.GetAlternativeText().isEmpty())
1914 {
1915 rMark.SetAlternativeText( u" "_ustr );
1916 }
1917
1918 const bool bForceExpandHints( !bMark && pTextCursor && pTextCursor->IsAtEndOfMeta() );
1919 const SetAttrMode nInsertFlags = bForceExpandHints
1920 ? ( SetAttrMode::FORCEHINTEXPAND
1921 | SetAttrMode::DONTEXPAND)
1922 : SetAttrMode::DONTEXPAND;
1923
1924 // rMark gets copied into the document pool;
1925 // pNewTextAttr comes back with the real format
1926 SwTextAttr *pNewTextAttr = nullptr;
1927 rDoc.getIDocumentContentOperations().InsertPoolItem(rPam, rMark, nInsertFlags,
1928 /*pLayout*/nullptr, &pNewTextAttr);
1929 if (bMark && *rPam.GetPoint() > *rPam.GetMark())
1930 {
1931 rPam.Exchange();
1932 }
1933
1934 if (!pNewTextAttr)
1935 {
1936 throw uno::RuntimeException(
1937 u"SwXDocumentIndexMark::InsertTOXMark(): cannot insert attribute"_ustr,
1938 nullptr);
1939 }
1940
1941 m_pDoc = &rDoc;
1942 m_pTOXMark = &pNewTextAttr->GetTOXMark();
1943 m_pTOXType = &rTOXType;
1944 EndListeningAll();
1945 StartListening(const_cast<SwTOXType*>(m_pTOXType)->GetNotifier());
1946 }
1947
1948 uno::Reference< text::XTextRange > SAL_CALL
1949 SwXDocumentIndexMark::getAnchor()
1950 {
1951 SolarMutexGuard aGuard;
1952
1953 SwTOXType *const pType = m_pImpl->GetTOXType();
1954 if (!pType || !m_pImpl->m_pTOXMark)
1955 {
1956 throw uno::RuntimeException();
1957 }
1958 if (!m_pImpl->m_pTOXMark->GetTextTOXMark())
1959 {
1960 throw uno::RuntimeException();
1961 }
1962 const SwTextTOXMark* pTextMark = m_pImpl->m_pTOXMark->GetTextTOXMark();
1963 SwPaM aPam(pTextMark->GetTextNode(), pTextMark->GetStart());
1964 aPam.SetMark();
1965 if(pTextMark->End())
1966 {
1967 aPam.GetPoint()->SetContent( *pTextMark->End() );
1968 }
1969 else
1970 {
1971 aPam.GetPoint()->AdjustContent(1);
1972 }
1973 uno::Reference< text::XTextRange > xRet;
1974 if(SwDocShell* pShell = m_pImpl->m_pDoc->GetDocShell())
1975 {
1976 const rtl::Reference< SwXTextDocument > xModel =
1977 pShell->GetBaseModel();
1978 xRet = new SwXTextRange(aPam, xModel->getText());
1979 }
1980
1981 return xRet;
1982 }
1983
1984 void SAL_CALL
1985 SwXDocumentIndexMark::dispose()
1986 {
1987 SolarMutexGuard aGuard;
1988
1989 SwTOXType *const pType = m_pImpl->GetTOXType();
1990 if (pType && m_pImpl->m_pTOXMark)
1991 {
1992 m_pImpl->DeleteTOXMark(); // call Invalidate() via modify!
1993 }
1994 }
1995
1996 void SAL_CALL
1997 SwXDocumentIndexMark::addEventListener(
1998 const uno::Reference< lang::XEventListener > & xListener)
1999 {
2000 // no need to lock here as m_pImpl is const and container threadsafe
2001 std::unique_lock aGuard(m_pImpl->m_Mutex);
2002 m_pImpl->m_EventListeners.addInterface(aGuard, xListener);
2003 }
2004
2005 void SAL_CALL
2006 SwXDocumentIndexMark::removeEventListener(
2007 const uno::Reference< lang::XEventListener > & xListener)
2008 {
2009 // no need to lock here as m_pImpl is const and container threadsafe
2010 std::unique_lock aGuard(m_pImpl->m_Mutex);
2011 m_pImpl->m_EventListeners.removeInterface(aGuard, xListener);
2012 }
2013
2014 uno::Reference< beans::XPropertySetInfo > SAL_CALL
2015 SwXDocumentIndexMark::getPropertySetInfo()
2016 {
2017 SolarMutexGuard g;
2018
2019 static uno::Reference< beans::XPropertySetInfo > xInfos[3];
2020 int nPos = 0;
2021 switch (m_pImpl->m_eTOXType)
2022 {
2023 case TOX_INDEX: nPos = 0; break;
2024 case TOX_CONTENT: nPos = 1; break;
2025 case TOX_USER: nPos = 2; break;
2026 default:
2027 ;
2028 }
2029 if(!xInfos[nPos].is())
2030 {
2031 const uno::Reference< beans::XPropertySetInfo > xInfo =
2032 m_pImpl->m_rPropSet.getPropertySetInfo();
2033 // extend PropertySetInfo!
2034 const uno::Sequence<beans::Property> aPropSeq = xInfo->getProperties();
2035 xInfos[nPos] = new SfxExtItemPropertySetInfo(
2036 aSwMapProvider.GetPropertyMapEntries(
2037 PROPERTY_MAP_PARAGRAPH_EXTENSIONS),
2038 aPropSeq );
2039 }
2040 return xInfos[nPos];
2041 }
2042
2043 void SAL_CALL
2044 SwXDocumentIndexMark::setPropertyValue(
2045 const OUString& rPropertyName, const uno::Any& rValue)
2046 {
2047 SolarMutexGuard aGuard;
2048
2049 SfxItemPropertyMapEntry const*const pEntry =
2050 m_pImpl->m_rPropSet.getPropertyMap().getByName(rPropertyName);
2051 if (!pEntry)
2052 {
2053 throw beans::UnknownPropertyException(
2054 "Unknown property: " + rPropertyName,
2055 getXWeak());
2056 }
2057 if (pEntry->nFlags & beans::PropertyAttribute::READONLY)
2058 {
2059 throw beans::PropertyVetoException(
2060 "Property is read-only: " + rPropertyName,
2061 getXWeak());
2062 }
2063
2064 SwTOXType *const pType = m_pImpl->GetTOXType();
2065 if (pType && m_pImpl->m_pTOXMark)
2066 {
2067 SwTOXMark aMark(*m_pImpl->m_pTOXMark);
2068 switch(pEntry->nWID)
2069 {
2070 case WID_ALT_TEXT:
2071 aMark.SetAlternativeText(lcl_AnyToType<OUString>(rValue));
2072 break;
2073 case WID_LEVEL:
2074 aMark.SetLevel(std::min( static_cast<sal_Int8>( MAXLEVEL ),
2075 static_cast<sal_Int8>(lcl_AnyToType<sal_Int16>(rValue)+1)));
2076 break;
2077 case WID_TOC_BOOKMARK :
2078 aMark.SetBookmarkName(lcl_AnyToType<OUString>(rValue));
2079 break;
2080 case WID_PRIMARY_KEY :
2081 aMark.SetPrimaryKey(lcl_AnyToType<OUString>(rValue));
2082 break;
2083 case WID_SECONDARY_KEY:
2084 aMark.SetSecondaryKey(lcl_AnyToType<OUString>(rValue));
2085 break;
2086 case WID_MAIN_ENTRY:
2087 aMark.SetMainEntry(lcl_AnyToType<bool>(rValue));
2088 break;
2089 case WID_TEXT_READING:
2090 aMark.SetTextReading(lcl_AnyToType<OUString>(rValue));
2091 break;
2092 case WID_PRIMARY_KEY_READING:
2093 aMark.SetPrimaryKeyReading(lcl_AnyToType<OUString>(rValue));
2094 break;
2095 case WID_SECONDARY_KEY_READING:
2096 aMark.SetSecondaryKeyReading(lcl_AnyToType<OUString>(rValue));
2097 break;
2098 }
2099 SwTextTOXMark const*const pTextMark =
2100 m_pImpl->m_pTOXMark->GetTextTOXMark();
2101 SwPaM aPam(pTextMark->GetTextNode(), pTextMark->GetStart());
2102 aPam.SetMark();
2103 if(pTextMark->End())
2104 {
2105 aPam.GetPoint()->SetContent(*pTextMark->End());
2106 }
2107 else
2108 {
2109 aPam.GetPoint()->AdjustContent(1);
2110 }
2111
2112 m_pImpl->ReplaceTOXMark(*pType, aMark, aPam);
2113 }
2114 else if (m_pImpl->m_bIsDescriptor)
2115 {
2116 switch(pEntry->nWID)
2117 {
2118 case WID_ALT_TEXT:
2119 m_pImpl->m_sAltText = lcl_AnyToType<OUString>(rValue);
2120 break;
2121 case WID_LEVEL:
2122 {
2123 const sal_Int16 nVal = lcl_AnyToType<sal_Int16>(rValue);
2124 if(nVal < 0 || nVal >= MAXLEVEL)
2125 {
2126 throw lang::IllegalArgumentException();
2127 }
2128 m_pImpl->m_nLevel = nVal;
2129 }
2130 break;
2131 case WID_TOC_BOOKMARK :
2132 {
2133 m_pImpl->m_aBookmarkName = lcl_AnyToType<OUString>(rValue);
2134 }
2135 break;
2136 case WID_PRIMARY_KEY:
2137 m_pImpl->m_sPrimaryKey = lcl_AnyToType<OUString>(rValue);
2138 break;
2139 case WID_SECONDARY_KEY:
2140 m_pImpl->m_sSecondaryKey = lcl_AnyToType<OUString>(rValue);
2141 break;
2142 case WID_TEXT_READING:
2143 m_pImpl->m_sTextReading = lcl_AnyToType<OUString>(rValue);
2144 break;
2145 case WID_PRIMARY_KEY_READING:
2146 m_pImpl->m_sPrimaryKeyReading = lcl_AnyToType<OUString>(rValue);
2147 break;
2148 case WID_SECONDARY_KEY_READING:
2149 m_pImpl->m_sSecondaryKeyReading = lcl_AnyToType<OUString>(rValue);
2150 break;
2151 case WID_USER_IDX_NAME:
2152 {
2153 OUString sTmp(lcl_AnyToType<OUString>(rValue));
2154 lcl_ConvertTOUNameToUserName(sTmp);
2155 m_pImpl->m_sUserIndexName = sTmp;
2156 }
2157 break;
2158 case WID_MAIN_ENTRY:
2159 m_pImpl->m_bMainEntry = lcl_AnyToType<bool>(rValue);
2160 break;
2161 case PROPERTY_MAP_INDEX_OBJECTS:
2162 // unsupported
2163 break;
2164 }
2165 }
2166 else
2167 {
2168 throw uno::RuntimeException();
2169 }
2170 }
2171
2172 uno::Any SAL_CALL
2173 SwXDocumentIndexMark::getPropertyValue(const OUString& rPropertyName)
2174 {
2175 SolarMutexGuard aGuard;
2176
2177 uno::Any aRet;
2178 SfxItemPropertyMapEntry const*const pEntry =
2179 m_pImpl->m_rPropSet.getPropertyMap().getByName(rPropertyName);
2180 if (!pEntry)
2181 {
2182 throw beans::UnknownPropertyException(
2183 "Unknown property: " + rPropertyName,
2184 getXWeak());
2185 }
2186 if (::sw::GetDefaultTextContentValue(aRet, rPropertyName, pEntry->nWID))
2187 {
2188 return aRet;
2189 }
2190
2191 SwTOXType *const pType = m_pImpl->GetTOXType();
2192 if (pType && m_pImpl->m_pTOXMark)
2193 {
2194 switch(pEntry->nWID)
2195 {
2196 case WID_ALT_TEXT:
2197 aRet <<= m_pImpl->m_pTOXMark->GetAlternativeText();
2198 break;
2199 case WID_LEVEL:
2200 aRet <<= static_cast<sal_Int16>(
2201 m_pImpl->m_pTOXMark->GetLevel() - 1);
2202 break;
2203 case WID_TOC_BOOKMARK :
2204 aRet <<= m_pImpl->m_pTOXMark->GetBookmarkName();
2205 break;
2206 case WID_PRIMARY_KEY :
2207 aRet <<= m_pImpl->m_pTOXMark->GetPrimaryKey();
2208 break;
2209 case WID_SECONDARY_KEY:
2210 aRet <<= m_pImpl->m_pTOXMark->GetSecondaryKey();
2211 break;
2212 case WID_TEXT_READING:
2213 aRet <<= m_pImpl->m_pTOXMark->GetTextReading();
2214 break;
2215 case WID_PRIMARY_KEY_READING:
2216 aRet <<= m_pImpl->m_pTOXMark->GetPrimaryKeyReading();
2217 break;
2218 case WID_SECONDARY_KEY_READING:
2219 aRet <<= m_pImpl->m_pTOXMark->GetSecondaryKeyReading();
2220 break;
2221 case WID_USER_IDX_NAME :
2222 {
2223 OUString sTmp(pType->GetTypeName());
2224 lcl_ConvertTOUNameToProgrammaticName(sTmp);
2225 aRet <<= sTmp;
2226 }
2227 break;
2228 case WID_MAIN_ENTRY:
2229 {
2230 const bool bTemp = m_pImpl->m_pTOXMark->IsMainEntry();
2231 aRet <<= bTemp;
2232 }
2233 break;
2234 }
2235 }
2236 else if (m_pImpl->m_bIsDescriptor)
2237 {
2238 switch(pEntry->nWID)
2239 {
2240 case WID_ALT_TEXT:
2241 aRet <<= m_pImpl->m_sAltText;
2242 break;
2243 case WID_LEVEL:
2244 aRet <<= static_cast<sal_Int16>(m_pImpl->m_nLevel);
2245 break;
2246 case WID_TOC_BOOKMARK :
2247 aRet <<= m_pImpl->m_aBookmarkName;
2248 break;
2249 case WID_PRIMARY_KEY:
2250 aRet <<= m_pImpl->m_sPrimaryKey;
2251 break;
2252 case WID_SECONDARY_KEY:
2253 aRet <<= m_pImpl->m_sSecondaryKey;
2254 break;
2255 case WID_TEXT_READING:
2256 aRet <<= m_pImpl->m_sTextReading;
2257 break;
2258 case WID_PRIMARY_KEY_READING:
2259 aRet <<= m_pImpl->m_sPrimaryKeyReading;
2260 break;
2261 case WID_SECONDARY_KEY_READING:
2262 aRet <<= m_pImpl->m_sSecondaryKeyReading;
2263 break;
2264 case WID_USER_IDX_NAME :
2265 aRet <<= m_pImpl->m_sUserIndexName;
2266 break;
2267 case WID_MAIN_ENTRY:
2268 aRet <<= m_pImpl->m_bMainEntry;
2269 break;
2270 }
2271 }
2272 else
2273 {
2274 throw uno::RuntimeException();
2275 }
2276 return aRet;
2277 }
2278
2279 void SAL_CALL
2280 SwXDocumentIndexMark::addPropertyChangeListener(
2281 const OUString& /*rPropertyName*/,
2282 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
2283 {
2284 OSL_FAIL("SwXDocumentIndexMark::addPropertyChangeListener(): not implemented");
2285 }
2286
2287 void SAL_CALL
2288 SwXDocumentIndexMark::removePropertyChangeListener(
2289 const OUString& /*rPropertyName*/,
2290 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/)
2291 {
2292 OSL_FAIL("SwXDocumentIndexMark::removePropertyChangeListener(): not implemented");
2293 }
2294
2295 void SAL_CALL
2296 SwXDocumentIndexMark::addVetoableChangeListener(
2297 const OUString& /*rPropertyName*/,
2298 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
2299 {
2300 OSL_FAIL("SwXDocumentIndexMark::addVetoableChangeListener(): not implemented");
2301 }
2302
2303 void SAL_CALL
2304 SwXDocumentIndexMark::removeVetoableChangeListener(
2305 const OUString& /*rPropertyName*/,
2306 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/)
2307 {
2308 OSL_FAIL("SwXDocumentIndexMark::removeVetoableChangeListener(): not implemented");
2309 }
2310
2311 SwXDocumentIndexes::SwXDocumentIndexes(SwDoc *const _pDoc)
2312 : SwUnoCollection(_pDoc)
2313 {
2314 }
2315
2316 SwXDocumentIndexes::~SwXDocumentIndexes()
2317 {
2318 }
2319
2320 OUString SAL_CALL
2321 SwXDocumentIndexes::getImplementationName()
2322 {
2323 return u"SwXDocumentIndexes"_ustr;
2324 }
2325
2326 sal_Bool SAL_CALL SwXDocumentIndexes::supportsService(const OUString& rServiceName)
2327 {
2328 return cppu::supportsService(this, rServiceName);
2329 }
2330
2331 uno::Sequence< OUString > SAL_CALL
2332 SwXDocumentIndexes::getSupportedServiceNames()
2333 {
2334 return { u"com.sun.star.text.DocumentIndexes"_ustr };
2335 }
2336
2337 sal_Int32 SAL_CALL
2338 SwXDocumentIndexes::getCount()
2339 {
2340 SolarMutexGuard aGuard;
2341
2342 sal_uInt32 nRet = 0;
2343 const SwSectionFormats& rFormats = GetDoc().GetSections();
2344 for( size_t n = 0; n < rFormats.size(); ++n )
2345 {
2346 const SwSection* pSect = rFormats[ n ]->GetSection();
2347 if( SectionType::ToxContent == pSect->GetType() &&
2348 pSect->GetFormat()->GetSectionNode() )
2349 {
2350 ++nRet;
2351 }
2352 }
2353 return nRet;
2354 }
2355
2356 uno::Any SAL_CALL
2357 SwXDocumentIndexes::getByIndex(sal_Int32 nIndex)
2358 {
2359 SolarMutexGuard aGuard;
2360
2361 sal_Int32 nIdx = 0;
2362
2363 auto& rDoc = GetDoc();
2364 const SwSectionFormats& rFormats = rDoc.GetSections();
2365 for( size_t n = 0; n < rFormats.size(); ++n )
2366 {
2367 SwSection* pSect = rFormats[ n ]->GetSection();
2368 if( SectionType::ToxContent == pSect->GetType() &&
2369 pSect->GetFormat()->GetSectionNode() &&
2370 nIdx++ == nIndex )
2371 {
2372 const uno::Reference< text::XDocumentIndex > xTmp =
2373 SwXDocumentIndex::CreateXDocumentIndex(
2374 rDoc, static_cast<SwTOXBaseSection *>(pSect));
2375 uno::Any aRet;
2376 aRet <<= xTmp;
2377 return aRet;
2378 }
2379 }
2380
2381 throw lang::IndexOutOfBoundsException();
2382 }
2383
2384 uno::Any SAL_CALL
2385 SwXDocumentIndexes::getByName(const OUString& rName)
2386 {
2387 SolarMutexGuard aGuard;
2388
2389 auto& rDoc = GetDoc();
2390 const SwSectionFormats& rFormats = rDoc.GetSections();
2391 for( size_t n = 0; n < rFormats.size(); ++n )
2392 {
2393 SwSection* pSect = rFormats[ n ]->GetSection();
2394 if( SectionType::ToxContent == pSect->GetType() &&
2395 pSect->GetFormat()->GetSectionNode() &&
2396 (static_cast<SwTOXBaseSection const*>(pSect)->GetTOXName()
2397 == rName))
2398 {
2399 const uno::Reference< text::XDocumentIndex > xTmp =
2400 SwXDocumentIndex::CreateXDocumentIndex(
2401 rDoc, static_cast<SwTOXBaseSection *>(pSect));
2402 uno::Any aRet;
2403 aRet <<= xTmp;
2404 return aRet;
2405 }
2406 }
2407 throw container::NoSuchElementException();
2408 }
2409
2410 uno::Sequence< OUString > SAL_CALL
2411 SwXDocumentIndexes::getElementNames()
2412 {
2413 SolarMutexGuard aGuard;
2414
2415 const SwSectionFormats& rFormats = GetDoc().GetSections();
2416 sal_Int32 nCount = 0;
2417 for( size_t n = 0; n < rFormats.size(); ++n )
2418 {
2419 SwSection const*const pSect = rFormats[ n ]->GetSection();
2420 if( SectionType::ToxContent == pSect->GetType() &&
2421 pSect->GetFormat()->GetSectionNode() )
2422 {
2423 ++nCount;
2424 }
2425 }
2426
2427 uno::Sequence< OUString > aRet(nCount);
2428 OUString* pArray = aRet.getArray();
2429 sal_Int32 nCnt = 0;
2430 for( size_t n = 0; n < rFormats.size(); ++n )
2431 {
2432 SwSection const*const pSect = rFormats[ n ]->GetSection();
2433 if( SectionType::ToxContent == pSect->GetType() &&
2434 pSect->GetFormat()->GetSectionNode())
2435 {
2436 pArray[nCnt++] = static_cast<SwTOXBaseSection const*>(pSect)->GetTOXName();
2437 }
2438 }
2439 return aRet;
2440 }
2441
2442 sal_Bool SAL_CALL
2443 SwXDocumentIndexes::hasByName(const OUString& rName)
2444 {
2445 SolarMutexGuard aGuard;
2446
2447 const SwSectionFormats& rFormats = GetDoc().GetSections();
2448 for( size_t n = 0; n < rFormats.size(); ++n )
2449 {
2450 SwSection const*const pSect = rFormats[ n ]->GetSection();
2451 if( SectionType::ToxContent == pSect->GetType() &&
2452 pSect->GetFormat()->GetSectionNode())
2453 {
2454 if (static_cast<SwTOXBaseSection const*>(pSect)->GetTOXName()
2455 == rName)
2456 {
2457 return true;
2458 }
2459 }
2460 }
2461 return false;
2462 }
2463
2464 uno::Type SAL_CALL
2465 SwXDocumentIndexes::getElementType()
2466 {
2467 return cppu::UnoType<text::XDocumentIndex>::get();
2468 }
2469
2470 sal_Bool SAL_CALL
2471 SwXDocumentIndexes::hasElements()
2472 {
2473 return 0 != getCount();
2474 }
2475
2476 SwXDocumentIndex::StyleAccess_Impl::StyleAccess_Impl(
2477 SwXDocumentIndex& rParentIdx)
2478 : m_xParent(&rParentIdx)
2479 {
2480 }
2481
2482 SwXDocumentIndex::StyleAccess_Impl::~StyleAccess_Impl()
2483 {
2484 }
2485
2486 OUString SAL_CALL
2487 SwXDocumentIndex::StyleAccess_Impl::getImplementationName()
2488 {
2489 return u"SwXDocumentIndex::StyleAccess_Impl"_ustr;
2490 }
2491
2492 sal_Bool SAL_CALL
2493 SwXDocumentIndex::StyleAccess_Impl::supportsService(const OUString& rServiceName)
2494 {
2495 return cppu::supportsService(this, rServiceName);
2496 }
2497
2498 uno::Sequence< OUString > SAL_CALL
2499 SwXDocumentIndex::StyleAccess_Impl::getSupportedServiceNames()
2500 {
2501 return { u"com.sun.star.text.DocumentIndexParagraphStyles"_ustr };
2502 }
2503
2504 void SAL_CALL
2505 SwXDocumentIndex::StyleAccess_Impl::replaceByIndex(
2506 sal_Int32 nIndex, const uno::Any& rElement)
2507 {
2508 SolarMutexGuard aGuard;
2509
2510 if(nIndex < 0 || nIndex >= MAXLEVEL)
2511 {
2512 throw lang::IndexOutOfBoundsException();
2513 }
2514
2515 SwTOXBase & rTOXBase( m_xParent->m_pImpl->GetTOXSectionOrThrow() );
2516
2517 uno::Sequence<OUString> aSeq;
2518 if(!(rElement >>= aSeq))
2519 {
2520 throw lang::IllegalArgumentException();
2521 }
2522
2523 const sal_Int32 nStyles = aSeq.getLength();
2524 const OUString* pStyles = aSeq.getConstArray();
2525 OUStringBuffer sSetStyles;
2526 OUString aString;
2527 for(sal_Int32 i = 0; i < nStyles; i++)
2528 {
2529 if(i)
2530 {
2531 sSetStyles.append(TOX_STYLE_DELIMITER);
2532 }
2533 SwStyleNameMapper::FillUIName(ProgName(pStyles[i]), aString,
2534 SwGetPoolIdFromName::TxtColl);
2535 sSetStyles.append(aString);
2536 }
2537 rTOXBase.SetStyleNames(sSetStyles.makeStringAndClear(), o3tl::narrowing<sal_uInt16>(nIndex));
2538 }
2539
2540 sal_Int32 SAL_CALL
2541 SwXDocumentIndex::StyleAccess_Impl::getCount()
2542 {
2543 return MAXLEVEL;
2544 }
2545
2546 uno::Any SAL_CALL
2547 SwXDocumentIndex::StyleAccess_Impl::getByIndex(sal_Int32 nIndex)
2548 {
2549 SolarMutexGuard aGuard;
2550
2551 if(nIndex < 0 || nIndex >= MAXLEVEL)
2552 {
2553 throw lang::IndexOutOfBoundsException();
2554 }
2555
2556 SwTOXBase & rTOXBase( m_xParent->m_pImpl->GetTOXSectionOrThrow() );
2557
2558 const OUString& rStyles =
2559 rTOXBase.GetStyleNames(o3tl::narrowing<sal_uInt16>(nIndex));
2560 const sal_Int32 nStyles = comphelper::string::getTokenCount(rStyles, TOX_STYLE_DELIMITER);
2561 uno::Sequence<OUString> aStyles(nStyles);
2562 OUString* pStyles = aStyles.getArray();
2563 ProgName aString;
2564 sal_Int32 nPos = 0;
2565 for(sal_Int32 i = 0; i < nStyles; ++i)
2566 {
2567 SwStyleNameMapper::FillProgName(
2568 rStyles.getToken(0, TOX_STYLE_DELIMITER, nPos),
2569 aString,
2570 SwGetPoolIdFromName::TxtColl);
2571 pStyles[i] = aString.toString();
2572 }
2573 uno::Any aRet(&aStyles, cppu::UnoType<uno::Sequence<OUString>>::get());
2574 return aRet;
2575 }
2576
2577 uno::Type SAL_CALL
2578 SwXDocumentIndex::StyleAccess_Impl::getElementType()
2579 {
2580 return cppu::UnoType<uno::Sequence<OUString>>::get();
2581 }
2582
2583 sal_Bool SAL_CALL
2584 SwXDocumentIndex::StyleAccess_Impl::hasElements()
2585 {
2586 return true;
2587 }
2588
2589 SwXDocumentIndex::TokenAccess_Impl::TokenAccess_Impl(
2590 SwXDocumentIndex& rParentIdx)
2591 : m_xParent(&rParentIdx)
2592 {
2593 }
2594
2595 SwXDocumentIndex::TokenAccess_Impl::~TokenAccess_Impl()
2596 {
2597 }
2598
2599 OUString SAL_CALL
2600 SwXDocumentIndex::TokenAccess_Impl::getImplementationName()
2601 {
2602 return u"SwXDocumentIndex::TokenAccess_Impl"_ustr;
2603 }
2604
2605 sal_Bool SAL_CALL SwXDocumentIndex::TokenAccess_Impl::supportsService(
2606 const OUString& rServiceName)
2607 {
2608 return cppu::supportsService(this, rServiceName);
2609 }
2610
2611 uno::Sequence< OUString > SAL_CALL
2612 SwXDocumentIndex::TokenAccess_Impl::getSupportedServiceNames()
2613 {
2614 return { u"com.sun.star.text.DocumentIndexLevelFormat"_ustr };
2615 }
2616
2617 namespace {
2618
2619 struct TokenType_ {
2620 const char *pName;
2621 enum FormTokenType eTokenType;
2622 };
2623
2624 }
2625
2626 const struct TokenType_ g_TokenTypes[] =
2627 {
2628 { "TokenEntryNumber", TOKEN_ENTRY_NO },
2629 { "TokenEntryText", TOKEN_ENTRY_TEXT },
2630 { "TokenTabStop", TOKEN_TAB_STOP },
2631 { "TokenText", TOKEN_TEXT },
2632 { "TokenPageNumber", TOKEN_PAGE_NUMS },
2633 { "TokenChapterInfo", TOKEN_CHAPTER_INFO },
2634 { "TokenHyperlinkStart", TOKEN_LINK_START },
2635 { "TokenHyperlinkEnd", TOKEN_LINK_END },
2636 { "TokenBibliographyDataField", TOKEN_AUTHORITY },
2637 { nullptr, static_cast<enum FormTokenType>(0) }
2638 };
2639
2640 void SAL_CALL
2641 SwXDocumentIndex::TokenAccess_Impl::replaceByIndex(
2642 sal_Int32 nIndex, const uno::Any& rElement)
2643 {
2644 SolarMutexGuard aGuard;
2645
2646 SwTOXBase & rTOXBase( m_xParent->m_pImpl->GetTOXSectionOrThrow() );
2647
2648 if ((nIndex < 0) || (nIndex > rTOXBase.GetTOXForm().GetFormMax()))
2649 {
2650 throw lang::IndexOutOfBoundsException();
2651 }
2652
2653 uno::Sequence<beans::PropertyValues> aSeq;
2654 if(!(rElement >>= aSeq))
2655 {
2656 throw lang::IllegalArgumentException();
2657 }
2658
2659 OUStringBuffer sPattern;
2660 for (const beans::PropertyValues& rToken : aSeq)
2661 {
2662 const beans::PropertyValue* pProperties = rToken.getConstArray();
2663 const sal_Int32 nProperties = rToken.getLength();
2664 //create an invalid token
2665 SwFormToken aToken(TOKEN_END);
2666 for(sal_Int32 j = 0; j < nProperties; j++)
2667 {
2668 if ( pProperties[j].Name == "TokenType" )
2669 {
2670 const OUString sTokenType =
2671 lcl_AnyToType<OUString>(pProperties[j].Value);
2672 for (TokenType_ const* pTokenType = g_TokenTypes;
2673 pTokenType->pName; ++pTokenType)
2674 {
2675 if (sTokenType.equalsAscii(pTokenType->pName))
2676 {
2677 aToken.eTokenType = pTokenType->eTokenType;
2678 break;
2679 }
2680 }
2681 }
2682 else if ( pProperties[j].Name == "CharacterStyleName" )
2683 {
2684 OUString sCharStyleName;
2685 SwStyleNameMapper::FillUIName(
2686 ProgName(lcl_AnyToType<OUString>(pProperties[j].Value)),
2687 sCharStyleName,
2688 SwGetPoolIdFromName::ChrFmt);
2689 aToken.sCharStyleName = sCharStyleName;
2690 aToken.nPoolId = SwStyleNameMapper::GetPoolIdFromUIName (
2691 sCharStyleName, SwGetPoolIdFromName::ChrFmt );
2692 }
2693 else if ( pProperties[j].Name == "TabStopRightAligned" )
2694 {
2695 const bool bRight = lcl_AnyToType<bool>(pProperties[j].Value);
2696 aToken.eTabAlign = bRight ?
2697 SvxTabAdjust::End : SvxTabAdjust::Left;
2698 }
2699 else if ( pProperties[j].Name == "TabStopPosition" )
2700 {
2701 sal_Int32 nPosition = 0;
2702 if (!(pProperties[j].Value >>= nPosition))
2703 {
2704 throw lang::IllegalArgumentException();
2705 }
2706 nPosition = o3tl::toTwips(nPosition, o3tl::Length::mm100);
2707 if(nPosition < 0)
2708 {
2709 throw lang::IllegalArgumentException();
2710 }
2711 aToken.nTabStopPosition = nPosition;
2712 }
2713 else if ( pProperties[j].Name == "TabStopFillCharacter" )
2714 {
2715 const OUString sFillChar =
2716 lcl_AnyToType<OUString>(pProperties[j].Value);
2717 if (sFillChar.getLength() > 1)
2718 {
2719 throw lang::IllegalArgumentException();
2720 }
2721 aToken.cTabFillChar =
2722 sFillChar.isEmpty() ? ' ' : sFillChar[0];
2723 }
2724 else if ( pProperties[j].Name == "Text" )
2725 {
2726 aToken.sText = lcl_AnyToType<OUString>(pProperties[j].Value);
2727 }
2728 else if ( pProperties[j].Name == "ChapterFormat" )
2729 {
2730 sal_Int16 nFormat = lcl_AnyToType<sal_Int16>(pProperties[j].Value);
2731 switch(nFormat)
2732 {
2733 case text::ChapterFormat::NUMBER:
2734 nFormat = CF_NUMBER;
2735 break;
2736 case text::ChapterFormat::NAME:
2737 nFormat = CF_TITLE;
2738 break;
2739 case text::ChapterFormat::NAME_NUMBER:
2740 nFormat = CF_NUM_TITLE;
2741 break;
2742 case text::ChapterFormat::NO_PREFIX_SUFFIX:
2743 nFormat = CF_NUMBER_NOPREPST;
2744 break;
2745 case text::ChapterFormat::DIGIT:
2746 nFormat = CF_NUM_NOPREPST_TITLE;
2747 break;
2748 default:
2749 throw lang::IllegalArgumentException();
2750 }
2751 aToken.nChapterFormat = nFormat;
2752 }
2753 // #i53420#
2754 else if ( pProperties[j].Name == "ChapterLevel" )
2755 {
2756 const sal_Int16 nLevel = lcl_AnyToType<sal_Int16>(pProperties[j].Value);
2757 if( nLevel < 1 || nLevel > MAXLEVEL )
2758 {
2759 throw lang::IllegalArgumentException();
2760 }
2761 aToken.nOutlineLevel = nLevel;
2762 }
2763 else if ( pProperties[j].Name == "BibliographyDataField" )
2764 {
2765 sal_Int16 nType = 0;
2766 pProperties[j].Value >>= nType;
2767 if(nType < 0 || nType > text::BibliographyDataField::LOCAL_URL)
2768 {
2769 throw lang::IllegalArgumentException(u"BibliographyDataField - wrong value"_ustr, nullptr, j);
2770 }
2771 aToken.nAuthorityField = nType;
2772 }
2773 // #i21237#
2774 else if ( pProperties[j].Name == "WithTab" )
2775 {
2776 aToken.bWithTab = lcl_AnyToType<bool>(pProperties[j].Value);
2777 }
2778
2779 }
2780 //exception if wrong TokenType
2781 if(TOKEN_END <= aToken.eTokenType )
2782 {
2783 throw lang::IllegalArgumentException();
2784 }
2785 // set TokenType from TOKEN_ENTRY_TEXT to TOKEN_ENTRY if it is
2786 // not a content index
2787 if(TOKEN_ENTRY_TEXT == aToken.eTokenType &&
2788 (TOX_CONTENT != rTOXBase.GetType()))
2789 {
2790 aToken.eTokenType = TOKEN_ENTRY;
2791 }
2792 // #i53420#
2793 // check for chapter format allowed values if it was TOKEN_ENTRY_NO type
2794 // only allowed value are CF_NUMBER and CF_NUM_NOPREPST_TITLE
2795 // reading from file
2796 if( TOKEN_ENTRY_NO == aToken.eTokenType )
2797 {
2798 switch(aToken.nChapterFormat)
2799 {
2800 case CF_NUMBER:
2801 case CF_NUM_NOPREPST_TITLE:
2802 break;
2803 default:
2804 throw lang::IllegalArgumentException();
2805 }
2806 }
2807
2808 if (rTOXBase.GetType() == TOX_CONTENT)
2809 {
2810 if (aToken.eTokenType == TOKEN_LINK_START && aToken.sCharStyleName.isEmpty())
2811 {
2812 aToken.sCharStyleName = SwResId(STR_POOLCHR_TOXJUMP);
2813 }
2814 }
2815
2816 sPattern.append(aToken.GetString());
2817 }
2818 SwForm aForm(rTOXBase.GetTOXForm());
2819 aForm.SetPattern(o3tl::narrowing<sal_uInt16>(nIndex), sPattern.makeStringAndClear());
2820 rTOXBase.SetTOXForm(aForm);
2821 }
2822
2823 sal_Int32 SAL_CALL
2824 SwXDocumentIndex::TokenAccess_Impl::getCount()
2825 {
2826 SolarMutexGuard aGuard;
2827
2828 const sal_Int32 nRet = m_xParent->m_pImpl->GetFormMax();
2829 return nRet;
2830 }
2831
2832 uno::Any SAL_CALL
2833 SwXDocumentIndex::TokenAccess_Impl::getByIndex(sal_Int32 nIndex)
2834 {
2835 SolarMutexGuard aGuard;
2836
2837 SwTOXBase & rTOXBase( m_xParent->m_pImpl->GetTOXSectionOrThrow() );
2838
2839 if ((nIndex < 0) || (nIndex > rTOXBase.GetTOXForm().GetFormMax()))
2840 {
2841 throw lang::IndexOutOfBoundsException();
2842 }
2843
2844 // #i21237#
2845 SwFormTokens aPattern = rTOXBase.GetTOXForm().
2846 GetPattern(o3tl::narrowing<sal_uInt16>(nIndex));
2847
2848 sal_Int32 nTokenCount = 0;
2849 uno::Sequence< beans::PropertyValues > aRetSeq;
2850 ProgName aProgCharStyle;
2851 for(const SwFormToken& aToken : aPattern) // #i21237#
2852 {
2853 nTokenCount++;
2854 aRetSeq.realloc(nTokenCount);
2855 beans::PropertyValues* pTokenProps = aRetSeq.getArray();
2856
2857 uno::Sequence< beans::PropertyValue >& rCurTokenSeq =
2858 pTokenProps[nTokenCount-1];
2859 SwStyleNameMapper::FillProgName(
2860 aToken.sCharStyleName,
2861 aProgCharStyle,
2862 SwGetPoolIdFromName::ChrFmt);
2863 switch(aToken.eTokenType)
2864 {
2865 case TOKEN_ENTRY_NO:
2866 {
2867 // #i53420#
2868 // writing to file (from doc to properties)
2869 sal_Int32 nElements = 2;
2870 sal_Int32 nCurrentElement = 0;
2871
2872 // check for default value
2873 if (aToken.nChapterFormat != CF_NUMBER)
2874 {
2875 nElements++;//we need the element
2876 }
2877 if( aToken.nOutlineLevel != MAXLEVEL )
2878 {
2879 nElements++;
2880 }
2881
2882 rCurTokenSeq.realloc( nElements );
2883
2884 beans::PropertyValue* pArr = rCurTokenSeq.getArray();
2885
2886 pArr[nCurrentElement].Name = "TokenType";
2887 pArr[nCurrentElement++].Value <<=
2888 u"TokenEntryNumber"_ustr;
2889
2890 pArr[nCurrentElement].Name = "CharacterStyleName";
2891 pArr[nCurrentElement++].Value <<= aProgCharStyle.toString();
2892 if( aToken.nChapterFormat != CF_NUMBER )
2893 {
2894 pArr[nCurrentElement].Name = "ChapterFormat";
2895 sal_Int16 nVal;
2896 // the allowed values for chapter format, when used as entry number,
2897 // are CF_NUMBER and CF_NUM_NOPREPST_TITLE only, all else forced to
2898 //CF_NUMBER
2899 switch(aToken.nChapterFormat)
2900 {
2901 default:
2902 case CF_NUMBER:
2903 nVal = text::ChapterFormat::NUMBER;
2904 break;
2905 case CF_NUM_NOPREPST_TITLE:
2906 nVal = text::ChapterFormat::DIGIT;
2907 break;
2908 }
2909 pArr[nCurrentElement++].Value <<= nVal;
2910 }
2911
2912 // only a ChapterLevel != MAXLEVEL is registered
2913 if (aToken.nOutlineLevel != MAXLEVEL)
2914 {
2915 pArr[nCurrentElement].Name = "ChapterLevel";
2916 pArr[nCurrentElement].Value <<= aToken.nOutlineLevel;
2917 }
2918 }
2919 break;
2920 case TOKEN_ENTRY: // no difference between Entry and Entry Text
2921 case TOKEN_ENTRY_TEXT:
2922 {
2923 rCurTokenSeq.realloc( 2 );
2924 beans::PropertyValue* pArr = rCurTokenSeq.getArray();
2925
2926 pArr[0].Name = "TokenType";
2927 pArr[0].Value <<= u"TokenEntryText"_ustr;
2928
2929 pArr[1].Name = "CharacterStyleName";
2930 pArr[1].Value <<= aProgCharStyle.toString();
2931 }
2932 break;
2933 case TOKEN_TAB_STOP:
2934 {
2935 rCurTokenSeq.realloc(5); // #i21237#
2936 beans::PropertyValue* pArr = rCurTokenSeq.getArray();
2937
2938 pArr[0].Name = "TokenType";
2939 pArr[0].Value <<= u"TokenTabStop"_ustr;
2940
2941 if(SvxTabAdjust::End == aToken.eTabAlign)
2942 {
2943 pArr[1].Name = "TabStopRightAligned";
2944 pArr[1].Value <<= true;
2945 }
2946 else
2947 {
2948 pArr[1].Name = "TabStopPosition";
2949 sal_Int32 nPos = convertTwipToMm100(aToken.nTabStopPosition);
2950 if(nPos < 0)
2951 nPos = 0;
2952 pArr[1].Value <<= nPos;
2953 }
2954 pArr[2].Name = "TabStopFillCharacter";
2955 pArr[2].Value <<= OUString(aToken.cTabFillChar);
2956 pArr[3].Name = "CharacterStyleName";
2957 pArr[3].Value <<= aProgCharStyle.toString();
2958 // #i21237#
2959 pArr[4].Name = "WithTab";
2960 pArr[4].Value <<= aToken.bWithTab;
2961 }
2962 break;
2963 case TOKEN_TEXT:
2964 {
2965 rCurTokenSeq.realloc( 3 );
2966 beans::PropertyValue* pArr = rCurTokenSeq.getArray();
2967
2968 pArr[0].Name = "TokenType";
2969 pArr[0].Value <<= u"TokenText"_ustr;
2970
2971 pArr[1].Name = "CharacterStyleName";
2972 pArr[1].Value <<= aProgCharStyle.toString();
2973
2974 pArr[2].Name = "Text";
2975 pArr[2].Value <<= aToken.sText;
2976 }
2977 break;
2978 case TOKEN_PAGE_NUMS:
2979 {
2980 rCurTokenSeq.realloc( 2 );
2981 beans::PropertyValue* pArr = rCurTokenSeq.getArray();
2982
2983 pArr[0].Name = "TokenType";
2984 pArr[0].Value <<= u"TokenPageNumber"_ustr;
2985
2986 pArr[1].Name = "CharacterStyleName";
2987 pArr[1].Value <<= aProgCharStyle.toString();
2988 }
2989 break;
2990 case TOKEN_CHAPTER_INFO:
2991 {
2992 rCurTokenSeq.realloc( 4 );
2993 beans::PropertyValue* pArr = rCurTokenSeq.getArray();
2994
2995 pArr[0].Name = "TokenType";
2996 pArr[0].Value <<= u"TokenChapterInfo"_ustr;
2997
2998 pArr[1].Name = "CharacterStyleName";
2999 pArr[1].Value <<= aProgCharStyle.toString();
3000
3001 pArr[2].Name = "ChapterFormat";
3002 sal_Int16 nVal = text::ChapterFormat::NUMBER;
3003 switch(aToken.nChapterFormat)
3004 {
3005 case CF_NUMBER:
3006 nVal = text::ChapterFormat::NUMBER;
3007 break;
3008 case CF_TITLE:
3009 nVal = text::ChapterFormat::NAME;
3010 break;
3011 case CF_NUM_TITLE:
3012 nVal = text::ChapterFormat::NAME_NUMBER;
3013 break;
3014 case CF_NUMBER_NOPREPST:
3015 nVal = text::ChapterFormat::NO_PREFIX_SUFFIX;
3016 break;
3017 case CF_NUM_NOPREPST_TITLE:
3018 nVal = text::ChapterFormat::DIGIT;
3019 break;
3020 }
3021 pArr[2].Value <<= nVal;
3022 // #i53420#
3023 pArr[3].Name = "ChapterLevel";
3024 pArr[3].Value <<= aToken.nOutlineLevel;
3025 }
3026 break;
3027 case TOKEN_LINK_START:
3028 {
3029 rCurTokenSeq.realloc( 2 );
3030 beans::PropertyValue* pArr = rCurTokenSeq.getArray();
3031
3032 pArr[0].Name = "TokenType";
3033 pArr[0].Value <<=
3034 u"TokenHyperlinkStart"_ustr;
3035 pArr[1].Name = "CharacterStyleName";
3036 pArr[1].Value <<= aProgCharStyle.toString();
3037 }
3038 break;
3039 case TOKEN_LINK_END:
3040 {
3041 rCurTokenSeq.realloc( 1 );
3042 beans::PropertyValue* pArr = rCurTokenSeq.getArray();
3043
3044 pArr[0].Name = "TokenType";
3045 pArr[0].Value <<=
3046 u"TokenHyperlinkEnd"_ustr;
3047 }
3048 break;
3049 case TOKEN_AUTHORITY:
3050 {
3051 rCurTokenSeq.realloc( 3 );
3052 beans::PropertyValue* pArr = rCurTokenSeq.getArray();
3053
3054 pArr[0].Name = "TokenType";
3055 pArr[0].Value <<=
3056 u"TokenBibliographyDataField"_ustr;
3057
3058 pArr[1].Name = "CharacterStyleName";
3059 pArr[1].Value <<= aProgCharStyle.toString();
3060
3061 pArr[2].Name = "BibliographyDataField";
3062 pArr[2].Value <<= sal_Int16(aToken.nAuthorityField);
3063 }
3064 break;
3065
3066 default:
3067 ;
3068 }
3069 }
3070
3071 uno::Any aRet;
3072 aRet <<= aRetSeq;
3073 return aRet;
3074 }
3075
3076 uno::Type SAL_CALL
3077 SwXDocumentIndex::TokenAccess_Impl::getElementType()
3078 {
3079 return cppu::UnoType<uno::Sequence< beans::PropertyValues >>::get();
3080 }
3081
3082 sal_Bool SAL_CALL
3083 SwXDocumentIndex::TokenAccess_Impl::hasElements()
3084 {
3085 return true;
3086 }
3087
3088 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE