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