LCOV - code coverage report
Current view: top level - sw/source/core/uibase/uno - unoatxt.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 550 0.0 %
Date: 2014-04-14 Functions: 0 78 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 <com/sun/star/beans/PropertyAttribute.hpp>
      21             : #include <osl/mutex.hxx>
      22             : #include <osl/diagnose.h>
      23             : #include <vcl/svapp.hxx>
      24             : #include <svtools/unoevent.hxx>
      25             : #include <svl/urihelper.hxx>
      26             : #include <sfx2/event.hxx>
      27             : #include <swtypes.hxx>
      28             : #include <glosdoc.hxx>
      29             : #include <shellio.hxx>
      30             : #include <initui.hxx>
      31             : #include <gloslst.hxx>
      32             : #include <unoatxt.hxx>
      33             : #include <unomap.hxx>
      34             : #include <unomid.h>
      35             : #include <unotextbodyhf.hxx>
      36             : #include <unotextrange.hxx>
      37             : #include <TextCursorHelper.hxx>
      38             : #include <swevent.hxx>
      39             : #include <doc.hxx>
      40             : #include <unocrsr.hxx>
      41             : #include <IMark.hxx>
      42             : #include <unoprnms.hxx>
      43             : #include <docsh.hxx>
      44             : #include <swmodule.hxx>
      45             : #include <svl/smplhint.hxx>
      46             : #include <svl/macitem.hxx>
      47             : #include <editeng/acorrcfg.hxx>
      48             : #include <comphelper/servicehelper.hxx>
      49             : #include <comphelper/string.hxx>
      50             : #include <cppuhelper/supportsservice.hxx>
      51             : 
      52             : #include <boost/scoped_ptr.hpp>
      53             : 
      54             : using namespace ::com::sun::star;
      55             : 
      56           0 : uno::Reference< uno::XInterface > SAL_CALL SwXAutoTextContainer_createInstance(
      57             :     const uno::Reference< lang::XMultiServiceFactory > & ) throw( uno::Exception )
      58             : {
      59             :     //the module may not be loaded
      60           0 :     SolarMutexGuard aGuard;
      61           0 :     SwGlobals::ensure();
      62           0 :     static uno::Reference< uno::XInterface > xAText = (cppu::OWeakObject*)new SwXAutoTextContainer();
      63           0 :     return xAText;
      64             : }
      65             : 
      66           0 : uno::Sequence< OUString > SAL_CALL SwXAutoTextContainer_getSupportedServiceNames() throw()
      67             : {
      68           0 :     OUString sService("com.sun.star.text.AutoTextContainer");
      69           0 :     const uno::Sequence< OUString > aSeq( &sService, 1 );
      70           0 :     return aSeq;
      71             : }
      72             : 
      73           0 : OUString SAL_CALL SwXAutoTextContainer_getImplementationName() throw()
      74             : {
      75           0 :     return OUString("SwXAutoTextContainer" );
      76             : }
      77             : 
      78           0 : SwXAutoTextContainer::SwXAutoTextContainer()
      79             : {
      80           0 :     pGlossaries = ::GetGlossaries();
      81             : 
      82           0 : }
      83             : 
      84           0 : SwXAutoTextContainer::~SwXAutoTextContainer()
      85             : {
      86             : 
      87           0 : }
      88             : 
      89           0 : sal_Int32 SwXAutoTextContainer::getCount(void) throw( uno::RuntimeException, std::exception )
      90             : {
      91           0 :     return pGlossaries->GetGroupCnt();
      92             : }
      93             : 
      94           0 : uno::Any SwXAutoTextContainer::getByIndex(sal_Int32 nIndex)
      95             :     throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
      96             : {
      97           0 :     SolarMutexGuard aGuard;
      98           0 :     uno::Any aRet;
      99           0 :     sal_uInt16 nCount = pGlossaries->GetGroupCnt();
     100           0 :     if ( 0 <= nIndex && nIndex < nCount )
     101           0 :         aRet = getByName(pGlossaries->GetGroupName( static_cast< sal_uInt16 >(nIndex) ));
     102             :     else
     103           0 :         throw lang::IndexOutOfBoundsException();
     104           0 :     return aRet;
     105             : }
     106             : 
     107           0 : uno::Type SwXAutoTextContainer::getElementType(void) throw( uno::RuntimeException, std::exception )
     108             : {
     109           0 :     return ::getCppuType((const uno::Reference<text::XAutoTextGroup>*)0);
     110             : 
     111             : }
     112             : 
     113           0 : sal_Bool SwXAutoTextContainer::hasElements(void) throw( uno::RuntimeException, std::exception )
     114             : {
     115             :     // At least standard should always exists!
     116           0 :     return sal_True;
     117             : }
     118             : 
     119           0 : uno::Any SwXAutoTextContainer::getByName(const OUString& GroupName)
     120             :     throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
     121             : {
     122           0 :     SolarMutexGuard aGuard;
     123             : 
     124           0 :     uno::Reference< text::XAutoTextGroup > xGroup;
     125           0 :     if ( pGlossaries && hasByName( GroupName ) )    // group name already known?
     126             :         // sal_True = create group if not already available
     127           0 :         xGroup = pGlossaries->GetAutoTextGroup( GroupName, true );
     128             : 
     129           0 :     if ( !xGroup.is() )
     130           0 :         throw container::NoSuchElementException();
     131             : 
     132           0 :     return makeAny( xGroup );
     133             : }
     134             : 
     135           0 : uno::Sequence< OUString > SwXAutoTextContainer::getElementNames(void) throw( uno::RuntimeException, std::exception )
     136             : {
     137           0 :     SolarMutexGuard aGuard;
     138           0 :     sal_uInt16 nCount = pGlossaries->GetGroupCnt();
     139             : 
     140           0 :     uno::Sequence< OUString > aGroupNames(nCount);
     141           0 :     OUString *pArr = aGroupNames.getArray();
     142             : 
     143           0 :     for ( sal_uInt16 i = 0; i < nCount; i++ )
     144             :     {
     145             :         // The names will be passed without a path extension.
     146           0 :         OUString sGroupName(pGlossaries->GetGroupName(i));
     147           0 :         pArr[i] = sGroupName.getToken(0, GLOS_DELIM);
     148           0 :     }
     149           0 :     return aGroupNames;
     150             : }
     151             : // Finds group names with or without path index.
     152           0 : sal_Bool SwXAutoTextContainer::hasByName(const OUString& Name)
     153             :     throw( uno::RuntimeException, std::exception )
     154             : {
     155           0 :     SolarMutexGuard aGuard;
     156           0 :     OUString sGroupName( pGlossaries->GetCompleteGroupName( Name ) );
     157           0 :     if(!sGroupName.isEmpty())
     158           0 :         return sal_True;
     159           0 :     return sal_False;
     160             : }
     161             : 
     162           0 : uno::Reference< text::XAutoTextGroup >  SwXAutoTextContainer::insertNewByName(
     163             :     const OUString& aGroupName)
     164             :     throw( lang::IllegalArgumentException, container::ElementExistException, uno::RuntimeException, std::exception )
     165             : {
     166           0 :     SolarMutexGuard aGuard;
     167           0 :     if(hasByName(aGroupName))
     168           0 :         throw container::ElementExistException();
     169             :     //check for non-ASCII characters
     170           0 :     if(aGroupName.isEmpty())
     171             :     {
     172           0 :         lang::IllegalArgumentException aIllegal;
     173           0 :         aIllegal.Message = "group name must not be empty";
     174           0 :         throw aIllegal;
     175             :     }
     176           0 :     for(sal_Int32 nPos = 0; nPos < aGroupName.getLength(); nPos++)
     177             :     {
     178           0 :         sal_Unicode cChar = aGroupName[nPos];
     179           0 :         if (comphelper::string::isalnumAscii(cChar) ||
     180           0 :             (cChar == '_') ||
     181           0 :             (cChar == 0x20) ||
     182             :             (cChar == GLOS_DELIM) )
     183             :         {
     184           0 :             continue;
     185             :         }
     186           0 :         lang::IllegalArgumentException aIllegal;
     187           0 :         aIllegal.Message = "group name must contain a-z, A-z, '_', ' ' only";
     188           0 :         throw aIllegal;
     189           0 :     }
     190           0 :     OUString sGroup(aGroupName);
     191           0 :     if (sGroup.indexOf(GLOS_DELIM)<0)
     192             :     {
     193           0 :         sGroup += OUString(GLOS_DELIM) + "0";
     194             :     }
     195           0 :     pGlossaries->NewGroupDoc(sGroup, sGroup.getToken(0, GLOS_DELIM));
     196             : 
     197           0 :     uno::Reference< text::XAutoTextGroup > xGroup = pGlossaries->GetAutoTextGroup( sGroup, true );
     198             :     OSL_ENSURE( xGroup.is(), "SwXAutoTextContainer::insertNewByName: no UNO object created? How this?" );
     199             :         // We just inserted the group into the glossaries, so why doesn't it exist?
     200             : 
     201           0 :     return xGroup;
     202             : }
     203             : 
     204           0 : void SwXAutoTextContainer::removeByName(const OUString& aGroupName)
     205             :     throw( container::NoSuchElementException, uno::RuntimeException, std::exception )
     206             : {
     207           0 :     SolarMutexGuard aGuard;
     208             :     // At first find the name with path extension
     209           0 :     OUString sGroupName = pGlossaries->GetCompleteGroupName( aGroupName );
     210           0 :     if(sGroupName.isEmpty())
     211           0 :         throw container::NoSuchElementException();
     212           0 :     pGlossaries->DelGroupDoc(sGroupName);
     213           0 : }
     214             : 
     215           0 : OUString SwXAutoTextContainer::getImplementationName(void) throw( uno::RuntimeException, std::exception )
     216             : {
     217           0 :     return SwXAutoTextContainer_getImplementationName();
     218             : }
     219             : 
     220           0 : sal_Bool SwXAutoTextContainer::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
     221             : {
     222           0 :     return cppu::supportsService(this, rServiceName);
     223             : }
     224             : 
     225           0 : uno::Sequence< OUString > SwXAutoTextContainer::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
     226             : {
     227           0 :     return SwXAutoTextContainer_getSupportedServiceNames();
     228             : }
     229             : 
     230             : namespace
     231             : {
     232             :     class theSwXAutoTextGroupUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSwXAutoTextGroupUnoTunnelId > {};
     233             : }
     234             : 
     235           0 : const uno::Sequence< sal_Int8 > & SwXAutoTextGroup::getUnoTunnelId()
     236             : {
     237           0 :     return theSwXAutoTextGroupUnoTunnelId::get().getSeq();
     238             : }
     239             : 
     240           0 : sal_Int64 SAL_CALL SwXAutoTextGroup::getSomething( const uno::Sequence< sal_Int8 >& rId )
     241             :     throw(uno::RuntimeException, std::exception)
     242             : {
     243           0 :     if( rId.getLength() == 16
     244           0 :         && 0 == memcmp( getUnoTunnelId().getConstArray(),
     245           0 :                                         rId.getConstArray(), 16 ) )
     246             :     {
     247           0 :             return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >( this ));
     248             :     }
     249           0 :     return 0;
     250             : }
     251             : 
     252           0 : SwXAutoTextGroup::SwXAutoTextGroup(const OUString& rName,
     253             :             SwGlossaries*   pGlos) :
     254           0 :     pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_AUTO_TEXT_GROUP)),
     255             :     pGlossaries(pGlos),
     256             :     sName(rName),
     257           0 :     m_sGroupName(rName)
     258             : {
     259             :     OSL_ENSURE( -1 != rName.indexOf( GLOS_DELIM ),
     260             :         "SwXAutoTextGroup::SwXAutoTextGroup: to be constructed with a complete name only!" );
     261           0 : }
     262             : 
     263           0 : SwXAutoTextGroup::~SwXAutoTextGroup()
     264             : {
     265           0 : }
     266             : 
     267           0 : uno::Sequence< OUString > SwXAutoTextGroup::getTitles(void) throw( uno::RuntimeException, std::exception )
     268             : {
     269           0 :     SolarMutexGuard aGuard;
     270           0 :     sal_uInt16 nCount = 0;
     271           0 :     SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0;
     272           0 :     if(pGlosGroup && !pGlosGroup->GetError())
     273           0 :         nCount = pGlosGroup->GetCount();
     274             :     else
     275           0 :         throw uno::RuntimeException();
     276             : 
     277           0 :     uno::Sequence< OUString > aEntryTitles(nCount);
     278           0 :     OUString *pArr = aEntryTitles.getArray();
     279             : 
     280           0 :     for ( sal_uInt16 i = 0; i < nCount; i++ )
     281           0 :         pArr[i] = pGlosGroup->GetLongName(i);
     282           0 :     delete pGlosGroup;
     283           0 :     return aEntryTitles;
     284             : }
     285             : 
     286           0 : void SwXAutoTextGroup::renameByName(const OUString& aElementName,
     287             :     const OUString& aNewElementName, const OUString& aNewElementTitle)
     288             :     throw( lang::IllegalArgumentException, container::ElementExistException, io::IOException,
     289             :                                                      uno::RuntimeException, std::exception)
     290             : {
     291           0 :     SolarMutexGuard aGuard;
     292             :     // throw exception only if the programmatic name is to be changed into an existing name
     293           0 :     if(aNewElementName != aElementName && hasByName(aNewElementName))
     294           0 :         throw container::ElementExistException();
     295           0 :     SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0;
     296           0 :     if(pGlosGroup && !pGlosGroup->GetError())
     297             :     {
     298           0 :         sal_uInt16 nIdx = pGlosGroup->GetIndex( aElementName);
     299           0 :         if(USHRT_MAX == nIdx)
     300           0 :             throw lang::IllegalArgumentException();
     301           0 :         OUString aNewShort(aNewElementName);
     302           0 :         OUString aNewName(aNewElementTitle);
     303           0 :         sal_uInt16 nOldLongIdx = pGlosGroup->GetLongIndex( aNewShort );
     304           0 :         sal_uInt16 nOldIdx = pGlosGroup->GetIndex( aNewName );
     305             : 
     306           0 :         if( nIdx != USHRT_MAX &&
     307           0 :                 (nOldLongIdx == USHRT_MAX || nOldLongIdx == nIdx )&&
     308           0 :                     (nOldIdx == USHRT_MAX || nOldIdx == nIdx ))
     309             :         {
     310           0 :             pGlosGroup->Rename( nIdx, &aNewShort, &aNewName );
     311           0 :             if(pGlosGroup->GetError() != 0)
     312           0 :                 throw io::IOException();
     313             :         }
     314           0 :         delete pGlosGroup;
     315             :     }
     316             :     else
     317           0 :         throw uno::RuntimeException();
     318           0 : }
     319             : 
     320           0 : static bool lcl_CopySelToDoc( SwDoc* pInsDoc, OTextCursorHelper* pxCursor, SwXTextRange* pxRange)
     321             : {
     322             :     OSL_ENSURE( pInsDoc, "no InsDoc");
     323             : 
     324           0 :     SwNodes& rNds = pInsDoc->GetNodes();
     325             : 
     326           0 :     SwNodeIndex aIdx( rNds.GetEndOfContent(), -1 );
     327           0 :     SwCntntNode * pNd = aIdx.GetNode().GetCntntNode();
     328           0 :     SwPosition aPos( aIdx, SwIndex( pNd, pNd->Len() ));
     329             : 
     330           0 :     bool bRet = false;
     331           0 :     pInsDoc->LockExpFlds();
     332             :     {
     333           0 :         SwDoc *const pDoc((pxCursor) ? pxCursor->GetDoc() : pxRange->GetDoc());
     334           0 :         SwPaM aPam(pDoc->GetNodes());
     335           0 :         SwPaM * pPam(0);
     336           0 :         if(pxCursor)
     337             :         {
     338           0 :             pPam = pxCursor->GetPaM();
     339             :         }
     340             :         else
     341             :         {
     342           0 :             if (pxRange->GetPositions(aPam))
     343             :             {
     344           0 :                 pPam = & aPam;
     345             :             }
     346             :         }
     347           0 :         if (!pPam) { return false; }
     348           0 :         bRet = pDoc->CopyRange( *pPam, aPos, false ) || bRet;
     349             :     }
     350             : 
     351           0 :     pInsDoc->UnlockExpFlds();
     352           0 :     if( !pInsDoc->IsExpFldsLocked() )
     353           0 :         pInsDoc->UpdateExpFlds(NULL, true);
     354             : 
     355           0 :     return bRet;
     356             : }
     357             : 
     358           0 : uno::Reference< text::XAutoTextEntry >  SwXAutoTextGroup::insertNewByName(const OUString& aName,
     359             :         const OUString& aTitle, const uno::Reference< text::XTextRange > & xTextRange)
     360             :         throw( container::ElementExistException, uno::RuntimeException, std::exception )
     361             : {
     362           0 :     SolarMutexGuard aGuard;
     363           0 :     if(hasByName(aName))
     364           0 :         throw container::ElementExistException();
     365           0 :     if(!xTextRange.is())
     366           0 :         throw uno::RuntimeException();
     367             : 
     368           0 :     SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0;
     369           0 :     OUString sShortName(aName);
     370           0 :     OUString sLongName(aTitle);
     371           0 :     if(pGlosGroup && !pGlosGroup->GetError())
     372             :     {
     373           0 :         uno::Reference<lang::XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
     374           0 :         SwXTextRange* pxRange = 0;
     375           0 :         OTextCursorHelper* pxCursor = 0;
     376           0 :         if(xRangeTunnel.is())
     377             :         {
     378           0 :             pxRange = reinterpret_cast<SwXTextRange*>(xRangeTunnel->getSomething(
     379           0 :                                     SwXTextRange::getUnoTunnelId()));
     380           0 :             pxCursor = reinterpret_cast<OTextCursorHelper*>(xRangeTunnel->getSomething(
     381           0 :                                     OTextCursorHelper::getUnoTunnelId()));
     382             :         }
     383             : 
     384           0 :         OUString sOnlyTxt;
     385           0 :         OUString* pOnlyTxt = 0;
     386           0 :         bool bNoAttr = !pxCursor && !pxRange;
     387           0 :         if(bNoAttr)
     388             :         {
     389           0 :             sOnlyTxt = OUString(xTextRange->getString());
     390           0 :             pOnlyTxt = &sOnlyTxt;
     391             :         }
     392             : 
     393           0 :         const SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get();
     394             : 
     395           0 :         SwDoc* pGDoc = pGlosGroup->GetDoc();
     396             : 
     397             :         // Until there is an option for that, delete base util::URL
     398           0 :         if(rCfg.IsSaveRelFile())
     399             :         {
     400           0 :             INetURLObject aTemp(pGlosGroup->GetFileName());
     401           0 :             pGlosGroup->SetBaseURL( aTemp.GetMainURL(INetURLObject::NO_DECODE));
     402             :         }
     403             :         else
     404           0 :             pGlosGroup->SetBaseURL( OUString() );
     405             : 
     406             :         sal_uInt16 nRet;
     407           0 :         if( pOnlyTxt )
     408           0 :             nRet = pGlosGroup->PutText( sShortName, sLongName, *pOnlyTxt );
     409             :         else
     410             :         {
     411           0 :             pGlosGroup->ClearDoc();
     412           0 :             if( pGlosGroup->BeginPutDoc( sShortName, sLongName ) )
     413             :             {
     414           0 :                 pGDoc->SetRedlineMode_intern( nsRedlineMode_t::REDLINE_DELETE_REDLINES );
     415           0 :                 lcl_CopySelToDoc( pGDoc, pxCursor, pxRange );
     416           0 :                 pGDoc->SetRedlineMode_intern((RedlineMode_t)( 0 ));
     417           0 :                 nRet = pGlosGroup->PutDoc();
     418             :             }
     419             :             else
     420           0 :                 nRet = (sal_uInt16) -1;
     421             :         }
     422             : 
     423           0 :         if(nRet == (sal_uInt16) -1 )
     424             :         {
     425           0 :             throw uno::RuntimeException();
     426             :         }
     427           0 :         pGlossaries->PutGroupDoc( pGlosGroup );
     428             :     }
     429             : 
     430             :     uno::Reference< text::XAutoTextEntry > xEntry = pGlossaries ?
     431             :         pGlossaries->GetAutoTextEntry( m_sGroupName, sName, sShortName, true ) :
     432           0 :         uno::Reference< text::XAutoTextEntry >();
     433             :     OSL_ENSURE( xEntry.is(), "SwXAutoTextGroup::insertNewByName: no UNO object created? How this?" );
     434             :         // we just inserted the entry into the group, so why doesn't it exist?
     435             : 
     436           0 :     return xEntry;
     437             : }
     438             : 
     439           0 : void SwXAutoTextGroup::removeByName(const OUString& aEntryName) throw( container::NoSuchElementException, uno::RuntimeException, std::exception )
     440             : {
     441           0 :     SolarMutexGuard aGuard;
     442           0 :     SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0;
     443           0 :     if(pGlosGroup && !pGlosGroup->GetError())
     444             :     {
     445           0 :         sal_uInt16 nIdx = pGlosGroup->GetIndex(aEntryName);
     446           0 :         if ( nIdx != USHRT_MAX )
     447           0 :             pGlosGroup->Delete(nIdx);
     448           0 :         delete pGlosGroup;
     449             :     }
     450             :     else
     451           0 :         throw container::NoSuchElementException();
     452           0 : }
     453             : 
     454           0 : OUString SwXAutoTextGroup::getName(void) throw( uno::RuntimeException, std::exception )
     455             : {
     456           0 :     SolarMutexGuard aGuard;
     457           0 :     return sName;
     458             : }
     459             : 
     460           0 : void SwXAutoTextGroup::setName(const OUString& rName) throw( uno::RuntimeException, std::exception )
     461             : {
     462           0 :     SolarMutexGuard aGuard;
     463           0 :     if( !pGlossaries )
     464           0 :         throw uno::RuntimeException();
     465             : 
     466           0 :     sal_Int32 nNewDelimPos = rName.lastIndexOf( GLOS_DELIM );
     467           0 :     sal_Int32 nOldDelimPos = sName.lastIndexOf( GLOS_DELIM );
     468             : 
     469           0 :     OUString aNewSuffix;
     470           0 :     if (nNewDelimPos > -1)
     471           0 :         aNewSuffix = rName.copy( nNewDelimPos + 1 );
     472           0 :     OUString aOldSuffix;
     473           0 :     if (nOldDelimPos > -1)
     474           0 :         aOldSuffix = sName.copy( nOldDelimPos + 1 );
     475             : 
     476           0 :     sal_Int32 nNewNumeric = aNewSuffix.toInt32();
     477           0 :     sal_Int32 nOldNumeric = aOldSuffix.toInt32();
     478             : 
     479           0 :     OUString aNewPrefix( (nNewDelimPos > 1) ? rName.copy( 0, nNewDelimPos ) : rName );
     480           0 :     OUString aOldPrefix( (nOldDelimPos > 1) ? sName.copy( 0, nOldDelimPos ) : sName );
     481             : 
     482           0 :     if ( sName == rName ||
     483           0 :        ( nNewNumeric == nOldNumeric && aNewPrefix == aOldPrefix ) )
     484           0 :         return;
     485           0 :     OUString sNewGroup(rName);
     486           0 :     if (sNewGroup.indexOf(GLOS_DELIM)<0)
     487             :     {
     488           0 :         sNewGroup += OUString(GLOS_DELIM) + "0";
     489             :     }
     490             : 
     491             :     //the name must be saved, the group may be invalidated while in RenameGroupDoc()
     492           0 :     SwGlossaries* pTempGlossaries = pGlossaries;
     493             : 
     494           0 :     OUString sPreserveTitle( pGlossaries->GetGroupTitle( sName ) );
     495           0 :     if ( !pGlossaries->RenameGroupDoc( sName, sNewGroup, sPreserveTitle ) )
     496           0 :         throw uno::RuntimeException();
     497             :     else
     498             :     {
     499           0 :         sName = rName;
     500           0 :         m_sGroupName = sNewGroup;
     501           0 :         pGlossaries = pTempGlossaries;
     502           0 :     }
     503             : }
     504             : 
     505           0 : sal_Int32 SwXAutoTextGroup::getCount(void) throw( uno::RuntimeException, std::exception )
     506             : {
     507           0 :     SolarMutexGuard aGuard;
     508           0 :     int nCount = 0;
     509           0 :     SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0;
     510           0 :     if(pGlosGroup && !pGlosGroup->GetError())
     511           0 :         nCount = pGlosGroup->GetCount();
     512             :     else
     513           0 :         throw uno::RuntimeException();
     514           0 :     delete pGlosGroup;
     515           0 :     return nCount;
     516             : }
     517             : 
     518           0 : uno::Any SwXAutoTextGroup::getByIndex(sal_Int32 nIndex)
     519             :     throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
     520             : {
     521           0 :     SolarMutexGuard aGuard;
     522           0 :     uno::Any aRet;
     523           0 :     sal_uInt16 nCount = 0;
     524           0 :     SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0;
     525           0 :     if(pGlosGroup && !pGlosGroup->GetError())
     526           0 :         nCount = pGlosGroup->GetCount();
     527             :     else
     528           0 :         throw uno::RuntimeException();
     529           0 :     if(0 <= nIndex && nIndex < nCount)
     530           0 :         aRet = getByName(pGlosGroup->GetShortName((sal_uInt16) nIndex));
     531             :     else
     532           0 :         throw lang::IndexOutOfBoundsException();
     533           0 :     delete pGlosGroup;
     534           0 :     return aRet;
     535             : }
     536             : 
     537           0 : uno::Type SwXAutoTextGroup::getElementType(void) throw( uno::RuntimeException, std::exception )
     538             : {
     539           0 :     return ::getCppuType((uno::Reference<text::XAutoTextEntry>*)0);
     540             : 
     541             : }
     542             : 
     543           0 : sal_Bool SwXAutoTextGroup::hasElements(void) throw( uno::RuntimeException, std::exception )
     544             : {
     545           0 :     SolarMutexGuard aGuard;
     546           0 :     SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0;
     547           0 :     sal_uInt16 nCount = 0;
     548           0 :     if(pGlosGroup && !pGlosGroup->GetError())
     549           0 :         nCount = pGlosGroup->GetCount();
     550             :     else
     551           0 :         throw uno::RuntimeException();
     552           0 :     delete pGlosGroup;
     553           0 :     return nCount > 0;
     554             : 
     555             : }
     556             : 
     557           0 : uno::Any SwXAutoTextGroup::getByName(const OUString& _rName)
     558             :     throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
     559             : {
     560           0 :     SolarMutexGuard aGuard;
     561           0 :     uno::Reference< text::XAutoTextEntry > xEntry = pGlossaries->GetAutoTextEntry( m_sGroupName, sName, _rName, true );
     562             :     OSL_ENSURE( xEntry.is(), "SwXAutoTextGroup::getByName: GetAutoTextEntry is fractious!" );
     563             :         // we told it to create the object, so why didn't it?
     564           0 :     return makeAny( xEntry );
     565             : }
     566             : 
     567           0 : uno::Sequence< OUString > SwXAutoTextGroup::getElementNames(void)
     568             :     throw( uno::RuntimeException, std::exception )
     569             : {
     570           0 :     SolarMutexGuard aGuard;
     571           0 :     sal_uInt16 nCount = 0;
     572           0 :     SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0;
     573           0 :     if(pGlosGroup && !pGlosGroup->GetError())
     574           0 :         nCount = pGlosGroup->GetCount();
     575             :     else
     576           0 :         throw uno::RuntimeException();
     577             : 
     578           0 :     uno::Sequence< OUString > aEntryNames(nCount);
     579           0 :     OUString *pArr = aEntryNames.getArray();
     580             : 
     581           0 :     for ( sal_uInt16 i = 0; i < nCount; i++ )
     582           0 :         pArr[i] = pGlosGroup->GetShortName(i);
     583           0 :     delete pGlosGroup;
     584           0 :     return aEntryNames;
     585             : }
     586             : 
     587           0 : sal_Bool SwXAutoTextGroup::hasByName(const OUString& rName)
     588             :     throw( uno::RuntimeException, std::exception )
     589             : {
     590           0 :     SolarMutexGuard aGuard;
     591           0 :     sal_Bool bRet = sal_False;
     592           0 :     sal_uInt16 nCount = 0;
     593           0 :     SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0;
     594           0 :     if(pGlosGroup && !pGlosGroup->GetError())
     595           0 :         nCount = pGlosGroup->GetCount();
     596             :     else
     597           0 :         throw uno::RuntimeException();
     598             : 
     599           0 :     for( sal_uInt16 i = 0; i < nCount; ++i )
     600             :     {
     601           0 :         OUString sCompare(pGlosGroup->GetShortName(i));
     602           0 :         if(sCompare.equalsIgnoreAsciiCase(rName))
     603             :         {
     604           0 :             bRet = true;
     605           0 :             break;
     606             :         }
     607           0 :     }
     608           0 :     delete pGlosGroup;
     609           0 :     return bRet;
     610             : }
     611             : 
     612           0 : uno::Reference< beans::XPropertySetInfo >  SwXAutoTextGroup::getPropertySetInfo(void)
     613             :     throw( uno::RuntimeException, std::exception )
     614             : {
     615           0 :     static uno::Reference< beans::XPropertySetInfo >  xRet = pPropSet->getPropertySetInfo();
     616           0 :     return xRet;
     617             : }
     618             : 
     619           0 : void SwXAutoTextGroup::setPropertyValue(
     620             :     const OUString& rPropertyName, const uno::Any& aValue)
     621             :     throw( beans::UnknownPropertyException, beans::PropertyVetoException,
     622             :          lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException, std::exception)
     623             : {
     624           0 :     SolarMutexGuard aGuard;
     625           0 :     const SfxItemPropertySimpleEntry*   pEntry = pPropSet->getPropertyMap().getByName( rPropertyName );
     626             : 
     627           0 :     if(!pEntry)
     628           0 :         throw beans::UnknownPropertyException();
     629             : 
     630           0 :     SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0;
     631           0 :     if(!pGlosGroup || pGlosGroup->GetError())
     632           0 :         throw uno::RuntimeException();
     633           0 :     switch(pEntry->nWID)
     634             :     {
     635             :         case  WID_GROUP_TITLE:
     636             :         {
     637           0 :             OUString sNewTitle;
     638           0 :             aValue >>= sNewTitle;
     639           0 :             if(sNewTitle.isEmpty())
     640           0 :                 throw lang::IllegalArgumentException();
     641           0 :             bool bChanged = !sNewTitle.equals(pGlosGroup->GetName());
     642           0 :             pGlosGroup->SetName(sNewTitle);
     643           0 :             if(bChanged && HasGlossaryList())
     644           0 :                 GetGlossaryList()->ClearGroups();
     645             :         }
     646           0 :         break;
     647             :     }
     648           0 :     delete pGlosGroup;
     649           0 : }
     650             : 
     651           0 : uno::Any SwXAutoTextGroup::getPropertyValue(const OUString& rPropertyName)
     652             :     throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
     653             : {
     654           0 :     SolarMutexGuard aGuard;
     655           0 :     const SfxItemPropertySimpleEntry*   pEntry = pPropSet->getPropertyMap().getByName( rPropertyName);
     656             : 
     657           0 :     if(!pEntry)
     658           0 :         throw beans::UnknownPropertyException();
     659           0 :     SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0;
     660           0 :     if(!pGlosGroup  || pGlosGroup->GetError())
     661           0 :         throw uno::RuntimeException();
     662             : 
     663           0 :     uno::Any aAny;
     664           0 :     switch(pEntry->nWID)
     665             :     {
     666             :         case  WID_GROUP_PATH:
     667           0 :             aAny <<= OUString(pGlosGroup->GetFileName());
     668           0 :         break;
     669             :         case  WID_GROUP_TITLE:
     670           0 :             aAny <<= OUString(pGlosGroup->GetName());
     671           0 :         break;
     672             :     }
     673           0 :     delete pGlosGroup;
     674           0 :     return aAny;
     675             : }
     676             : 
     677           0 : void SwXAutoTextGroup::addPropertyChangeListener(
     678             :     const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/)
     679             :     throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
     680             : {
     681           0 : }
     682             : 
     683           0 : void SwXAutoTextGroup::removePropertyChangeListener(
     684             :     const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/)
     685             :     throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
     686             : {
     687           0 : }
     688             : 
     689           0 : void SwXAutoTextGroup::addVetoableChangeListener(
     690             :     const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/)
     691             :     throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
     692             : {
     693           0 : }
     694             : 
     695           0 : void SwXAutoTextGroup::removeVetoableChangeListener(
     696             :     const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/)
     697             :     throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception )
     698             : {
     699           0 : }
     700             : 
     701           0 : void SwXAutoTextGroup::Invalidate()
     702             : {
     703           0 :     pGlossaries = 0;
     704           0 :     sName = OUString();
     705           0 :     m_sGroupName = OUString();
     706           0 : }
     707             : 
     708           0 : OUString SwXAutoTextGroup::getImplementationName(void) throw( uno::RuntimeException, std::exception )
     709             : {
     710           0 :     return OUString("SwXAutoTextGroup");
     711             : }
     712             : 
     713           0 : sal_Bool SwXAutoTextGroup::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
     714             : {
     715           0 :     return cppu::supportsService(this, rServiceName);
     716             : }
     717             : 
     718           0 : uno::Sequence< OUString > SwXAutoTextGroup::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
     719             : {
     720           0 :     uno::Sequence< OUString > aRet(1);
     721           0 :     OUString* pArray = aRet.getArray();
     722           0 :     pArray[0] = "com.sun.star.text.AutoTextGroup";
     723           0 :     return aRet;
     724             : }
     725             : 
     726             : namespace
     727             : {
     728             :     class theSwXAutoTextEntryUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSwXAutoTextEntryUnoTunnelId > {};
     729             : }
     730             : 
     731           0 : const uno::Sequence< sal_Int8 > & SwXAutoTextEntry::getUnoTunnelId()
     732             : {
     733           0 :     return theSwXAutoTextEntryUnoTunnelId::get().getSeq();
     734             : }
     735             : 
     736           0 : sal_Int64 SAL_CALL SwXAutoTextEntry::getSomething( const uno::Sequence< sal_Int8 >& rId )
     737             :     throw(uno::RuntimeException, std::exception)
     738             : {
     739           0 :     if( rId.getLength() == 16
     740           0 :         && 0 == memcmp( getUnoTunnelId().getConstArray(),
     741           0 :                                         rId.getConstArray(), 16 ) )
     742             :     {
     743           0 :             return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >( this ));
     744             :     }
     745           0 :     return 0;
     746             : }
     747             : 
     748           0 : SwXAutoTextEntry::SwXAutoTextEntry(SwGlossaries* pGlss, const OUString& rGroupName,
     749             :                                             const OUString& rEntryName) :
     750             :     pGlossaries(pGlss),
     751             :     sGroupName(rGroupName),
     752             :     sEntryName(rEntryName),
     753           0 :     pBodyText ( NULL )
     754             : {
     755           0 : }
     756             : 
     757           0 : SwXAutoTextEntry::~SwXAutoTextEntry()
     758             : {
     759             :     {
     760           0 :         SolarMutexGuard aGuard;
     761             : 
     762             :         // ensure that any pending modifications are written
     763           0 :         implFlushDocument( true );
     764             : 
     765             :         //! Bug #96559
     766             :         // DocShell must be cleared before mutex is lost.
     767             :         // Needs to be done explicitly since xDocSh is a class member.
     768             :         // Thus, an own block here, guarded by the SolarMutex
     769             :     }
     770           0 : }
     771             : 
     772           0 : void SwXAutoTextEntry::implFlushDocument( bool _bCloseDoc )
     773             : {
     774           0 :     if ( xDocSh.Is() )
     775             :     {
     776           0 :         if ( xDocSh->GetDoc()->IsModified () )
     777           0 :             xDocSh->Save();
     778             : 
     779           0 :         if ( _bCloseDoc )
     780             :         {
     781             :             // stop listening at the document
     782           0 :             EndListening( *&xDocSh );
     783             : 
     784           0 :             xDocSh->DoClose();
     785           0 :             xDocSh.Clear();
     786             :         }
     787             :     }
     788           0 : }
     789             : 
     790           0 : void SwXAutoTextEntry::Notify( SfxBroadcaster& _rBC, const SfxHint& _rHint )
     791             : {
     792           0 :     if ( &_rBC == &xDocSh )
     793             :     {   // it's our document
     794           0 :         if ( _rHint.ISA( SfxSimpleHint ) )
     795             :         {
     796           0 :             if ( SFX_HINT_DEINITIALIZING == static_cast< const SfxSimpleHint& >( _rHint ).GetId() )
     797             :             {
     798             :                 // our document is dying (possibly because we're shuting down, and the document was notified
     799             :                 // earlier than we are?)
     800             :                 // stop listening at the docu
     801           0 :                 EndListening( *&xDocSh );
     802             :                 // and release our reference
     803           0 :                 xDocSh.Clear();
     804             :             }
     805             :         }
     806           0 :         else if(_rHint.ISA(SfxEventHint))
     807             :         {
     808           0 :             if(SFX_EVENT_PREPARECLOSEDOC == static_cast< const SfxEventHint& >( _rHint ).GetEventId())
     809             :             {
     810           0 :                 implFlushDocument( false );
     811           0 :                 xBodyText = 0;
     812           0 :                 xDocSh.Clear();
     813             :             }
     814             :         }
     815             :     }
     816           0 : }
     817             : 
     818           0 : void SwXAutoTextEntry::GetBodyText ()
     819             : {
     820           0 :     SolarMutexGuard aGuard;
     821             : 
     822           0 :     xDocSh = pGlossaries->EditGroupDoc ( sGroupName, sEntryName, sal_False );
     823             :     OSL_ENSURE( xDocSh.Is(), "SwXAutoTextEntry::GetBodyText: unexpected: no doc returned by EditGroupDoc!" );
     824             : 
     825             :     // start listening at the document
     826           0 :     StartListening( *&xDocSh );
     827             : 
     828           0 :     pBodyText = new SwXBodyText ( xDocSh->GetDoc() );
     829           0 :     xBodyText = uno::Reference < lang::XServiceInfo > ( *pBodyText, uno::UNO_QUERY);
     830           0 : }
     831             : 
     832           0 : uno::Reference< text::XTextCursor >  SwXAutoTextEntry::createTextCursor(void) throw( uno::RuntimeException, std::exception )
     833             : {
     834           0 :     SolarMutexGuard aGuard;
     835           0 :     EnsureBodyText();
     836           0 :     return pBodyText->createTextCursor();
     837             : }
     838             : 
     839           0 : uno::Reference< text::XTextCursor >  SwXAutoTextEntry::createTextCursorByRange(
     840             :     const uno::Reference< text::XTextRange > & aTextPosition) throw( uno::RuntimeException, std::exception )
     841             : {
     842           0 :     SolarMutexGuard aGuard;
     843           0 :     EnsureBodyText();
     844           0 :     return pBodyText->createTextCursorByRange ( aTextPosition );
     845             : }
     846             : 
     847           0 : void SwXAutoTextEntry::insertString(const uno::Reference< text::XTextRange > & xRange, const OUString& aString, sal_Bool bAbsorb) throw( uno::RuntimeException, std::exception )
     848             : {
     849           0 :     SolarMutexGuard aGuard;
     850           0 :     EnsureBodyText();
     851           0 :     pBodyText->insertString ( xRange, aString, bAbsorb );
     852           0 : }
     853             : 
     854           0 : void SwXAutoTextEntry::insertControlCharacter(const uno::Reference< text::XTextRange > & xRange,
     855             :     sal_Int16 nControlCharacter, sal_Bool bAbsorb)
     856             :         throw( lang::IllegalArgumentException, uno::RuntimeException, std::exception )
     857             : {
     858           0 :     SolarMutexGuard aGuard;
     859           0 :     EnsureBodyText();
     860           0 :     pBodyText->insertControlCharacter ( xRange, nControlCharacter, bAbsorb );
     861           0 : }
     862             : 
     863           0 : void SwXAutoTextEntry::insertTextContent(
     864             :     const uno::Reference< text::XTextRange > & xRange,
     865             :     const uno::Reference< text::XTextContent > & xContent, sal_Bool bAbsorb)
     866             :         throw( lang::IllegalArgumentException, uno::RuntimeException, std::exception )
     867             : {
     868           0 :     SolarMutexGuard aGuard;
     869           0 :     EnsureBodyText();
     870           0 :     pBodyText->insertTextContent ( xRange, xContent, bAbsorb );
     871           0 : }
     872             : 
     873           0 : void SwXAutoTextEntry::removeTextContent(
     874             :     const uno::Reference< text::XTextContent > & xContent)
     875             :         throw( container::NoSuchElementException, uno::RuntimeException, std::exception )
     876             : {
     877           0 :     SolarMutexGuard aGuard;
     878           0 :     EnsureBodyText();
     879           0 :     pBodyText->removeTextContent ( xContent );
     880           0 : }
     881             : 
     882           0 : uno::Reference< text::XText >  SwXAutoTextEntry::getText(void) throw( uno::RuntimeException, std::exception )
     883             : {
     884           0 :     SolarMutexGuard aGuard;
     885           0 :     uno::Reference< text::XText >  xRet =  (text::XText*)this;
     886           0 :     return xRet;
     887             : }
     888             : 
     889           0 : uno::Reference< text::XTextRange >  SwXAutoTextEntry::getStart(void) throw( uno::RuntimeException, std::exception )
     890             : {
     891           0 :     SolarMutexGuard aGuard;
     892           0 :     EnsureBodyText();
     893           0 :     return pBodyText->getStart();
     894             : }
     895             : 
     896           0 : uno::Reference< text::XTextRange >  SwXAutoTextEntry::getEnd(void) throw( uno::RuntimeException, std::exception )
     897             : {
     898           0 :     SolarMutexGuard aGuard;
     899           0 :     EnsureBodyText();
     900           0 :     return pBodyText->getEnd();
     901             : }
     902             : 
     903           0 : OUString SwXAutoTextEntry::getString(void) throw( uno::RuntimeException, std::exception )
     904             : {
     905           0 :     SolarMutexGuard aGuard;
     906           0 :     EnsureBodyText();
     907           0 :     return pBodyText->getString();
     908             : }
     909             : 
     910           0 : void SwXAutoTextEntry::setString(const OUString& aString) throw( uno::RuntimeException, std::exception )
     911             : {
     912           0 :     SolarMutexGuard aGuard;
     913           0 :     EnsureBodyText();
     914           0 :     pBodyText->setString( aString );
     915           0 : }
     916             : 
     917           0 : void SwXAutoTextEntry::applyTo(const uno::Reference< text::XTextRange > & xTextRange)throw( uno::RuntimeException, std::exception )
     918             : {
     919           0 :     SolarMutexGuard aGuard;
     920             : 
     921             :     // ensure that any pending modifications are written
     922             :     // reason is that we're holding the _copy_ of the auto text, while the real auto text
     923             :     // is stored somewhere. And below, we're not working with our copy, but only tell the target
     924             :     // TextRange to work with the stored version.
     925             :     // #96380# - 2003-03-03 - fs@openoffice.org
     926           0 :     implFlushDocument( false );
     927             :         // TODO: think about if we should pass "true" here
     928             :         // The difference would be that when the next modification is made to this instance here, then
     929             :         // we would be forced to open the document again, instead of working on our current copy.
     930             :         // This means that we would reflect any changes which were done to the AutoText by foreign instances
     931             :         // in the meantime
     932             : 
     933           0 :     uno::Reference<lang::XUnoTunnel> xTunnel( xTextRange, uno::UNO_QUERY);
     934           0 :     SwXTextRange* pRange = 0;
     935           0 :     OTextCursorHelper* pCursor = 0;
     936           0 :     SwXText *pText = 0;
     937             : 
     938           0 :     if(xTunnel.is())
     939             :     {
     940             :         pRange = reinterpret_cast < SwXTextRange* >
     941           0 :                 ( xTunnel->getSomething( SwXTextRange::getUnoTunnelId() ) );
     942             :         pCursor = reinterpret_cast < OTextCursorHelper*>
     943           0 :                 ( xTunnel->getSomething( OTextCursorHelper::getUnoTunnelId() ) );
     944             :         pText = reinterpret_cast < SwXText* >
     945           0 :                 ( xTunnel->getSomething( SwXText::getUnoTunnelId() ) );
     946             :     }
     947             : 
     948           0 :     SwDoc* pDoc = 0;
     949           0 :     if (pRange)
     950           0 :         pDoc = pRange->GetDoc();
     951           0 :     else if ( pCursor )
     952           0 :         pDoc = pCursor->GetDoc();
     953           0 :     else if ( pText && pText->GetDoc() )
     954             :     {
     955           0 :         xTunnel = uno::Reference < lang::XUnoTunnel > (pText->getStart(), uno::UNO_QUERY);
     956           0 :         if (xTunnel.is())
     957             :         {
     958             :             pCursor = reinterpret_cast < OTextCursorHelper* >
     959           0 :                 ( xTunnel->getSomething( OTextCursorHelper::getUnoTunnelId() ) );
     960           0 :             if (pCursor)
     961           0 :                 pDoc = pText->GetDoc();
     962             :         }
     963             :     }
     964             : 
     965           0 :     if(!pDoc)
     966           0 :         throw uno::RuntimeException();
     967             : 
     968           0 :     SwPaM InsertPaM(pDoc->GetNodes());
     969           0 :     if (pRange)
     970             :     {
     971           0 :         if (!pRange->GetPositions(InsertPaM))
     972             :         {
     973           0 :             throw uno::RuntimeException();
     974             :         }
     975             :     }
     976             :     else
     977             :     {
     978           0 :         InsertPaM = *pCursor->GetPaM();
     979             :     }
     980             : 
     981           0 :     boost::scoped_ptr<SwTextBlocks> pBlock(pGlossaries->GetGroupDoc(sGroupName));
     982           0 :     const bool bResult = pBlock.get() && !pBlock->GetError()
     983           0 :                     && pDoc->InsertGlossary( *pBlock, sEntryName, InsertPaM);
     984             : 
     985           0 :     if(!bResult)
     986           0 :         throw uno::RuntimeException();
     987           0 : }
     988             : 
     989           0 : OUString SwXAutoTextEntry::getImplementationName(void) throw( uno::RuntimeException, std::exception )
     990             : {
     991           0 :     return OUString("SwXAutoTextEntry");
     992             : }
     993             : 
     994           0 : sal_Bool SwXAutoTextEntry::supportsService(const OUString& rServiceName) throw( uno::RuntimeException, std::exception )
     995             : {
     996           0 :     return cppu::supportsService(this, rServiceName);
     997             : }
     998             : 
     999           0 : uno::Sequence< OUString > SwXAutoTextEntry::getSupportedServiceNames(void) throw( uno::RuntimeException, std::exception )
    1000             : {
    1001           0 :     uno::Sequence< OUString > aRet(1);
    1002           0 :     OUString* pArray = aRet.getArray();
    1003           0 :     pArray[0] = "com.sun.star.text.AutoTextEntry";
    1004           0 :     return aRet;
    1005             : }
    1006             : 
    1007           0 : uno::Reference< container::XNameReplace > SwXAutoTextEntry::getEvents()
    1008             :     throw( uno::RuntimeException, std::exception )
    1009             : {
    1010           0 :     return new SwAutoTextEventDescriptor( *this );
    1011             : }
    1012             : 
    1013             : const struct SvEventDescription aAutotextEvents[] =
    1014             : {
    1015             :     { SW_EVENT_START_INS_GLOSSARY,  "OnInsertStart" },
    1016             :     { SW_EVENT_END_INS_GLOSSARY,    "OnInsertDone" },
    1017             :     { 0, NULL }
    1018             : };
    1019             : 
    1020           0 : SwAutoTextEventDescriptor::SwAutoTextEventDescriptor(
    1021             :     SwXAutoTextEntry& rAutoText ) :
    1022             :         SvBaseEventDescriptor(aAutotextEvents),
    1023             :         sSwAutoTextEventDescriptor(
    1024             :             "SwAutoTextEventDescriptor"),
    1025           0 :         rAutoTextEntry(rAutoText)
    1026             : {
    1027           0 : }
    1028             : 
    1029           0 : SwAutoTextEventDescriptor::~SwAutoTextEventDescriptor()
    1030             : {
    1031           0 : }
    1032             : 
    1033           0 : OUString SwAutoTextEventDescriptor::getImplementationName()
    1034             :     throw( uno::RuntimeException, std::exception )
    1035             : {
    1036           0 :     return sSwAutoTextEventDescriptor;
    1037             : }
    1038             : 
    1039           0 : void SwAutoTextEventDescriptor::replaceByName(
    1040             :     const sal_uInt16 nEvent,
    1041             :     const SvxMacro& rMacro)
    1042             :             throw(
    1043             :                 lang::IllegalArgumentException,
    1044             :                 container::NoSuchElementException,
    1045             :                 lang::WrappedTargetException,
    1046             :                 uno::RuntimeException)
    1047             : {
    1048             :     OSL_ENSURE( NULL != rAutoTextEntry.GetGlossaries(),
    1049             :                 "Strangely enough, the AutoText vanished!" );
    1050             :     OSL_ENSURE( (nEvent == SW_EVENT_END_INS_GLOSSARY) ||
    1051             :                 (nEvent == SW_EVENT_START_INS_GLOSSARY) ,
    1052             :                 "Unknown event ID" );
    1053             : 
    1054             :     SwGlossaries *const pGlossaries =
    1055           0 :         const_cast<SwGlossaries*>(rAutoTextEntry.GetGlossaries());
    1056             :     SwTextBlocks* pBlocks =
    1057           0 :         pGlossaries->GetGroupDoc( rAutoTextEntry.GetGroupName() );
    1058             :     OSL_ENSURE( NULL != pBlocks,
    1059             :                 "can't get autotext group; SwAutoTextEntry has illegal name?");
    1060             : 
    1061           0 :     if( pBlocks && !pBlocks->GetError())
    1062             :     {
    1063           0 :         sal_uInt16 nIndex = pBlocks->GetIndex( rAutoTextEntry.GetEntryName() );
    1064           0 :         if( nIndex != USHRT_MAX )
    1065             :         {
    1066           0 :             SvxMacroTableDtor aMacroTable;
    1067           0 :             if( pBlocks->GetMacroTable( nIndex, aMacroTable ) )
    1068             :             {
    1069           0 :                 aMacroTable.Insert( nEvent, rMacro );
    1070           0 :                 pBlocks->SetMacroTable( nIndex, aMacroTable );
    1071           0 :             }
    1072             :         }
    1073             : 
    1074           0 :         delete pBlocks;
    1075             :     }
    1076             :     // else: ignore
    1077           0 : }
    1078             : 
    1079           0 : void SwAutoTextEventDescriptor::getByName(
    1080             :     SvxMacro& rMacro,
    1081             :     const sal_uInt16 nEvent )
    1082             :             throw(
    1083             :                 container::NoSuchElementException,
    1084             :                 lang::WrappedTargetException,
    1085             :                 uno::RuntimeException)
    1086             : {
    1087             :     OSL_ENSURE( NULL != rAutoTextEntry.GetGlossaries(), "no AutoText" );
    1088             :     OSL_ENSURE( (nEvent == SW_EVENT_END_INS_GLOSSARY) ||
    1089             :                 (nEvent == SW_EVENT_START_INS_GLOSSARY) ,
    1090             :                 "Unknown event ID" );
    1091             : 
    1092             :     SwGlossaries *const pGlossaries =
    1093           0 :         const_cast<SwGlossaries*>(rAutoTextEntry.GetGlossaries());
    1094             :     SwTextBlocks* pBlocks =
    1095           0 :         pGlossaries->GetGroupDoc( rAutoTextEntry.GetGroupName() );
    1096             :     OSL_ENSURE( NULL != pBlocks,
    1097             :                 "can't get autotext group; SwAutoTextEntry has illegal name?");
    1098             : 
    1099             :     // return empty macro, unless macro is found
    1100           0 :     OUString sEmptyStr;
    1101           0 :     SvxMacro aEmptyMacro(sEmptyStr, sEmptyStr);
    1102           0 :     rMacro = aEmptyMacro;
    1103             : 
    1104           0 :     if ( pBlocks &&  !pBlocks->GetError())
    1105             :     {
    1106           0 :         sal_uInt16 nIndex = pBlocks->GetIndex( rAutoTextEntry.GetEntryName() );
    1107           0 :         if( nIndex != USHRT_MAX )
    1108             :         {
    1109           0 :             SvxMacroTableDtor aMacroTable;
    1110           0 :             if( pBlocks->GetMacroTable( nIndex, aMacroTable ) )
    1111             :             {
    1112           0 :                 SvxMacro *pMacro = aMacroTable.Get( nEvent );
    1113           0 :                 if( pMacro )
    1114           0 :                     rMacro = *pMacro;
    1115           0 :             }
    1116             :         }
    1117             : 
    1118           0 :         delete pBlocks;
    1119           0 :     }
    1120           0 : }
    1121             : 
    1122             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10