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