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

Generated by: LCOV version 1.10