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