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