| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sw.hxx" |
| |
| |
| #define _SVSTDARR_STRINGS |
| |
| #include <com/sun/star/beans/PropertyAttribute.hpp> |
| #include <vos/mutex.hxx> |
| #include <tools/debug.hxx> |
| #include <vcl/svapp.hxx> |
| #include <svl/svstdarr.hxx> |
| #include <svtools/unoevent.hxx> |
| #include <svl/urihelper.hxx> |
| #include <sfx2/event.hxx> |
| #include <swtypes.hxx> |
| #include <glosdoc.hxx> |
| #include <shellio.hxx> |
| #include <initui.hxx> |
| #include <gloslst.hxx> |
| #include <unoatxt.hxx> |
| #include <unomap.hxx> |
| #include <unomid.h> |
| #include <unotextbodyhf.hxx> |
| #include <unotextrange.hxx> |
| #include <TextCursorHelper.hxx> |
| #include <swevent.hxx> |
| #include <doc.hxx> |
| #include <unocrsr.hxx> |
| #include <IMark.hxx> |
| #include <unoprnms.hxx> |
| #include <docsh.hxx> |
| #include <swunodef.hxx> |
| #include <swmodule.hxx> |
| #include <svl/smplhint.hxx> |
| #include <svl/macitem.hxx> |
| |
| #include <editeng/acorrcfg.hxx> |
| |
| #include <memory> |
| |
| |
| SV_IMPL_REF ( SwDocShell ) |
| using namespace ::com::sun::star; |
| using ::rtl::OUString; |
| |
| /****************************************************************** |
| * |
| ******************************************************************/ |
| /* -----------------30.03.99 14:31------------------- |
| * |
| * --------------------------------------------------*/ |
| uno::Reference< uno::XInterface > SAL_CALL SwXAutoTextContainer_createInstance( |
| const uno::Reference< lang::XMultiServiceFactory > & ) throw( uno::Exception ) |
| { |
| //the module may not be loaded |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| SwDLL::Init(); |
| static uno::Reference< uno::XInterface > xAText = (cppu::OWeakObject*)new SwXAutoTextContainer();; |
| return xAText; |
| } |
| /* -----------------------------17.04.01 13:17-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| uno::Sequence< OUString > SAL_CALL SwXAutoTextContainer_getSupportedServiceNames() throw() |
| { |
| OUString sService( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.AutoTextContainer")); |
| const uno::Sequence< OUString > aSeq( &sService, 1 ); |
| return aSeq; |
| } |
| /* -----------------------------17.04.01 13:18-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| OUString SAL_CALL SwXAutoTextContainer_getImplementationName() throw() |
| { |
| return OUString( RTL_CONSTASCII_USTRINGPARAM("SwXAutoTextContainer" ) ); |
| } |
| |
| /*-- 21.12.98 12:42:16--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| SwXAutoTextContainer::SwXAutoTextContainer() |
| { |
| pGlossaries = ::GetGlossaries(); |
| |
| } |
| /*-- 21.12.98 12:42:17--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| SwXAutoTextContainer::~SwXAutoTextContainer() |
| { |
| |
| } |
| /*-- 21.12.98 12:42:17--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Int32 SwXAutoTextContainer::getCount(void) throw( uno::RuntimeException ) |
| { |
| return pGlossaries->GetGroupCnt(); |
| } |
| /*-- 21.12.98 12:42:18--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Any SwXAutoTextContainer::getByIndex(sal_Int32 nIndex) |
| throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| uno::Any aRet; |
| sal_uInt16 nCount = pGlossaries->GetGroupCnt(); |
| if ( 0 <= nIndex && nIndex < nCount ) |
| aRet = getByName(pGlossaries->GetGroupName( static_cast< sal_uInt16 >(nIndex) )); |
| else |
| throw lang::IndexOutOfBoundsException(); |
| return aRet; |
| } |
| /*-- 21.12.98 12:42:18--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Type SwXAutoTextContainer::getElementType(void) throw( uno::RuntimeException ) |
| { |
| return ::getCppuType((const uno::Reference<text::XAutoTextGroup>*)0); |
| |
| } |
| /*-- 21.12.98 12:42:18--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXAutoTextContainer::hasElements(void) throw( uno::RuntimeException ) |
| { |
| //zumindest Standard sollte es immer geben! |
| return sal_True; |
| } |
| /*-- 21.12.98 12:42:18--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Any SwXAutoTextContainer::getByName(const OUString& GroupName) |
| throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| |
| uno::Reference< text::XAutoTextGroup > xGroup; |
| if ( pGlossaries && hasByName( GroupName ) ) // group name already known? |
| // sal_True = create group if not already available |
| xGroup = pGlossaries->GetAutoTextGroup( GroupName, sal_True ); |
| |
| if ( !xGroup.is() ) |
| throw container::NoSuchElementException(); |
| |
| return makeAny( xGroup ); |
| } |
| /*-- 21.12.98 12:42:19--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Sequence< OUString > SwXAutoTextContainer::getElementNames(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_uInt16 nCount = pGlossaries->GetGroupCnt(); |
| |
| uno::Sequence< OUString > aGroupNames(nCount); |
| OUString *pArr = aGroupNames.getArray(); |
| |
| for ( sal_uInt16 i = 0; i < nCount; i++ ) |
| { |
| // Die Namen werden ohne Pfad-Extension weitergegeben |
| String sGroupName(pGlossaries->GetGroupName(i)); |
| pArr[i] = sGroupName.GetToken(0, GLOS_DELIM); |
| } |
| return aGroupNames; |
| } |
| /*-- 21.12.98 12:42:19--------------------------------------------------- |
| findet Gruppennamen mit und ohne Pfadindex |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXAutoTextContainer::hasByName(const OUString& Name) |
| throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| String sGroupName( pGlossaries->GetCompleteGroupName( Name ) ); |
| if(sGroupName.Len()) |
| return sal_True; |
| return sal_False; |
| } |
| /*-- 21.12.98 12:42:19--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< text::XAutoTextGroup > SwXAutoTextContainer::insertNewByName( |
| const OUString& aGroupName) |
| throw( lang::IllegalArgumentException, container::ElementExistException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(hasByName(aGroupName)) |
| throw container::ElementExistException(); |
| //check for non-ASCII characters |
| if(!aGroupName.getLength()) |
| { |
| lang::IllegalArgumentException aIllegal; |
| aIllegal.Message = C2U("group name must not be empty"); |
| throw aIllegal; |
| } |
| for(sal_Int32 nPos = 0; nPos < aGroupName.getLength(); nPos++) |
| { |
| sal_Unicode cChar = aGroupName[nPos]; |
| if( ((cChar >= 'A') && (cChar <= 'Z')) || |
| ((cChar >= 'a') && (cChar <= 'z')) || |
| ((cChar >= '0') && (cChar <= '9')) || |
| (cChar == '_') || |
| (cChar == 0x20) || |
| (cChar == GLOS_DELIM) ) |
| { |
| continue; |
| } |
| lang::IllegalArgumentException aIllegal; |
| aIllegal.Message = C2U("group name must contain a-z, A-z, '_', ' ' only"); |
| throw aIllegal; |
| } |
| String sGroup(aGroupName); |
| if(STRING_NOTFOUND == sGroup.Search(GLOS_DELIM)) |
| { |
| sGroup += GLOS_DELIM; |
| sGroup += UniString::CreateFromInt32(0); |
| } |
| pGlossaries->NewGroupDoc(sGroup, sGroup.GetToken(0, GLOS_DELIM)); |
| |
| uno::Reference< text::XAutoTextGroup > xGroup = pGlossaries->GetAutoTextGroup( sGroup, true ); |
| DBG_ASSERT( xGroup.is(), "SwXAutoTextContainer::insertNewByName: no UNO object created? How this?" ); |
| // we just inserted the group into the glossaries, so why doesn't it exist? |
| |
| return xGroup; |
| } |
| /*-- 21.12.98 12:42:19--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextContainer::removeByName(const OUString& aGroupName) |
| throw( container::NoSuchElementException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| //zunaechst den Namen mit Pfad-Extension finden |
| String sGroupName = pGlossaries->GetCompleteGroupName( aGroupName ); |
| if(!sGroupName.Len()) |
| throw container::NoSuchElementException(); |
| pGlossaries->DelGroupDoc(sGroupName); |
| } |
| /* -----------------------------06.04.00 11:11-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| OUString SwXAutoTextContainer::getImplementationName(void) throw( uno::RuntimeException ) |
| { |
| return SwXAutoTextContainer_getImplementationName(); |
| } |
| /* -----------------------------06.04.00 11:11-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| sal_Bool SwXAutoTextContainer::supportsService(const OUString& rServiceName) throw( uno::RuntimeException ) |
| { |
| const uno::Sequence< OUString > aNames = SwXAutoTextContainer_getSupportedServiceNames(); |
| for(sal_Int32 nService = 0; nService < aNames.getLength(); nService++) |
| { |
| if(aNames.getConstArray()[nService] == rServiceName) |
| return sal_True; |
| } |
| return sal_False; |
| } |
| /* -----------------------------06.04.00 11:11-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| uno::Sequence< OUString > SwXAutoTextContainer::getSupportedServiceNames(void) throw( uno::RuntimeException ) |
| { |
| return SwXAutoTextContainer_getSupportedServiceNames(); |
| } |
| /****************************************************************** |
| * |
| ******************************************************************/ |
| /* -----------------------------10.03.00 18:02-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| const uno::Sequence< sal_Int8 > & SwXAutoTextGroup::getUnoTunnelId() |
| { |
| static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId(); |
| return aSeq; |
| } |
| /* -----------------------------10.03.00 18:04-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| sal_Int64 SAL_CALL SwXAutoTextGroup::getSomething( const uno::Sequence< sal_Int8 >& rId ) |
| throw(uno::RuntimeException) |
| { |
| if( rId.getLength() == 16 |
| && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), |
| rId.getConstArray(), 16 ) ) |
| { |
| return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >( this )); |
| } |
| return 0; |
| } |
| |
| /*-- 21.12.98 12:42:24--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| SwXAutoTextGroup::SwXAutoTextGroup(const OUString& rName, |
| SwGlossaries* pGlos) : |
| pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_AUTO_TEXT_GROUP)), |
| pGlossaries(pGlos), |
| sName(rName), |
| m_sGroupName(rName) |
| { |
| DBG_ASSERT( -1 != rName.indexOf( GLOS_DELIM ), |
| "SwXAutoTextGroup::SwXAutoTextGroup: to be constructed with a complete name only!" ); |
| } |
| |
| /*-- 21.12.98 12:42:24--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| SwXAutoTextGroup::~SwXAutoTextGroup() |
| { |
| } |
| /*-- 21.12.98 12:42:24--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| /*-- 21.12.98 12:42:25--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Sequence< OUString > SwXAutoTextGroup::getTitles(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_uInt16 nCount = 0; |
| SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0; |
| if(pGlosGroup && !pGlosGroup->GetError()) |
| nCount = pGlosGroup->GetCount(); |
| else |
| throw uno::RuntimeException(); |
| |
| uno::Sequence< OUString > aEntryTitles(nCount); |
| OUString *pArr = aEntryTitles.getArray(); |
| |
| for ( sal_uInt16 i = 0; i < nCount; i++ ) |
| pArr[i] = pGlosGroup->GetLongName(i); |
| delete pGlosGroup; |
| return aEntryTitles; |
| } |
| /*-- 21.12.98 12:42:25--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextGroup::renameByName(const OUString& aElementName, |
| const OUString& aNewElementName, const OUString& aNewElementTitle) |
| throw( lang::IllegalArgumentException, container::ElementExistException, io::IOException, |
| uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| // throw exception only if the programmatic name is to be changed into an existing name |
| if(aNewElementName != aElementName && hasByName(aNewElementName)) |
| throw container::ElementExistException(); |
| SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0; |
| if(pGlosGroup && !pGlosGroup->GetError()) |
| { |
| sal_uInt16 nIdx = pGlosGroup->GetIndex( aElementName); |
| if(USHRT_MAX == nIdx) |
| throw lang::IllegalArgumentException(); |
| String aNewShort( aNewElementName); |
| String aNewName( aNewElementTitle); |
| sal_uInt16 nOldLongIdx = pGlosGroup->GetLongIndex( aNewShort ); |
| sal_uInt16 nOldIdx = pGlosGroup->GetIndex( aNewName ); |
| |
| if( nIdx != USHRT_MAX && |
| (nOldLongIdx == USHRT_MAX || nOldLongIdx == nIdx )&& |
| (nOldIdx == USHRT_MAX || nOldIdx == nIdx )) |
| { |
| pGlosGroup->Rename( nIdx, &aNewShort, &aNewName ); |
| if(pGlosGroup->GetError() != 0) |
| throw io::IOException(); |
| } |
| delete pGlosGroup; |
| } |
| else |
| throw uno::RuntimeException(); |
| } |
| |
| sal_Bool lcl_CopySelToDoc( SwDoc* pInsDoc, OTextCursorHelper* pxCursor, SwXTextRange* pxRange) |
| { |
| ASSERT( pInsDoc, "kein Ins.Dokument" ); |
| |
| SwNodes& rNds = pInsDoc->GetNodes(); |
| |
| SwNodeIndex aIdx( rNds.GetEndOfContent(), -1 ); |
| SwCntntNode * pNd = aIdx.GetNode().GetCntntNode(); |
| SwPosition aPos( aIdx, SwIndex( pNd, pNd->Len() )); |
| |
| bool bRet = false; |
| pInsDoc->LockExpFlds(); |
| { |
| SwDoc *const pDoc((pxCursor) ? pxCursor->GetDoc() : pxRange->GetDoc()); |
| SwPaM aPam(pDoc->GetNodes()); |
| SwPaM * pPam(0); |
| if(pxCursor) |
| { |
| pPam = pxCursor->GetPaM(); |
| } |
| else |
| { |
| if (pxRange->GetPositions(aPam)) |
| { |
| pPam = & aPam; |
| } |
| } |
| if (!pPam) { return false; } |
| bRet = pDoc->CopyRange( *pPam, aPos, false ) || bRet; |
| } |
| |
| pInsDoc->UnlockExpFlds(); |
| if( !pInsDoc->IsExpFldsLocked() ) |
| pInsDoc->UpdateExpFlds(NULL, true); |
| |
| return bRet; |
| } |
| /*-- 21.12.98 12:42:25--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< text::XAutoTextEntry > SwXAutoTextGroup::insertNewByName(const OUString& aName, |
| const OUString& aTitle, const uno::Reference< text::XTextRange > & xTextRange) |
| throw( container::ElementExistException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(hasByName(aName)) |
| throw container::ElementExistException(); |
| if(!xTextRange.is()) |
| throw uno::RuntimeException(); |
| |
| SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0; |
| String sShortName(aName); |
| String sLongName(aTitle); |
| if(pGlosGroup && !pGlosGroup->GetError()) |
| { |
| /*if( pGlosGroup->IsOld() && pGlosGroup->ConvertToNew()) |
| { |
| throw uno::RuntimeException(); |
| } */ |
| uno::Reference<lang::XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY); |
| SwXTextRange* pxRange = 0; |
| OTextCursorHelper* pxCursor = 0; |
| if(xRangeTunnel.is()) |
| { |
| pxRange = reinterpret_cast<SwXTextRange*>(xRangeTunnel->getSomething( |
| SwXTextRange::getUnoTunnelId())); |
| pxCursor = reinterpret_cast<OTextCursorHelper*>(xRangeTunnel->getSomething( |
| OTextCursorHelper::getUnoTunnelId())); |
| } |
| |
| String sOnlyTxt; |
| String* pOnlyTxt = 0; |
| sal_Bool bNoAttr = !pxCursor && !pxRange; |
| if(bNoAttr) |
| { |
| sOnlyTxt = UniString(xTextRange->getString()); |
| pOnlyTxt = &sOnlyTxt; |
| } |
| |
| const SvxAutoCorrCfg* pCfg = SvxAutoCorrCfg::Get(); |
| |
| SwDoc* pGDoc = pGlosGroup->GetDoc(); |
| |
| // Bis es eine Option dafuer gibt, base util::URL loeschen |
| if(pCfg->IsSaveRelFile()) |
| { |
| INetURLObject aTemp(pGlosGroup->GetFileName()); |
| pGlosGroup->SetBaseURL( aTemp.GetMainURL(INetURLObject::NO_DECODE)); |
| } |
| else |
| pGlosGroup->SetBaseURL( aEmptyStr ); |
| |
| sal_uInt16 nRet; |
| if( pOnlyTxt ) |
| nRet = pGlosGroup->PutText( sShortName, sLongName, *pOnlyTxt ); |
| else |
| { |
| pGlosGroup->ClearDoc(); |
| if( pGlosGroup->BeginPutDoc( sShortName, sLongName ) ) |
| { |
| pGDoc->SetRedlineMode_intern( nsRedlineMode_t::REDLINE_DELETE_REDLINES ); |
| lcl_CopySelToDoc( pGDoc, pxCursor, pxRange ); |
| pGDoc->SetRedlineMode_intern((RedlineMode_t)( 0 )); |
| nRet = pGlosGroup->PutDoc(); |
| } |
| else |
| nRet = (sal_uInt16) -1; |
| } |
| |
| if(nRet == (sal_uInt16) -1 ) |
| { |
| throw uno::RuntimeException(); |
| } |
| pGlossaries->PutGroupDoc( pGlosGroup ); |
| } |
| |
| uno::Reference< text::XAutoTextEntry > xEntry = pGlossaries->GetAutoTextEntry( m_sGroupName, sName, sShortName, true ); |
| DBG_ASSERT( xEntry.is(), "SwXAutoTextGroup::insertNewByName: no UNO object created? How this?" ); |
| // we just inserted the entry into the group, so why doesn't it exist? |
| |
| return xEntry; |
| } |
| /*-- 21.12.98 12:42:25--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextGroup::removeByName(const OUString& aEntryName) throw( container::NoSuchElementException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0; |
| if(pGlosGroup && !pGlosGroup->GetError()) |
| { |
| sal_uInt16 nIdx = pGlosGroup->GetIndex(aEntryName); |
| if ( nIdx != USHRT_MAX ) |
| pGlosGroup->Delete(nIdx); |
| delete pGlosGroup; |
| } |
| else |
| throw container::NoSuchElementException(); |
| } |
| /*-- 21.12.98 12:42:25--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| OUString SwXAutoTextGroup::getName(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| return sName; |
| } |
| /*-- 21.12.98 12:42:25--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextGroup::setName(const OUString& rName) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if( !pGlossaries ) |
| throw uno::RuntimeException(); |
| |
| sal_Int32 nNewDelimPos = rName.lastIndexOf( GLOS_DELIM ); |
| sal_Int32 nOldDelimPos = sName.lastIndexOf( GLOS_DELIM ); |
| |
| OUString aNewSuffix; |
| if (nNewDelimPos > -1) |
| aNewSuffix = rName.copy( nNewDelimPos + 1 ); |
| OUString aOldSuffix; |
| if (nOldDelimPos > -1) |
| aOldSuffix = sName.copy( nOldDelimPos + 1 ); |
| |
| sal_Int32 nNewNumeric = aNewSuffix.toInt32(); |
| sal_Int32 nOldNumeric = aOldSuffix.toInt32(); |
| |
| OUString aNewPrefix( (nNewDelimPos > 1) ? rName.copy( 0, nNewDelimPos ) : rName ); |
| OUString aOldPrefix( (nOldDelimPos > 1) ? sName.copy( 0, nOldDelimPos ) : sName ); |
| |
| if ( sName == rName || |
| ( nNewNumeric == nOldNumeric && aNewPrefix == aOldPrefix ) ) |
| return; |
| String sNewGroup(rName); |
| if(STRING_NOTFOUND == sNewGroup.Search(GLOS_DELIM)) |
| { |
| sNewGroup += GLOS_DELIM; |
| sNewGroup += UniString::CreateFromInt32(0); |
| } |
| |
| //the name must be saved, the group may be invalidated while in RenameGroupDoc() |
| SwGlossaries* pTempGlossaries = pGlossaries; |
| |
| String sPreserveTitle( pGlossaries->GetGroupTitle( sName ) ); |
| if ( !pGlossaries->RenameGroupDoc( sName, sNewGroup, sPreserveTitle ) ) |
| throw uno::RuntimeException(); |
| else |
| { |
| sName = rName; |
| m_sGroupName = sNewGroup; |
| pGlossaries = pTempGlossaries; |
| } |
| } |
| /*-- 21.12.98 12:42:26--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Int32 SwXAutoTextGroup::getCount(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| int nCount = 0; |
| SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0; |
| if(pGlosGroup && !pGlosGroup->GetError()) |
| nCount = pGlosGroup->GetCount(); |
| else |
| throw uno::RuntimeException(); |
| delete pGlosGroup; |
| return nCount; |
| } |
| /*-- 21.12.98 12:42:26--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Any SwXAutoTextGroup::getByIndex(sal_Int32 nIndex) |
| throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| uno::Any aRet; |
| sal_uInt16 nCount = 0; |
| SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0; |
| if(pGlosGroup && !pGlosGroup->GetError()) |
| nCount = pGlosGroup->GetCount(); |
| else |
| throw uno::RuntimeException(); |
| if(0 <= nIndex && nIndex < nCount) |
| aRet = getByName(pGlosGroup->GetShortName((sal_uInt16) nIndex)); |
| else |
| throw lang::IndexOutOfBoundsException(); |
| delete pGlosGroup; |
| return aRet; |
| } |
| /*-- 21.12.98 12:42:26--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Type SwXAutoTextGroup::getElementType(void) throw( uno::RuntimeException ) |
| { |
| return ::getCppuType((uno::Reference<text::XAutoTextEntry>*)0); |
| |
| } |
| /*-- 21.12.98 12:42:26--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXAutoTextGroup::hasElements(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0; |
| sal_uInt16 nCount = 0; |
| if(pGlosGroup && !pGlosGroup->GetError()) |
| nCount = pGlosGroup->GetCount(); |
| else |
| throw uno::RuntimeException(); |
| delete pGlosGroup; |
| return nCount > 0; |
| |
| } |
| /*-- 21.12.98 12:42:27--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Any SwXAutoTextGroup::getByName(const OUString& _rName) |
| throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| uno::Reference< text::XAutoTextEntry > xEntry = pGlossaries->GetAutoTextEntry( m_sGroupName, sName, _rName, true ); |
| DBG_ASSERT( xEntry.is(), "SwXAutoTextGroup::getByName: GetAutoTextEntry is fractious!" ); |
| // we told it to create the object, so why didn't it? |
| return makeAny( xEntry ); |
| } |
| /*-- 21.12.98 12:42:27--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Sequence< OUString > SwXAutoTextGroup::getElementNames(void) |
| throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_uInt16 nCount = 0; |
| SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0; |
| if(pGlosGroup && !pGlosGroup->GetError()) |
| nCount = pGlosGroup->GetCount(); |
| else |
| throw uno::RuntimeException(); |
| |
| uno::Sequence< OUString > aEntryNames(nCount); |
| OUString *pArr = aEntryNames.getArray(); |
| |
| for ( sal_uInt16 i = 0; i < nCount; i++ ) |
| pArr[i] = pGlosGroup->GetShortName(i); |
| delete pGlosGroup; |
| return aEntryNames; |
| } |
| /*-- 21.12.98 12:42:27--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXAutoTextGroup::hasByName(const OUString& rName) |
| throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| sal_uInt16 nCount = 0; |
| SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0; |
| if(pGlosGroup && !pGlosGroup->GetError()) |
| nCount = pGlosGroup->GetCount(); |
| else |
| throw uno::RuntimeException(); |
| |
| for( sal_uInt16 i = 0; i < nCount; i++ ) |
| { |
| String sCompare(pGlosGroup->GetShortName(i)); |
| if(COMPARE_EQUAL == sCompare.CompareIgnoreCaseToAscii(String(rName))) |
| { |
| bRet = sal_True; |
| break; |
| } |
| } |
| delete pGlosGroup; |
| return bRet; |
| } |
| |
| /*-- 09.02.00 15:33:30--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< beans::XPropertySetInfo > SwXAutoTextGroup::getPropertySetInfo(void) |
| throw( uno::RuntimeException ) |
| { |
| static uno::Reference< beans::XPropertySetInfo > xRet = pPropSet->getPropertySetInfo(); |
| return xRet; |
| } |
| /*-- 09.02.00 15:33:31--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextGroup::setPropertyValue( |
| const OUString& rPropertyName, const uno::Any& aValue) |
| throw( beans::UnknownPropertyException, beans::PropertyVetoException, |
| lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName ); |
| |
| if(!pEntry) |
| throw beans::UnknownPropertyException(); |
| |
| SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0; |
| if(!pGlosGroup || pGlosGroup->GetError()) |
| throw uno::RuntimeException(); |
| switch(pEntry->nWID) |
| { |
| case WID_GROUP_TITLE: |
| { |
| OUString sNewTitle; |
| aValue >>= sNewTitle; |
| if(!sNewTitle.getLength()) |
| throw lang::IllegalArgumentException(); |
| sal_Bool bChanged = !sNewTitle.equals(pGlosGroup->GetName()); |
| pGlosGroup->SetName(sNewTitle); |
| if(bChanged && HasGlossaryList()) |
| GetGlossaryList()->ClearGroups(); |
| } |
| break; |
| } |
| delete pGlosGroup; |
| } |
| /*-- 09.02.00 15:33:31--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Any SwXAutoTextGroup::getPropertyValue(const OUString& rPropertyName) |
| throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName); |
| |
| if(!pEntry) |
| throw beans::UnknownPropertyException(); |
| SwTextBlocks* pGlosGroup = pGlossaries ? pGlossaries->GetGroupDoc(m_sGroupName, sal_False) : 0; |
| if(!pGlosGroup || pGlosGroup->GetError()) |
| throw uno::RuntimeException(); |
| |
| uno::Any aAny; |
| switch(pEntry->nWID) |
| { |
| case WID_GROUP_PATH: |
| aAny <<= OUString(pGlosGroup->GetFileName()); |
| break; |
| case WID_GROUP_TITLE: |
| aAny <<= OUString(pGlosGroup->GetName()); |
| break; |
| } |
| delete pGlosGroup; |
| return aAny; |
| } |
| /*-- 09.02.00 15:33:31--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextGroup::addPropertyChangeListener( |
| const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) |
| throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException ) |
| { |
| } |
| /*-- 09.02.00 15:33:31--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextGroup::removePropertyChangeListener( |
| const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) |
| throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException ) |
| { |
| } |
| /*-- 09.02.00 15:33:32--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextGroup::addVetoableChangeListener( |
| const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) |
| throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException ) |
| { |
| } |
| /*-- 09.02.00 15:33:32--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextGroup::removeVetoableChangeListener( |
| const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) |
| throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException ) |
| { |
| } |
| /*-- 21.12.98 12:42:27--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextGroup::Invalidate() |
| { |
| pGlossaries = 0; |
| sName = aEmptyStr; |
| m_sGroupName = aEmptyStr; |
| } |
| /* -----------------------------06.04.00 11:11-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| OUString SwXAutoTextGroup::getImplementationName(void) throw( uno::RuntimeException ) |
| { |
| return C2U("SwXAutoTextGroup"); |
| } |
| /* -----------------------------06.04.00 11:11-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| sal_Bool SwXAutoTextGroup::supportsService(const OUString& rServiceName) throw( uno::RuntimeException ) |
| { |
| return C2U("com.sun.star.text.AutoTextGroup") == rServiceName; |
| } |
| /* -----------------------------06.04.00 11:11-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| uno::Sequence< OUString > SwXAutoTextGroup::getSupportedServiceNames(void) throw( uno::RuntimeException ) |
| { |
| uno::Sequence< OUString > aRet(1); |
| OUString* pArray = aRet.getArray(); |
| pArray[0] = C2U("com.sun.star.text.AutoTextGroup"); |
| return aRet; |
| } |
| /****************************************************************** |
| * |
| ******************************************************************/ |
| /* -----------------------------10.03.00 18:02-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| const uno::Sequence< sal_Int8 > & SwXAutoTextEntry::getUnoTunnelId() |
| { |
| static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId(); |
| return aSeq; |
| } |
| /* -----------------------------10.03.00 18:04-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| sal_Int64 SAL_CALL SwXAutoTextEntry::getSomething( const uno::Sequence< sal_Int8 >& rId ) |
| throw(uno::RuntimeException) |
| { |
| if( rId.getLength() == 16 |
| && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), |
| rId.getConstArray(), 16 ) ) |
| { |
| return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >( this )); |
| } |
| return 0; |
| } |
| /*-- 21.12.98 12:42:33--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| SwXAutoTextEntry::SwXAutoTextEntry(SwGlossaries* pGlss, const String& rGroupName, |
| const String& rEntryName) : |
| pGlossaries(pGlss), |
| sGroupName(rGroupName), |
| sEntryName(rEntryName), |
| pBodyText ( NULL ) |
| { |
| } |
| /*-- 21.12.98 12:42:33--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| SwXAutoTextEntry::~SwXAutoTextEntry() |
| { |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| |
| // ensure that any pending modifications are written |
| implFlushDocument( true ); |
| |
| //! Bug #96559 |
| // DocShell must be cleared before mutex is lost. |
| // Needs to be done explicitly since xDocSh is a class member. |
| // Thus, an own block here, guarded by the SolarMutex |
| } |
| } |
| |
| //--------------------------------------------------------------------- |
| //--- 03.03.2003 13:24:58 ----------------------------------------------- |
| |
| void SwXAutoTextEntry::implFlushDocument( bool _bCloseDoc ) |
| { |
| if ( xDocSh.Is() ) |
| { |
| if ( xDocSh->GetDoc()->IsModified () ) |
| xDocSh->Save(); |
| |
| if ( _bCloseDoc ) |
| { |
| // stop listening at the document |
| EndListening( *&xDocSh ); |
| |
| xDocSh->DoClose(); |
| xDocSh.Clear(); |
| } |
| } |
| } |
| |
| //----------------------------------------------------------------------- |
| //--- 03.03.2003 15:51:52 ----------------------------------------------- |
| |
| void SwXAutoTextEntry::Notify( SfxBroadcaster& _rBC, const SfxHint& _rHint ) |
| { |
| if ( &_rBC == &xDocSh ) |
| { // it's our document |
| if ( _rHint.ISA( SfxSimpleHint ) ) |
| { |
| if ( SFX_HINT_DEINITIALIZING == static_cast< const SfxSimpleHint& >( _rHint ).GetId() ) |
| { |
| // our document is dying (possibly because we're shuting down, and the document was notified |
| // earlier than we are?) |
| // stop listening at the docu |
| EndListening( *&xDocSh ); |
| // and release our reference |
| xDocSh.Clear(); |
| } |
| } |
| else if(_rHint.ISA(SfxEventHint)) |
| { |
| if(SFX_EVENT_PREPARECLOSEDOC == static_cast< const SfxEventHint& >( _rHint ).GetEventId()) |
| { |
| implFlushDocument( sal_False ); |
| xBodyText = 0; |
| xDocSh.Clear(); |
| } |
| } |
| } |
| } |
| |
| void SwXAutoTextEntry::GetBodyText () |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| |
| xDocSh = pGlossaries->EditGroupDoc ( sGroupName, sEntryName, sal_False ); |
| DBG_ASSERT( xDocSh.Is(), "SwXAutoTextEntry::GetBodyText: unexpected: no doc returned by EditGroupDoc!" ); |
| |
| // start listening at the document |
| StartListening( *&xDocSh ); |
| |
| pBodyText = new SwXBodyText ( xDocSh->GetDoc() ); |
| xBodyText = uno::Reference < lang::XServiceInfo > ( *pBodyText, uno::UNO_QUERY); |
| } |
| |
| uno::Reference< text::XTextCursor > SwXAutoTextEntry::createTextCursor(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| EnsureBodyText(); |
| return pBodyText->createTextCursor(); |
| } |
| /*-- 21.12.98 12:42:34--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< text::XTextCursor > SwXAutoTextEntry::createTextCursorByRange( |
| const uno::Reference< text::XTextRange > & aTextPosition) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| EnsureBodyText(); |
| return pBodyText->createTextCursorByRange ( aTextPosition ); |
| } |
| /*-- 21.12.98 12:42:34--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextEntry::insertString(const uno::Reference< text::XTextRange > & xRange, const OUString& aString, sal_Bool bAbsorb) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| EnsureBodyText(); |
| pBodyText->insertString ( xRange, aString, bAbsorb ); |
| } |
| /*-- 21.12.98 12:42:34--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextEntry::insertControlCharacter(const uno::Reference< text::XTextRange > & xRange, |
| sal_Int16 nControlCharacter, sal_Bool bAbsorb) |
| throw( lang::IllegalArgumentException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| EnsureBodyText(); |
| pBodyText->insertControlCharacter ( xRange, nControlCharacter, bAbsorb ); |
| } |
| /*-- 21.12.98 12:42:34--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextEntry::insertTextContent( |
| const uno::Reference< text::XTextRange > & xRange, |
| const uno::Reference< text::XTextContent > & xContent, sal_Bool bAbsorb) |
| throw( lang::IllegalArgumentException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| EnsureBodyText(); |
| pBodyText->insertTextContent ( xRange, xContent, bAbsorb ); |
| } |
| /*-- 21.12.98 12:42:34--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextEntry::removeTextContent( |
| const uno::Reference< text::XTextContent > & xContent) |
| throw( container::NoSuchElementException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| EnsureBodyText(); |
| pBodyText->removeTextContent ( xContent ); |
| } |
| /*-- 21.12.98 12:42:35--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< text::XText > SwXAutoTextEntry::getText(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| uno::Reference< text::XText > xRet = (text::XText*)this; |
| return xRet; |
| } |
| /*-- 21.12.98 12:42:35--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< text::XTextRange > SwXAutoTextEntry::getStart(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| EnsureBodyText(); |
| return pBodyText->getStart(); |
| } |
| /*-- 21.12.98 12:42:36--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< text::XTextRange > SwXAutoTextEntry::getEnd(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| EnsureBodyText(); |
| return pBodyText->getEnd(); |
| } |
| /*-- 21.12.98 12:42:36--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| OUString SwXAutoTextEntry::getString(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| EnsureBodyText(); |
| return pBodyText->getString(); |
| } |
| /*-- 21.12.98 12:42:36--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXAutoTextEntry::setString(const OUString& aString) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| EnsureBodyText(); |
| pBodyText->setString( aString ); |
| } |
| /* -----------------15.07.99 10:11------------------- |
| |
| --------------------------------------------------*/ |
| void SwXAutoTextEntry::applyTo(const uno::Reference< text::XTextRange > & xTextRange)throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| |
| // ensure that any pending modifications are written |
| // reason is that we're holding the _copy_ of the auto text, while the real auto text |
| // is stored somewhere. And below, we're not working with our copy, but only tell the target |
| // TextRange to work with the stored version. |
| // #96380# - 2003-03-03 - fs@openoffice.org |
| implFlushDocument( false ); |
| // TODO: think about if we should pass "true" here |
| // The difference would be that when the next modification is made to this instance here, then |
| // we would be forced to open the document again, instead of working on our current copy. |
| // This means that we would reflect any changes which were done to the AutoText by foreign instances |
| // in the meantime |
| |
| uno::Reference<lang::XUnoTunnel> xTunnel( xTextRange, uno::UNO_QUERY); |
| SwXTextRange* pRange = 0; |
| OTextCursorHelper* pCursor = 0; |
| SwXText *pText = 0; |
| |
| if(xTunnel.is()) |
| { |
| pRange = reinterpret_cast < SwXTextRange* > |
| ( xTunnel->getSomething( SwXTextRange::getUnoTunnelId() ) ); |
| pCursor = reinterpret_cast < OTextCursorHelper*> |
| ( xTunnel->getSomething( OTextCursorHelper::getUnoTunnelId() ) ); |
| pText = reinterpret_cast < SwXText* > |
| ( xTunnel->getSomething( SwXText::getUnoTunnelId() ) ); |
| } |
| |
| SwDoc* pDoc = 0; |
| if (pRange) |
| pDoc = pRange->GetDoc(); |
| else if ( pCursor ) |
| pDoc = pCursor->GetDoc(); |
| else if ( pText && pText->GetDoc() ) |
| { |
| xTunnel = uno::Reference < lang::XUnoTunnel > (pText->getStart(), uno::UNO_QUERY); |
| if (xTunnel.is()) |
| { |
| pCursor = reinterpret_cast < OTextCursorHelper* > |
| ( xTunnel->getSomething( OTextCursorHelper::getUnoTunnelId() ) ); |
| if (pCursor) |
| pDoc = pText->GetDoc(); |
| } |
| } |
| |
| if(!pDoc) |
| throw uno::RuntimeException(); |
| |
| SwPaM InsertPaM(pDoc->GetNodes()); |
| if (pRange) |
| { |
| if (!pRange->GetPositions(InsertPaM)) |
| { |
| throw uno::RuntimeException(); |
| } |
| } |
| else |
| { |
| InsertPaM = *pCursor->GetPaM(); |
| } |
| |
| ::std::auto_ptr<SwTextBlocks> pBlock(pGlossaries->GetGroupDoc(sGroupName)); |
| const bool bResult = pBlock.get() && !pBlock->GetError() |
| && pDoc->InsertGlossary( *pBlock, sEntryName, InsertPaM); |
| |
| if(!bResult) |
| throw uno::RuntimeException(); |
| } |
| /* -----------------------------06.04.00 11:11-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| OUString SwXAutoTextEntry::getImplementationName(void) throw( uno::RuntimeException ) |
| { |
| return C2U("SwXAutoTextEntry"); |
| } |
| /* -----------------------------06.04.00 11:11-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| sal_Bool SwXAutoTextEntry::supportsService(const OUString& rServiceName) throw( uno::RuntimeException ) |
| { |
| return C2U("com.sun.star.text.AutoTextEntry") == rServiceName; |
| } |
| /* -----------------------------06.04.00 11:11-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| uno::Sequence< OUString > SwXAutoTextEntry::getSupportedServiceNames(void) throw( uno::RuntimeException ) |
| { |
| uno::Sequence< OUString > aRet(1); |
| OUString* pArray = aRet.getArray(); |
| pArray[0] = C2U("com.sun.star.text.AutoTextEntry"); |
| return aRet; |
| } |
| /* -----------------------------06.04.00 11:11-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| uno::Reference< container::XNameReplace > SwXAutoTextEntry::getEvents() |
| throw( uno::RuntimeException ) |
| { |
| return new SwAutoTextEventDescriptor( *this ); |
| } |
| /* -----------------------------30.01.01 18:40-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| const struct SvEventDescription aAutotextEvents[] = |
| { |
| { SW_EVENT_START_INS_GLOSSARY, "OnInsertStart" }, |
| { SW_EVENT_END_INS_GLOSSARY, "OnInsertDone" }, |
| { 0, NULL } |
| }; |
| |
| /* -----------------------------30.01.01 18:40-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| SwAutoTextEventDescriptor::SwAutoTextEventDescriptor( |
| SwXAutoTextEntry& rAutoText ) : |
| SvBaseEventDescriptor(aAutotextEvents), |
| sSwAutoTextEventDescriptor(RTL_CONSTASCII_USTRINGPARAM( |
| "SwAutoTextEventDescriptor")), |
| rAutoTextEntry(rAutoText) |
| { |
| } |
| /* -----------------------------30.01.01 18:40-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| SwAutoTextEventDescriptor::~SwAutoTextEventDescriptor() |
| { |
| } |
| /* -----------------------------30.01.01 18:40-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| OUString SwAutoTextEventDescriptor::getImplementationName() |
| throw( uno::RuntimeException ) |
| { |
| return sSwAutoTextEventDescriptor; |
| } |
| /* -----------------------------30.01.01 18:40-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SwAutoTextEventDescriptor::replaceByName( |
| const sal_uInt16 nEvent, |
| const SvxMacro& rMacro) |
| throw( |
| lang::IllegalArgumentException, |
| container::NoSuchElementException, |
| lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| DBG_ASSERT( NULL != rAutoTextEntry.GetGlossaries(), |
| "Strangely enough, the AutoText vanished!" ); |
| DBG_ASSERT( (nEvent == SW_EVENT_END_INS_GLOSSARY) || |
| (nEvent == SW_EVENT_START_INS_GLOSSARY) , |
| "Unknown event ID" ); |
| |
| const SwGlossaries* pGlossaries = rAutoTextEntry.GetGlossaries(); |
| SwTextBlocks* pBlocks = |
| pGlossaries->GetGroupDoc( rAutoTextEntry.GetGroupName() ); |
| DBG_ASSERT( NULL != pBlocks, |
| "can't get autotext group; SwAutoTextEntry has illegal name?"); |
| |
| if( pBlocks && !pBlocks->GetError()) |
| { |
| sal_uInt16 nIndex = pBlocks->GetIndex( rAutoTextEntry.GetEntryName() ); |
| if( nIndex != USHRT_MAX ) |
| { |
| SvxMacroTableDtor aMacroTable; |
| if( pBlocks->GetMacroTable( nIndex, aMacroTable ) ) |
| { |
| SvxMacro* pNewMacro = new SvxMacro(rMacro); |
| aMacroTable.Replace( nEvent, pNewMacro ); |
| pBlocks->SetMacroTable( nIndex, aMacroTable ); |
| } |
| } |
| |
| delete pBlocks; |
| } |
| // else: ignore |
| } |
| /* -----------------------------30.01.01 18:40-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SwAutoTextEventDescriptor::getByName( |
| SvxMacro& rMacro, |
| const sal_uInt16 nEvent ) |
| throw( |
| container::NoSuchElementException, |
| lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| DBG_ASSERT( NULL != rAutoTextEntry.GetGlossaries(), "no AutoText" ); |
| DBG_ASSERT( (nEvent == SW_EVENT_END_INS_GLOSSARY) || |
| (nEvent == SW_EVENT_START_INS_GLOSSARY) , |
| "Unknown event ID" ); |
| |
| const SwGlossaries* pGlossaries = rAutoTextEntry.GetGlossaries(); |
| SwTextBlocks* pBlocks = |
| pGlossaries->GetGroupDoc( rAutoTextEntry.GetGroupName() ); |
| DBG_ASSERT( NULL != pBlocks, |
| "can't get autotext group; SwAutoTextEntry has illegal name?"); |
| |
| // return empty macro, unless macro is found |
| OUString sEmptyStr; |
| SvxMacro aEmptyMacro(sEmptyStr, sEmptyStr); |
| rMacro = aEmptyMacro; |
| |
| if ( pBlocks && !pBlocks->GetError()) |
| { |
| sal_uInt16 nIndex = pBlocks->GetIndex( rAutoTextEntry.GetEntryName() ); |
| if( nIndex != USHRT_MAX ) |
| { |
| SvxMacroTableDtor aMacroTable; |
| if( pBlocks->GetMacroTable( nIndex, aMacroTable ) ) |
| { |
| SvxMacro *pMacro = aMacroTable.Get( nEvent ); |
| if( pMacro ) |
| rMacro = *pMacro; |
| } |
| } |
| |
| delete pBlocks; |
| } |
| } |
| |
| |
| |
| |