| /************************************************************** |
| * |
| * 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" |
| |
| #include <memory> |
| |
| #include <com/sun/star/container/XNamed.hpp> |
| |
| #define _SVSTDARR_STRINGS |
| #include <unotools/transliterationwrapper.hxx> |
| |
| #include <svl/svstdarr.hxx> |
| |
| #ifndef __RSC //autogen |
| #include <tools/errinf.hxx> |
| #endif |
| #include <tools/debug.hxx> |
| #include <svl/urihelper.hxx> |
| #ifndef SVTOOLS_FSTATHELPER_HXX |
| #include <svl/fstathelper.hxx> |
| #endif |
| #include <unotools/pathoptions.hxx> |
| #include <unotools/tempfile.hxx> |
| #include <swtypes.hxx> |
| #include <errhdl.hxx> // ASSERT |
| #include <uitool.hxx> |
| #include <glosdoc.hxx> |
| #include <shellio.hxx> |
| #include <swunohelper.hxx> |
| |
| #include <unoatxt.hxx> |
| #include <swerror.h> |
| #ifndef _GLOBALS_HRC |
| #include <globals.hrc> |
| #endif |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| |
| |
| // PUBLIC METHODES ------------------------------------------------------- |
| /* -----------------------------08.02.00 15:54-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| String lcl_CheckFileName( const String& rNewFilePath, |
| const String& rNewGroupName ) |
| { |
| String sRet; |
| //group name should contain only A-Z and a-z and spaces |
| for( xub_StrLen i = 0; i < rNewGroupName.Len(); i++ ) |
| { |
| sal_Unicode cChar = rNewGroupName.GetChar(i); |
| if( (cChar >= 'A' && cChar <= 'Z') || |
| (cChar >= 'a' && cChar <= 'z') || |
| (cChar >= '0' && cChar <= '9') || |
| cChar == '_' || cChar == 0x20 ) |
| { |
| sRet += cChar; |
| } |
| } |
| sRet.EraseLeadingChars(); |
| sRet.EraseTrailingChars(); |
| |
| sal_Bool bOk = sal_False; |
| if( sRet.Len() ) |
| { |
| String sTmpDir(rNewFilePath); |
| sTmpDir += INET_PATH_TOKEN; |
| sTmpDir += sRet; |
| sTmpDir += SwGlossaries::GetExtension(); |
| bOk = !FStatHelper::IsDocument( sTmpDir ); |
| } |
| |
| if( !bOk ) |
| { |
| String rSG = SwGlossaries::GetExtension(); |
| //generate generic name |
| utl::TempFile aTemp( |
| String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "group" )), |
| &rSG, &rNewFilePath ); |
| aTemp.EnableKillingFile(); |
| |
| INetURLObject aTempURL( aTemp.GetURL() ); |
| sRet = aTempURL.GetBase(); |
| } |
| return sRet; |
| } |
| /*------------------------------------------------------------------------ |
| Beschreibung: Liefert den Namen der Default-Gruppe |
| ------------------------------------------------------------------------*/ |
| |
| |
| String SwGlossaries::GetDefName() |
| { |
| return String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "standard" )); |
| |
| } |
| /*------------------------------------------------------------------------ |
| Beschreibung: Liefert die Anzahl der Textbausteingruppen |
| ------------------------------------------------------------------------*/ |
| |
| |
| sal_uInt16 SwGlossaries::GetGroupCnt() |
| { |
| return GetNameList()->Count(); |
| } |
| /*------------------------------------------------------------------------ |
| Beschreibung: Liefert den Gruppennamen |
| ------------------------------------------------------------------------*/ |
| sal_Bool SwGlossaries::FindGroupName(String & rGroup) |
| { |
| // enthaelt der Gruppenname keinen Pfad, kann hier ein passender |
| // Gruppeneintrag gesucht werden; |
| sal_uInt16 nCount = GetGroupCnt(); |
| sal_uInt16 i; |
| for(i= 0; i < nCount; i++) |
| { |
| String sTemp(GetGroupName(i)); |
| if(rGroup.Equals( sTemp.GetToken(0, GLOS_DELIM))) |
| { |
| rGroup = sTemp; |
| return sal_True; |
| } |
| } |
| //man darf zweimal suchen, denn bei mehreren Verzeichnissen koennte |
| //der caseinsensitive Name mehrfach auftreten |
| const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore(); |
| for(i = 0; i < nCount; i++) |
| { |
| String sTemp( GetGroupName( i )); |
| sal_uInt16 nPath = (sal_uInt16)sTemp.GetToken(1, GLOS_DELIM).ToInt32(); |
| |
| if( !SWUnoHelper::UCB_IsCaseSensitiveFileName( *(*m_pPathArr)[nPath] ) |
| && rSCmp.isEqual( rGroup, sTemp.GetToken( 0, GLOS_DELIM) ) ) |
| { |
| rGroup = sTemp; |
| return sal_True; |
| } |
| } |
| return sal_False; |
| } |
| /* --------------------------------------------------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| |
| String SwGlossaries::GetGroupName(sal_uInt16 nGroupId) |
| { |
| ASSERT(nGroupId < m_pGlosArr->Count(), Textbausteinarray ueberindiziert); |
| return *(*m_pGlosArr)[nGroupId]; |
| } |
| /* -----------------------------08.02.00 13:04-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| String SwGlossaries::GetGroupTitle( const String& rGroupName ) |
| { |
| String sRet; |
| String sGroup(rGroupName); |
| if(STRING_NOTFOUND == sGroup.Search(GLOS_DELIM)) |
| FindGroupName(sGroup); |
| SwTextBlocks* pGroup = GetGroupDoc(sGroup, sal_False); |
| if(pGroup) |
| { |
| sRet = pGroup->GetName(); |
| PutGroupDoc( pGroup ); |
| } |
| return sRet; |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: Liefert das Textbaustein-Dokument der Gruppe rName |
| ------------------------------------------------------------------------*/ |
| |
| SwTextBlocks* SwGlossaries::GetGroupDoc(const String &rName, |
| sal_Bool bCreate) const |
| { |
| // gfs. in die Liste der Textbausteine eintragen |
| if(bCreate && m_pGlosArr) |
| { |
| const String aName(rName); |
| const sal_uInt16 nCount = m_pGlosArr->Count(); |
| sal_uInt16 i; |
| |
| for( i = 0; i < nCount; ++i) |
| { |
| const String *pName = (*m_pGlosArr)[i]; |
| if(*pName == aName) |
| break; |
| } |
| if(i == nCount) |
| { // Baustein nicht in der Liste |
| String *pTmp = new String(aName); |
| m_pGlosArr->Insert(pTmp, m_pGlosArr->Count()); |
| } |
| } |
| return GetGlosDoc( rName, bCreate ); |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: Loeschen Textblock |
| ------------------------------------------------------------------------*/ |
| |
| void SwGlossaries::PutGroupDoc(SwTextBlocks *pBlock) { |
| delete pBlock; |
| } |
| /*------------------------------------------------------------------------ |
| Beschreibung: Erzeugt ein neues Dokument mit dem Gruppenname |
| Wird temp. auch als File angelegt, damit die |
| Gruppen auch spaeter (ohne Zugriff) vorhanden sind. |
| ------------------------------------------------------------------------*/ |
| |
| |
| sal_Bool SwGlossaries::NewGroupDoc(String& rGroupName, const String& rTitle) |
| { |
| sal_uInt16 nNewPath = (sal_uInt16)rGroupName.GetToken(1, GLOS_DELIM).ToInt32(); |
| String sNewFilePath(*(*m_pPathArr)[nNewPath]); |
| String sNewGroup = lcl_CheckFileName(sNewFilePath, rGroupName.GetToken(0, GLOS_DELIM)); |
| sNewGroup += GLOS_DELIM; |
| sNewGroup += rGroupName.GetToken(1, GLOS_DELIM); |
| SwTextBlocks *pBlock = GetGlosDoc( sNewGroup ); |
| if(pBlock) |
| { |
| String *pTmp = |
| new String(sNewGroup); |
| SvStrings* pList = GetNameList(); |
| pList->Insert(pTmp, pList->Count()); |
| pBlock->SetName(rTitle); |
| PutGroupDoc(pBlock); |
| rGroupName = sNewGroup; |
| return sal_True; |
| } |
| return sal_False; |
| } |
| /* -----------------23.11.98 13:13------------------- |
| * |
| * --------------------------------------------------*/ |
| sal_Bool SwGlossaries::RenameGroupDoc( |
| const String& rOldGroup, String& rNewGroup, const String& rNewTitle ) |
| { |
| sal_Bool bRet = sal_False; |
| sal_uInt16 nOldPath = (sal_uInt16)rOldGroup.GetToken(1, GLOS_DELIM).ToInt32(); |
| if(nOldPath < m_pPathArr->Count()) |
| { |
| String sOldFileURL(*(*m_pPathArr)[nOldPath]); |
| sOldFileURL += INET_PATH_TOKEN; |
| sOldFileURL += rOldGroup.GetToken(0, GLOS_DELIM); |
| sOldFileURL += SwGlossaries::GetExtension(); |
| sal_Bool bExist = FStatHelper::IsDocument( sOldFileURL ); |
| DBG_ASSERT(bExist, "Gruppe existiert nicht!"); |
| if(bExist) |
| { |
| sal_uInt16 nNewPath = (sal_uInt16)rNewGroup.GetToken(1, GLOS_DELIM).ToInt32(); |
| if( nNewPath < m_pPathArr->Count()) |
| { |
| String sNewFilePath(*(*m_pPathArr)[nNewPath]); |
| String sNewFileName = lcl_CheckFileName( |
| sNewFilePath, rNewGroup.GetToken(0, GLOS_DELIM)); |
| //String aTmp( rNewGroup.GetToken(0, GLOS_DELIM)); |
| const sal_uInt16 nFileNameLen = sNewFileName.Len(); |
| sNewFileName += SwGlossaries::GetExtension(); |
| String sTempNewFilePath(sNewFilePath); |
| sTempNewFilePath += INET_PATH_TOKEN; |
| sTempNewFilePath += sNewFileName ; |
| bExist = FStatHelper::IsDocument( sTempNewFilePath ); |
| DBG_ASSERT(!bExist, "Gruppe existiert bereits!"); |
| if(!bExist) |
| { |
| sal_Bool bCopyCompleted = SWUnoHelper::UCB_CopyFile( |
| sOldFileURL, sTempNewFilePath, sal_True ); |
| if(bCopyCompleted) |
| { |
| bRet = sal_True; |
| RemoveFileFromList( rOldGroup ); |
| |
| rNewGroup = sNewFileName.Copy(0, nFileNameLen); |
| rNewGroup += GLOS_DELIM; |
| rNewGroup += String::CreateFromInt32(nNewPath); |
| String *pTmp = new String(rNewGroup); |
| if(!m_pGlosArr) |
| GetNameList(); |
| else |
| m_pGlosArr->Insert(pTmp, m_pGlosArr->Count()); |
| |
| sNewFilePath += INET_PATH_TOKEN; |
| sNewFilePath += sNewFileName ; |
| SwTextBlocks* pNewBlock = new SwTextBlocks( sNewFilePath ); |
| pNewBlock->SetName(rNewTitle); |
| delete pNewBlock; |
| } |
| } |
| } |
| } |
| } |
| return bRet; |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: Loescht eine Textbausteingruppe |
| ------------------------------------------------------------------------*/ |
| |
| |
| sal_Bool SwGlossaries::DelGroupDoc(const String &rName) |
| { |
| sal_uInt16 nPath = (sal_uInt16)rName.GetToken(1, GLOS_DELIM).ToInt32(); |
| if(nPath >= m_pPathArr->Count()) |
| return sal_False; |
| String sFileURL(*(*m_pPathArr)[nPath]); |
| String aTmp( rName.GetToken(0, GLOS_DELIM)); |
| String aName(aTmp); |
| aName += GLOS_DELIM; |
| aName += String::CreateFromInt32(nPath); |
| |
| aTmp += SwGlossaries::GetExtension(); |
| sFileURL += INET_PATH_TOKEN; |
| sFileURL += aTmp; |
| // Auch, wenn das File nicht existiert, muss es aus der Liste |
| // der Textbausteinbereiche entfernt werden |
| // Kein && wegen CFfront |
| sal_Bool bRemoved = SWUnoHelper::UCB_DeleteFile( sFileURL ); |
| DBG_ASSERT(bRemoved, "file has not been removed"); |
| RemoveFileFromList( aName ); |
| return bRemoved; |
| } |
| /*------------------------------------------------------------------------ |
| Beschreibung: DTOR |
| ------------------------------------------------------------------------*/ |
| |
| |
| SwGlossaries::~SwGlossaries() |
| { |
| sal_uInt16 nCount = m_pGlosArr? m_pGlosArr->Count() : 0; |
| sal_uInt16 i; |
| |
| for( i = 0; i < nCount; ++i) |
| { |
| String *pTmp = (*m_pGlosArr)[i]; |
| delete pTmp; |
| } |
| nCount = m_pPathArr? m_pPathArr->Count() : 0; |
| for(i = 0; i < nCount; ++i) |
| { |
| String *pTmp = (*m_pPathArr)[i]; |
| delete pTmp; |
| } |
| delete m_pGlosArr; |
| delete m_pPathArr; |
| |
| InvalidateUNOOjects(); |
| } |
| /*------------------------------------------------------------------------ |
| Beschreibung: Bausteindokument einlesen |
| ------------------------------------------------------------------------*/ |
| |
| |
| SwTextBlocks* SwGlossaries::GetGlosDoc( const String &rName, sal_Bool bCreate ) const |
| { |
| sal_uInt16 nPath = (sal_uInt16)rName.GetToken(1, GLOS_DELIM).ToInt32(); |
| SwTextBlocks *pTmp = 0; |
| if(nPath < m_pPathArr->Count()) |
| { |
| String sFileURL(*(*m_pPathArr)[nPath]); |
| String aTmp( rName.GetToken(0, GLOS_DELIM)); |
| aTmp += SwGlossaries::GetExtension(); |
| sFileURL += INET_PATH_TOKEN; |
| sFileURL += aTmp; |
| |
| sal_Bool bExist = sal_False; |
| if(!bCreate) |
| bExist = FStatHelper::IsDocument( sFileURL ); |
| |
| if (bCreate || bExist) |
| { |
| pTmp = new SwTextBlocks( sFileURL ); |
| sal_Bool bOk = sal_True; |
| if( pTmp->GetError() ) |
| { |
| ErrorHandler::HandleError( pTmp->GetError() ); |
| bOk = !IsError( pTmp->GetError() ); |
| } |
| |
| if( bOk && !pTmp->GetName().Len() ) |
| pTmp->SetName( rName ); |
| } |
| } |
| |
| return pTmp; |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: Zugriff auf die Liste der Name; diese wird gfs. eingelesen |
| ------------------------------------------------------------------------*/ |
| |
| SvStrings* SwGlossaries::GetNameList() |
| { |
| if( !m_pGlosArr ) |
| { |
| m_pGlosArr = new SvStrings; |
| String sExt( SwGlossaries::GetExtension() ); |
| for( sal_uInt16 i = 0; i < m_pPathArr->Count(); i++ ) |
| { |
| SvStrings aFiles( 16, 16 ); |
| |
| SWUnoHelper::UCB_GetFileListOfFolder( *(*m_pPathArr)[i], aFiles, |
| &sExt ); |
| for( sal_uInt16 nFiles = 0, nFEnd = aFiles.Count(); |
| nFiles < nFEnd; ++nFiles ) |
| { |
| String* pTitle = aFiles[ nFiles ]; |
| String sName( pTitle->Copy( 0, pTitle->Len() - sExt.Len() )); |
| sName += GLOS_DELIM; |
| sName += String::CreateFromInt32( i ); |
| m_pGlosArr->Insert( new String(sName), m_pGlosArr->Count() ); |
| |
| // don't need any more these pointers |
| delete pTitle; |
| } |
| } |
| if(!m_pGlosArr->Count()) |
| { |
| // Der Standard-Baustein steht im ersten Teil des Pfades |
| String *pTmp = new String( SwGlossaries::GetDefName() ); |
| (*pTmp) += GLOS_DELIM; |
| (*pTmp) += '0'; |
| m_pGlosArr->Insert(pTmp, m_pGlosArr->Count()); |
| } |
| } |
| return m_pGlosArr; |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: CTOR |
| ------------------------------------------------------------------------*/ |
| |
| |
| SwGlossaries::SwGlossaries() : |
| m_pPathArr(0), |
| m_pGlosArr(0) |
| { |
| m_pPathArr = new SvStrings; |
| UpdateGlosPath(sal_True); |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: Neuen Pfad einstellen und internes Array neu aufbauen |
| ------------------------------------------------------------------------*/ |
| |
| /* -----------------21.01.99 15:36------------------- |
| * #61050# Doppelte Pfade fuehren zu Verwirrung - als raus damit |
| * --------------------------------------------------*/ |
| sal_Bool lcl_FindSameEntry(const SvStrings& rDirArr, const String& rEntryURL) |
| { |
| for(sal_uInt16 i = 0; i < rDirArr.Count(); i++) |
| if(rEntryURL == (*rDirArr.GetObject(i))) |
| return sal_True; |
| return sal_False; |
| } |
| |
| void SwGlossaries::UpdateGlosPath(sal_Bool bFull) |
| { |
| SvtPathOptions aPathOpt; |
| String aNewPath( aPathOpt.GetAutoTextPath() ); |
| sal_Bool bPathChanged = m_aPath != aNewPath; |
| if (bFull || bPathChanged) |
| { |
| m_aPath = aNewPath; |
| sal_uInt16 nCount = m_pPathArr? m_pPathArr->Count() : 0; |
| sal_uInt16 i; |
| |
| for( i = nCount; i; --i) |
| { |
| String *pTmp = (*m_pPathArr)[i - 1]; |
| m_pPathArr->Remove(i - 1); |
| delete pTmp; |
| } |
| sal_uInt16 nTokenCount = m_aPath.GetTokenCount(SVT_SEARCHPATH_DELIMITER); |
| SvStrings aDirArr; |
| for( i = 0; i < nTokenCount; i++ ) |
| { |
| String sPth(m_aPath.GetToken(i, SVT_SEARCHPATH_DELIMITER)); |
| sPth = URIHelper::SmartRel2Abs( |
| INetURLObject(), sPth, URIHelper::GetMaybeFileHdl()); |
| |
| if(i && lcl_FindSameEntry(aDirArr, sPth)) |
| { |
| continue; |
| } |
| aDirArr.Insert(new String(sPth), aDirArr.Count()); |
| if( !FStatHelper::IsFolder( sPth ) ) |
| { |
| if( m_sErrPath.Len() ) |
| m_sErrPath += SVT_SEARCHPATH_DELIMITER; |
| INetURLObject aTemp( sPth ); |
| m_sErrPath += String(aTemp.GetFull()); |
| } |
| else |
| m_pPathArr->Insert(new String(sPth), m_pPathArr->Count()); |
| } |
| aDirArr.DeleteAndDestroy(0, aDirArr.Count()); |
| |
| if(!nTokenCount || |
| (m_sErrPath.Len() && (bPathChanged || m_sOldErrPath != m_sErrPath)) ) |
| { |
| m_sOldErrPath = m_sErrPath; |
| // Falscher Pfad, d.h. AutoText-Verzeichnis existiert nicht |
| |
| ErrorHandler::HandleError( *new StringErrorInfo( |
| ERR_AUTOPATH_ERROR, m_sErrPath, |
| ERRCODE_BUTTON_OK | ERRCODE_MSG_ERROR )); |
| m_bError = sal_True; |
| } |
| else |
| m_bError = sal_False; |
| |
| if(m_pGlosArr) |
| { |
| for(i = 0; i < m_pGlosArr->Count(); ++i) |
| { |
| delete (String *)(*m_pGlosArr)[i]; |
| } |
| DELETEZ(m_pGlosArr); |
| GetNameList(); |
| } |
| } |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| |
| void SwGlossaries::ShowError() |
| { |
| sal_uInt32 nPathError = *new StringErrorInfo(ERR_AUTOPATH_ERROR, |
| m_sErrPath, ERRCODE_BUTTON_OK ); |
| ErrorHandler::HandleError( nPathError ); |
| } |
| /* -----------------------------09.02.00 11:37-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| String SwGlossaries::GetExtension() |
| { |
| return String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( ".bau" )); |
| } |
| |
| |
| |
| void SwGlossaries::RemoveFileFromList( const String& rGroup ) |
| { |
| if(m_pGlosArr) |
| { |
| const sal_uInt16 nCount = m_pGlosArr->Count(); |
| for(sal_uInt16 i = 0; i < nCount; ++i) |
| { |
| String *pTmp = (*m_pGlosArr)[i]; |
| if(*pTmp == rGroup) |
| { |
| rtl::OUString aUName = rGroup; |
| { |
| // tell the UNO AutoTextGroup object that it's not valid anymore |
| for ( UnoAutoTextGroups::iterator aLoop = m_aGlossaryGroups.begin(); |
| aLoop != m_aGlossaryGroups.end(); |
| ++aLoop |
| ) |
| { |
| Reference< container::XNamed > xNamed( aLoop->get(), UNO_QUERY ); |
| if ( xNamed.is() && ( xNamed->getName() == aUName ) ) |
| { |
| static_cast< SwXAutoTextGroup* >( xNamed.get() )->Invalidate(); |
| // note that this static_cast works because we know that the array only |
| // contains SwXAutoTextGroup implementation |
| m_aGlossaryGroups.erase( aLoop ); |
| break; |
| } |
| } |
| } |
| |
| { |
| // tell all our UNO AutoTextEntry objects that they're not valid anymore |
| for ( UnoAutoTextEntries::iterator aLoop = m_aGlossaryEntries.begin(); |
| aLoop != m_aGlossaryEntries.end(); |
| ) |
| { |
| Reference< lang::XUnoTunnel > xEntryTunnel( aLoop->get(), UNO_QUERY ); |
| |
| SwXAutoTextEntry* pEntry = NULL; |
| if ( xEntryTunnel.is() ) |
| pEntry = reinterpret_cast< SwXAutoTextEntry* >( |
| xEntryTunnel->getSomething( SwXAutoTextEntry::getUnoTunnelId() ) ); |
| |
| if ( pEntry && ( pEntry->GetGroupName() == rGroup ) ) |
| { |
| pEntry->Invalidate(); |
| aLoop = m_aGlossaryEntries.erase( aLoop ); |
| } |
| else |
| ++aLoop; |
| } |
| } |
| |
| m_pGlosArr->Remove(i); |
| delete pTmp; |
| break; |
| } |
| } |
| } |
| } |
| |
| |
| String SwGlossaries::GetCompleteGroupName( const rtl::OUString& GroupName ) |
| { |
| sal_uInt16 nCount = GetGroupCnt(); |
| //wenn der Gruppenname intern erzeugt wurde, dann steht auch hier der Pfad drin |
| String sGroup(GroupName); |
| String sGroupName(sGroup.GetToken(0, GLOS_DELIM)); |
| String sPath = sGroup.GetToken(1, GLOS_DELIM); |
| sal_Bool bPathLen = sPath.Len() > 0; |
| for ( sal_uInt16 i = 0; i < nCount; i++ ) |
| { |
| String sGrpName = GetGroupName(i); |
| if(bPathLen ? sGroup == sGrpName : sGroupName == sGrpName.GetToken(0, GLOS_DELIM)) |
| { |
| return sGrpName; |
| } |
| } |
| return aEmptyStr; |
| } |
| |
| |
| void SwGlossaries::InvalidateUNOOjects() |
| { |
| // invalidate all the AutoTextGroup-objects |
| for ( UnoAutoTextGroups::iterator aGroupLoop = m_aGlossaryGroups.begin(); |
| aGroupLoop != m_aGlossaryGroups.end(); |
| ++aGroupLoop |
| ) |
| { |
| Reference< text::XAutoTextGroup > xGroup( aGroupLoop->get(), UNO_QUERY ); |
| if ( xGroup.is() ) |
| static_cast< SwXAutoTextGroup* >( xGroup.get() )->Invalidate(); |
| } |
| UnoAutoTextGroups aTmpg = UnoAutoTextGroups(); |
| m_aGlossaryGroups.swap( aTmpg ); |
| |
| // invalidate all the AutoTextEntry-objects |
| for ( UnoAutoTextEntries::const_iterator aEntryLoop = m_aGlossaryEntries.begin(); |
| aEntryLoop != m_aGlossaryEntries.end(); |
| ++aEntryLoop |
| ) |
| { |
| Reference< lang::XUnoTunnel > xEntryTunnel( aEntryLoop->get(), UNO_QUERY ); |
| SwXAutoTextEntry* pEntry = NULL; |
| if ( xEntryTunnel.is() ) |
| pEntry = reinterpret_cast< SwXAutoTextEntry* >( |
| xEntryTunnel->getSomething( SwXAutoTextEntry::getUnoTunnelId() ) ); |
| |
| if ( pEntry ) |
| pEntry->Invalidate(); |
| } |
| UnoAutoTextEntries aTmpe = UnoAutoTextEntries(); |
| m_aGlossaryEntries.swap( aTmpe ); |
| } |
| |
| //----------------------------------------------------------------------- |
| //--- 03.03.2003 14:15:32 ----------------------------------------------- |
| |
| Reference< text::XAutoTextGroup > SwGlossaries::GetAutoTextGroup( const ::rtl::OUString& _rGroupName, bool _bCreate ) |
| { |
| // first, find the name with path-extension |
| String sCompleteGroupName = GetCompleteGroupName( _rGroupName ); |
| |
| Reference< text::XAutoTextGroup > xGroup; |
| |
| // look up the group in the cache |
| UnoAutoTextGroups::iterator aSearch = m_aGlossaryGroups.begin(); |
| for ( ; aSearch != m_aGlossaryGroups.end(); ) |
| { |
| Reference< lang::XUnoTunnel > xGroupTunnel( aSearch->get(), UNO_QUERY ); |
| |
| SwXAutoTextGroup* pSwGroup = 0; |
| if ( xGroupTunnel.is() ) |
| pSwGroup = reinterpret_cast< SwXAutoTextGroup* >( xGroupTunnel->getSomething( SwXAutoTextGroup::getUnoTunnelId() ) ); |
| |
| if ( !pSwGroup ) |
| { |
| // the object is dead in the meantime -> remove from cache |
| aSearch = m_aGlossaryGroups.erase( aSearch ); |
| continue; |
| } |
| |
| if ( _rGroupName == pSwGroup->getName() ) |
| { // the group is already cached |
| if ( sCompleteGroupName.Len() ) |
| { // the group still exists -> return it |
| xGroup = pSwGroup; |
| break; |
| } |
| else |
| { |
| // this group does not exist (anymore) -> release the cached UNO object for it |
| aSearch = m_aGlossaryGroups.erase( aSearch ); |
| // so it won't be created below |
| _bCreate = sal_False; |
| break; |
| } |
| } |
| |
| ++aSearch; |
| } |
| |
| if ( !xGroup.is() && _bCreate ) |
| { |
| xGroup = new SwXAutoTextGroup( sCompleteGroupName, this ); |
| // cache it |
| m_aGlossaryGroups.push_back( AutoTextGroupRef( xGroup ) ); |
| } |
| |
| return xGroup; |
| } |
| |
| //----------------------------------------------------------------------- |
| //--- 03.03.2003 13:46:06 ----------------------------------------------- |
| |
| Reference< text::XAutoTextEntry > SwGlossaries::GetAutoTextEntry( const String& _rCompleteGroupName, const ::rtl::OUString& _rGroupName, const ::rtl::OUString& _rEntryName, |
| bool _bCreate ) |
| { |
| //standard must be created |
| sal_Bool bCreate = ( _rCompleteGroupName == GetDefName() ); |
| ::std::auto_ptr< SwTextBlocks > pGlosGroup( GetGroupDoc( _rCompleteGroupName, bCreate ) ); |
| |
| if ( pGlosGroup.get() && !pGlosGroup->GetError() ) |
| { |
| sal_uInt16 nIdx = pGlosGroup->GetIndex( _rEntryName ); |
| if ( USHRT_MAX == nIdx ) |
| throw container::NoSuchElementException(); |
| } |
| else |
| throw lang::WrappedTargetException(); |
| |
| Reference< text::XAutoTextEntry > xReturn; |
| String sGroupName( _rGroupName ); |
| String sEntryName( _rEntryName ); |
| |
| UnoAutoTextEntries::iterator aSearch( m_aGlossaryEntries.begin() ); |
| for ( ; aSearch != m_aGlossaryEntries.end(); ) |
| { |
| Reference< lang::XUnoTunnel > xEntryTunnel( aSearch->get(), UNO_QUERY ); |
| |
| SwXAutoTextEntry* pEntry = NULL; |
| if ( xEntryTunnel.is() ) |
| pEntry = reinterpret_cast< SwXAutoTextEntry* >( xEntryTunnel->getSomething( SwXAutoTextEntry::getUnoTunnelId() ) ); |
| else |
| { |
| // the object is dead in the meantime -> remove from cache |
| aSearch = m_aGlossaryEntries.erase( aSearch ); |
| continue; |
| } |
| |
| if ( pEntry |
| && ( COMPARE_EQUAL == pEntry->GetGroupName().CompareTo( sGroupName ) ) |
| && ( COMPARE_EQUAL == pEntry->GetEntryName().CompareTo( sEntryName ) ) |
| ) |
| { |
| xReturn = pEntry; |
| break; |
| } |
| |
| ++aSearch; |
| } |
| |
| if ( !xReturn.is() && _bCreate ) |
| { |
| xReturn = new SwXAutoTextEntry( this, sGroupName, sEntryName ); |
| // cache it |
| m_aGlossaryEntries.push_back( AutoTextEntryRef( xReturn ) ); |
| } |
| |
| return xReturn; |
| } |
| |
| |
| |