LCOV - code coverage report
Current view: top level - sw/source/core/unocore - unoidx.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 1460 0.0 %
Date: 2014-04-14 Functions: 0 125 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10