/************************************************************** * * 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 #include #include #ifndef __RSC //autogen #include #endif #ifndef _MSGBOX_HXX //autogen #include #endif #ifndef _MSGBOX_HXX //autogen #include #endif #include #include #include #define _SVSTDARR_STRINGS #include #include #include #include #include #include #include #include // Fehlermeldungen #include #include #include #include #include #include // fuer Undo-Ids #include #include // fuer ::GetGlossaries() #include #include #ifndef _DOCSH_HXX #include #endif #include #ifndef _DOCHDL_HRC #include #endif #ifndef _SWERROR_H #include #endif #include #ifndef _LSTBOX_HXX //autogen #include #endif #include #include "swabstdlg.hxx" #include #include using namespace ::com::sun::star; const short RET_EDIT = 100; // PUBLIC METHODES ------------------------------------------------------- struct TextBlockInfo_Impl { String sTitle; String sLongName; String sGroupName; }; typedef TextBlockInfo_Impl* TextBlockInfo_ImplPtr; SV_DECL_PTRARR_DEL( TextBlockInfoArr, TextBlockInfo_ImplPtr, 0, 4 ) SV_IMPL_PTRARR( TextBlockInfoArr, TextBlockInfo_ImplPtr ) SV_IMPL_REF( SwDocShell ) /*------------------------------------------------------------------------ Beschreibung: Dialog fuer Bearbeiten Vorlagen ------------------------------------------------------------------------*/ void SwGlossaryHdl::GlossaryDlg() { SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create(); DBG_ASSERT(pFact, "Dialogdiet fail!"); AbstractGlossaryDlg* pDlg = pFact->CreateGlossaryDlg( DLG_RENAME_GLOS, pViewFrame, this, pWrtShell); DBG_ASSERT(pDlg, "Dialogdiet fail!"); String sName, sShortName; if( RET_EDIT == pDlg->Execute() ) { sName = pDlg->GetCurrGrpName(); sShortName = pDlg->GetCurrShortName(); } delete pDlg; DELETEZ(pCurGrp); if(HasGlossaryList()) { GetGlossaryList()->ClearGroups(); } if( sName.Len() || sShortName.Len() ) rStatGlossaries.EditGroupDoc( sName, sShortName ); } /*------------------------------------------------------------------------ Beschreibung: Setzen der aktuellen Gruppe; falls aus dem Dialog gerufen, wird die Gruppe temp. erzeugt fuer einen schnelleren Zugriff ------------------------------------------------------------------------*/ void SwGlossaryHdl::SetCurGroup(const String &rGrp, sal_Bool bApi, sal_Bool bAlwaysCreateNew ) { String sGroup(rGrp); if(STRING_NOTFOUND == sGroup.Search(GLOS_DELIM) && !FindGroupName(sGroup)) { sGroup += GLOS_DELIM; sGroup += '0'; } if(pCurGrp) { sal_Bool bPathEqual = sal_False; if(!bAlwaysCreateNew) { INetURLObject aTemp( pCurGrp->GetFileName() ); String sCurBase = aTemp.getBase(); aTemp.removeSegment(); const String sCurEntryPath = aTemp.GetMainURL(INetURLObject::NO_DECODE); const SvStrings* pPathArr = rStatGlossaries.GetPathArray(); sal_uInt16 nCurrentPath = USHRT_MAX; for(sal_uInt16 nPath = 0; nPath < pPathArr->Count(); nPath++) { if(sCurEntryPath == *(*pPathArr)[nPath]) { nCurrentPath = nPath; break; } } String sPath = sGroup.GetToken(1, GLOS_DELIM); sal_uInt16 nComparePath = (sal_uInt16)sPath.ToInt32(); if(nCurrentPath == nComparePath && sGroup.GetToken(0, GLOS_DELIM) == sCurBase) bPathEqual = sal_True; } // const String aMac_Tmp(pCurGrp->GetName()); // Beim Pfadwechsel kann man sich auf den Namen nicht verlassen if(!bAlwaysCreateNew && bPathEqual // aMac_Tmp == sGroup ) return; } aCurGrp = sGroup; if(!bApi) { if(pCurGrp) { rStatGlossaries.PutGroupDoc(pCurGrp); pCurGrp = 0; } pCurGrp = rStatGlossaries.GetGroupDoc(aCurGrp, sal_True); } } /*------------------------------------------------------------------------ Beschreibung: ------------------------------------------------------------------------*/ sal_uInt16 SwGlossaryHdl::GetGroupCnt() const { return rStatGlossaries.GetGroupCnt(); } /*------------------------------------------------------------------------ Beschreibung: ------------------------------------------------------------------------*/ String SwGlossaryHdl::GetGroupName( sal_uInt16 nId, String* pTitle ) { String sRet = rStatGlossaries.GetGroupName(nId); if(pTitle) { SwTextBlocks* pGroup = rStatGlossaries.GetGroupDoc(sRet, sal_False); if(pGroup && !pGroup->GetError()) { *pTitle = pGroup->GetName(); if(!pTitle->Len()) { *pTitle = sRet.GetToken(0, GLOS_DELIM); pGroup->SetName(*pTitle); } rStatGlossaries.PutGroupDoc( pGroup ); } else sRet.Erase(); } return sRet; } /*------------------------------------------------------------------------ Beschreibung: ------------------------------------------------------------------------*/ sal_Bool SwGlossaryHdl::NewGroup(String &rGrpName, const String& rTitle) { if(STRING_NOTFOUND == rGrpName.Search(GLOS_DELIM)) FindGroupName(rGrpName); return rStatGlossaries.NewGroupDoc(rGrpName, rTitle); } /* -----------------23.11.98 13:10------------------- * Umbenennen eines Textbausteins * --------------------------------------------------*/ sal_Bool SwGlossaryHdl::RenameGroup(const String & rOld, String& rNew, const String& rNewTitle) { sal_Bool bRet = sal_False; String sOldGroup(rOld); if(STRING_NOTFOUND == rOld.Search(GLOS_DELIM)) FindGroupName(sOldGroup); if(rOld == rNew) { SwTextBlocks* pGroup = rStatGlossaries.GetGroupDoc(sOldGroup, sal_False); if(pGroup) { pGroup->SetName(rNewTitle); rStatGlossaries.PutGroupDoc( pGroup ); bRet = sal_True; } } else { String sNewGroup(rNew); if(STRING_NOTFOUND == sNewGroup.Search(GLOS_DELIM)) { sNewGroup += GLOS_DELIM; sNewGroup += '0'; } bRet = rStatGlossaries.RenameGroupDoc(sOldGroup, sNewGroup, rNewTitle); rNew = sNewGroup; } return bRet; } /* -----------------27.11.98 13:49------------------- * * --------------------------------------------------*/ sal_Bool SwGlossaryHdl::CopyOrMove( const String& rSourceGroupName, String& rSourceShortName, const String& rDestGroupName, const String& rLongName, sal_Bool bMove ) { SwTextBlocks* pSourceGroup = rStatGlossaries.GetGroupDoc(rSourceGroupName, sal_False); SwTextBlocks* pDestGroup = rStatGlossaries.GetGroupDoc(rDestGroupName, sal_False); if(pDestGroup->IsReadOnly() || (bMove && pSourceGroup->IsReadOnly()) ) return sal_False; /*if(pDestGroup->IsOld()&& 0!= pDestGroup->ConvertToNew()) return sal_False; if(bMove && pSourceGroup->IsOld() && 0 != pSourceGroup->ConvertToNew()) return sal_False;*/ //Der Index muss hier ermittelt werden, weil rSourceShortName in CopyBlock evtl veraendert wird sal_uInt16 nDeleteIdx = pSourceGroup->GetIndex( rSourceShortName ); DBG_ASSERT(USHRT_MAX != nDeleteIdx, "Eintrag nicht gefunden"); sal_uLong nRet = pSourceGroup->CopyBlock( *pDestGroup, rSourceShortName, rLongName ); if(!nRet && bMove) { // der Index muss existieren nRet = pSourceGroup->Delete( nDeleteIdx ) ? 0 : 1; } rStatGlossaries.PutGroupDoc( pSourceGroup ); rStatGlossaries.PutGroupDoc( pDestGroup ); return !nRet; } /*------------------------------------------------------------------------ Beschreibung: Loeschen einer Textbausteindatei-Gruppe ------------------------------------------------------------------------*/ sal_Bool SwGlossaryHdl::DelGroup(const String &rGrpName) { String sGroup(rGrpName); if(STRING_NOTFOUND == sGroup.Search(GLOS_DELIM)) FindGroupName(sGroup); if( rStatGlossaries.DelGroupDoc(sGroup) ) { if(pCurGrp) { const String aMac_Tmp(pCurGrp->GetName()); if(aMac_Tmp == sGroup) DELETEZ(pCurGrp); } return sal_True; } return sal_False; } /*------------------------------------------------------------------------ Beschreibung: Anzahl Textbausteine erfragen ------------------------------------------------------------------------*/ sal_uInt16 SwGlossaryHdl::GetGlossaryCnt() { return pCurGrp ? pCurGrp->GetCount() : 0; } /*------------------------------------------------------------------------ Beschreibung: ------------------------------------------------------------------------*/ String SwGlossaryHdl::GetGlossaryName( sal_uInt16 nId ) { ASSERT(nId < GetGlossaryCnt(), Textbausteinarray ueberindiziert.); return pCurGrp->GetLongName( nId ); } /* -----------------30.11.98 13:18------------------- * * --------------------------------------------------*/ String SwGlossaryHdl::GetGlossaryShortName(sal_uInt16 nId) { ASSERT(nId < GetGlossaryCnt(), Textbausteinarray ueberindiziert.); return pCurGrp->GetShortName( nId ); } /*------------------------------------------------------------------------ Beschreibung: Kurzname erfragen ------------------------------------------------------------------------*/ String SwGlossaryHdl::GetGlossaryShortName(const String &rName) { String sReturn; SwTextBlocks *pTmp = pCurGrp ? pCurGrp: rStatGlossaries.GetGroupDoc( aCurGrp, sal_False ); if(pTmp) { sal_uInt16 nIdx = pTmp->GetLongIndex( rName ); if( nIdx != (sal_uInt16) -1 ) sReturn = pTmp->GetShortName( nIdx ); if( !pCurGrp ) rStatGlossaries.PutGroupDoc( pTmp ); } return sReturn; } /*------------------------------------------------------------------------ Beschreibung: Kuerzel fuer Textbaustein bereits verwendet? ------------------------------------------------------------------------*/ sal_Bool SwGlossaryHdl::HasShortName(const String& rShortName) const { SwTextBlocks *pBlock = pCurGrp ? pCurGrp : rStatGlossaries.GetGroupDoc( aCurGrp ); sal_Bool bRet = pBlock->GetIndex( rShortName ) != (sal_uInt16) -1; if( !pCurGrp ) rStatGlossaries.PutGroupDoc( pBlock ); return bRet; } /* -----------------------------20.03.01 10:52-------------------------------- ---------------------------------------------------------------------------*/ sal_Bool SwGlossaryHdl::ConvertToNew(SwTextBlocks& /*rOld*/) { /*if( rOld.IsOld() ) { QueryBox aAsk( pWrtShell->GetView().GetWindow(), SW_RES( MSG_UPDATE_NEW_GLOS_FMT ) ); if( aAsk.Execute() == RET_YES ) { if( rOld.ConvertToNew() ) { InfoBox(pWrtShell->GetView().GetWindow(), SW_RES(MSG_ERR_INSERT_GLOS)).Execute(); return sal_False; } } else return sal_False; }*/ return sal_True; } /*------------------------------------------------------------------------ Beschreibung: Erzeugen eines Textbausteines ------------------------------------------------------------------------*/ sal_Bool SwGlossaryHdl::NewGlossary(const String& rName, const String& rShortName, sal_Bool bCreateGroup, sal_Bool bNoAttr) { SwTextBlocks *pTmp = pCurGrp ? pCurGrp: rStatGlossaries.GetGroupDoc( aCurGrp, bCreateGroup ); //pTmp == 0 if the AutoText path setting is wrong if(!pTmp) return sal_False; if(!ConvertToNew(*pTmp)) return sal_False; String sOnlyTxt; String* pOnlyTxt = 0; if( bNoAttr ) { if( !pWrtShell->GetSelectedText( sOnlyTxt, GETSELTXT_PARABRK_TO_ONLYCR )) return sal_False; pOnlyTxt = &sOnlyTxt; } const SvxAutoCorrCfg* pCfg = SvxAutoCorrCfg::Get(); const sal_uInt16 nSuccess = pWrtShell->MakeGlossary( *pTmp, rName, rShortName, pCfg->IsSaveRelFile(), pOnlyTxt ); if(nSuccess == (sal_uInt16) -1 ) { InfoBox(pWrtShell->GetView().GetWindow(), SW_RES(MSG_ERR_INSERT_GLOS)).Execute(); } if( !pCurGrp ) rStatGlossaries.PutGroupDoc( pTmp ); return sal_Bool( nSuccess != (sal_uInt16) -1 ); } /*------------------------------------------------------------------------ Beschreibung: Loeschen eines Textbausteines ------------------------------------------------------------------------*/ sal_Bool SwGlossaryHdl::DelGlossary(const String &rShortName) { SwTextBlocks *pGlossary = pCurGrp ? pCurGrp : rStatGlossaries.GetGroupDoc(aCurGrp); //pTmp == 0 if the AutoText path setting is wrong if(!pGlossary || !ConvertToNew(*pGlossary)) return sal_False; sal_uInt16 nIdx = pGlossary->GetIndex( rShortName ); if( nIdx != (sal_uInt16) -1 ) pGlossary->Delete( nIdx ); if( !pCurGrp ) rStatGlossaries.PutGroupDoc( pGlossary ); return sal_True; } /*------------------------------------------------------------------------ Beschreibung: Kurzform expandieren ------------------------------------------------------------------------*/ sal_Bool SwGlossaryHdl::ExpandGlossary() { ASSERT(pWrtShell->CanInsert(), illegal); SwTextBlocks *pGlossary; SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create(); DBG_ASSERT(pFact, "Dialogdiet fail!"); ::GlossaryGetCurrGroup fnGetCurrGroup = pFact->GetGlossaryCurrGroupFunc( DLG_RENAME_GLOS ); DBG_ASSERT(fnGetCurrGroup, "Dialogdiet fail!"); String sGroupName( (*fnGetCurrGroup)() ); if(STRING_NOTFOUND == sGroupName.Search(GLOS_DELIM)) FindGroupName(sGroupName); pGlossary = rStatGlossaries.GetGroupDoc(sGroupName); String aShortName; // bei Textselektion diese verwenden if(pWrtShell->SwCrsrShell::HasSelection() && !pWrtShell->IsBlockMode()) { aShortName = pWrtShell->GetSelTxt(); } else { if(pWrtShell->IsAddMode()) pWrtShell->LeaveAddMode(); else if(pWrtShell->IsBlockMode()) pWrtShell->LeaveBlockMode(); else if(pWrtShell->IsExtMode()) pWrtShell->LeaveExtMode(); // Wort selektieren pWrtShell->SelNearestWrd(); // Wort erfragen if(pWrtShell->IsSelection()) aShortName = pWrtShell->GetSelTxt(); } return pGlossary ? Expand( aShortName, &rStatGlossaries, pGlossary ) : sal_False; } sal_Bool SwGlossaryHdl::Expand( const String& rShortName, SwGlossaries *pGlossaries, SwTextBlocks *pGlossary ) { TextBlockInfoArr aFoundArr; String aShortName( rShortName ); sal_Bool bCancel = sal_False; // search for text block //#b6633427# - don't prefer current group depending on configuration setting const SvxAutoCorrCfg* pCfg = SvxAutoCorrCfg::Get(); sal_uInt16 nFound = !pCfg->IsSearchInAllCategories() ? pGlossary->GetIndex( aShortName ) : -1; // if not found then search in all groups if( nFound == (sal_uInt16) -1 ) { const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore(); SwGlossaryList* pGlossaryList = ::GetGlossaryList(); sal_uInt16 nGroupCount = pGlossaryList->GetGroupCount(); for(sal_uInt16 i = 1; i <= nGroupCount; i++) { // Gruppenname mit Pfad-Extension besorgen String sTitle; String sGroupName = pGlossaryList->GetGroupName(i - 1, sal_False, &sTitle); if(sGroupName == pGlossary->GetName()) continue; sal_uInt16 nBlockCount = pGlossaryList->GetBlockCount(i -1); if(nBlockCount) { for(sal_uInt16 j = 0; j < nBlockCount; j++) { String sEntry; String sLongName(pGlossaryList->GetBlockName(i - 1, j, sEntry)); if( rSCmp.isEqual( rShortName, sEntry )) { TextBlockInfo_Impl* pData = new TextBlockInfo_Impl; pData->sTitle = sTitle; pData->sLongName = sLongName; pData->sGroupName = sGroupName; aFoundArr.Insert(pData, aFoundArr.Count()); } } } } if( aFoundArr.Count() ) // einer wurde gefunden { pGlossaries->PutGroupDoc(pGlossary); if(1 == aFoundArr.Count()) { TextBlockInfo_Impl* pData = aFoundArr.GetObject(0); pGlossary = (SwTextBlocks *)pGlossaries->GetGroupDoc(pData->sGroupName); nFound = pGlossary->GetIndex( aShortName ); } else { SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create(); DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!"); AbstarctSwSelGlossaryDlg* pDlg = pFact->CreateSwSelGlossaryDlg( 0, aShortName, DLG_SEL_GLOS ); DBG_ASSERT(pDlg, "Dialogdiet fail!"); for(sal_uInt16 i = 0; i < aFoundArr.Count(); ++i) { TextBlockInfo_Impl* pData = aFoundArr.GetObject(i); pDlg->InsertGlos(pData->sTitle, pData->sLongName); } pDlg->SelectEntryPos(0); const sal_uInt16 nRet = RET_OK == pDlg->Execute()? pDlg->GetSelectedIdx(): LISTBOX_ENTRY_NOTFOUND; delete pDlg; if(LISTBOX_ENTRY_NOTFOUND != nRet) { TextBlockInfo_Impl* pData = aFoundArr.GetObject(nRet); pGlossary = (SwTextBlocks *)pGlossaries->GetGroupDoc(pData->sGroupName); nFound = pGlossary->GetIndex( aShortName ); } else { nFound = (sal_uInt16) -1; bCancel = sal_True; } } } } // nicht gefunden if( nFound == (sal_uInt16) -1 ) { if( !bCancel ) { pGlossaries->PutGroupDoc(pGlossary); const sal_uInt16 nMaxLen = 50; if(pWrtShell->IsSelection() && aShortName.Len() > nMaxLen) { aShortName.Erase(nMaxLen); aShortName.AppendAscii(" ..."); } String aTmp( SW_RES(STR_NOGLOS)); aTmp.SearchAndReplaceAscii("%1", aShortName); InfoBox( pWrtShell->GetView().GetWindow(), aTmp ).Execute(); } return sal_False; } else { String aLongName = pGlossary->GetLongName( nFound ); SvxMacro aStartMacro(aEmptyStr, aEmptyStr, STARBASIC); SvxMacro aEndMacro(aEmptyStr, aEmptyStr, STARBASIC); GetMacros( aShortName, aStartMacro, aEndMacro, pGlossary ); // StartAction darf nich vor HasSelection und DelRight stehen, // sonst wird der moeglich Shellwechsel verzoegert und // API-Programme wuerden dann haengenbleiben // ausserdem darf das Ereignismacro ebenfalls nicht in einer Action gerufen werden pWrtShell->StartUndo(UNDO_INSGLOSSARY); if( aStartMacro.GetMacName().Len() ) pWrtShell->ExecMacro( aStartMacro ); if(pWrtShell->HasSelection()) pWrtShell->DelLeft(); pWrtShell->StartAllAction(); // alle InputFelder zwischenspeichern SwInputFieldList aFldLst( pWrtShell, sal_True ); pWrtShell->InsertGlossary(*pGlossary, aShortName); pWrtShell->EndAllAction(); if( aEndMacro.GetMacName().Len() ) { pWrtShell->ExecMacro( aEndMacro ); } pWrtShell->EndUndo(UNDO_INSGLOSSARY); // fuer alle neuen InputFelder die Eingaben abfordern if( aFldLst.BuildSortLst() ) pWrtShell->UpdateInputFlds( &aFldLst ); } pGlossaries->PutGroupDoc(pGlossary); return sal_True; } /*------------------------------------------------------------------------ Beschreibung: Textbaustein einfuegen ------------------------------------------------------------------------*/ sal_Bool SwGlossaryHdl::InsertGlossary(const String &rName) { ASSERT(pWrtShell->CanInsert(), illegal); SwTextBlocks *pGlos = pCurGrp? pCurGrp: rStatGlossaries.GetGroupDoc(aCurGrp); if (!pGlos) return sal_False; SvxMacro aStartMacro(aEmptyStr, aEmptyStr, STARBASIC); SvxMacro aEndMacro(aEmptyStr, aEmptyStr, STARBASIC); GetMacros( rName, aStartMacro, aEndMacro, pGlos ); // StartAction darf nich vor HasSelection und DelRight stehen, // sonst wird der moeglich Shellwechsel verzoegert und // API-Programme wuerden dann haengenbleiben // ausserdem darf das Ereignismacro ebenfalls nicht in einer Action gerufen werden if( aStartMacro.GetMacName().Len() ) pWrtShell->ExecMacro( aStartMacro ); if( pWrtShell->HasSelection() ) pWrtShell->DelRight(); pWrtShell->StartAllAction(); // alle InputFelder zwischenspeichern SwInputFieldList aFldLst( pWrtShell, sal_True ); pWrtShell->InsertGlossary(*pGlos, rName); pWrtShell->EndAllAction(); if( aEndMacro.GetMacName().Len() ) { pWrtShell->ExecMacro( aEndMacro ); } // fuer alle neuen InputFelder die Eingaben abfordern if( aFldLst.BuildSortLst() ) pWrtShell->UpdateInputFlds( &aFldLst ); if(!pCurGrp) rStatGlossaries.PutGroupDoc(pGlos); return sal_True; } /*------------------------------------------------------------------------ Beschreibung: Macro setzen / erfragen ------------------------------------------------------------------------*/ void SwGlossaryHdl::SetMacros(const String& rShortName, const SvxMacro* pStart, const SvxMacro* pEnd, SwTextBlocks *pGlossary ) { SwTextBlocks *pGlos = pGlossary ? pGlossary : pCurGrp ? pCurGrp : rStatGlossaries.GetGroupDoc( aCurGrp ); SvxMacroTableDtor aMacroTbl; if( pStart ) aMacroTbl.Insert( SW_EVENT_START_INS_GLOSSARY, new SvxMacro(*pStart)); if( pEnd ) aMacroTbl.Insert( SW_EVENT_END_INS_GLOSSARY, new SvxMacro(*pEnd)); sal_uInt16 nIdx = pGlos->GetIndex( rShortName ); if( !pGlos->SetMacroTable( nIdx, aMacroTbl ) && pGlos->GetError() ) ErrorHandler::HandleError( pGlos->GetError() ); if(!pCurGrp && !pGlossary) rStatGlossaries.PutGroupDoc(pGlos); } void SwGlossaryHdl::GetMacros( const String &rShortName, SvxMacro& rStart, SvxMacro& rEnd, SwTextBlocks *pGlossary ) { SwTextBlocks *pGlos = pGlossary ? pGlossary : pCurGrp ? pCurGrp : rStatGlossaries.GetGroupDoc(aCurGrp); sal_uInt16 nIndex = pGlos->GetIndex( rShortName ); if( nIndex != USHRT_MAX ) { SvxMacroTableDtor aMacroTbl; if( pGlos->GetMacroTable( nIndex, aMacroTbl ) ) { SvxMacro *pMacro = aMacroTbl.Get( SW_EVENT_START_INS_GLOSSARY ); if( pMacro ) rStart = *pMacro; pMacro = aMacroTbl.Get( SW_EVENT_END_INS_GLOSSARY ); if( pMacro ) rEnd = *pMacro; } } if( !pCurGrp && !pGlossary ) rStatGlossaries.PutGroupDoc( pGlos ); } /*------------------------------------------------------------------------ Beschreibung: ctor, dtor ------------------------------------------------------------------------*/ SwGlossaryHdl::SwGlossaryHdl(SfxViewFrame* pVwFrm, SwWrtShell *pSh) : rStatGlossaries( *::GetGlossaries() ), aCurGrp( rStatGlossaries.GetDefName() ), pViewFrame( pVwFrm ), pWrtShell( pSh ), pCurGrp( 0 ) { } SwGlossaryHdl::~SwGlossaryHdl() { if( pCurGrp ) rStatGlossaries.PutGroupDoc( pCurGrp ); } /*------------------------------------------------------------------------ Beschreibung: Umbenennen eines Textbausteines ------------------------------------------------------------------------*/ sal_Bool SwGlossaryHdl::Rename(const String& rOldShort, const String& rNewShortName, const String& rNewName ) { sal_Bool bRet = sal_False; SwTextBlocks *pGlossary = pCurGrp ? pCurGrp : rStatGlossaries.GetGroupDoc(aCurGrp); if(pGlossary) { if(!ConvertToNew(*pGlossary)) return sal_False; sal_uInt16 nIdx = pGlossary->GetIndex( rOldShort ); sal_uInt16 nOldLongIdx = pGlossary->GetLongIndex( rNewName ); sal_uInt16 nOldIdx = pGlossary->GetIndex( rNewShortName ); if( nIdx != USHRT_MAX && (nOldLongIdx == USHRT_MAX || nOldLongIdx == nIdx )&& (nOldIdx == USHRT_MAX || nOldIdx == nIdx )) { String aNewShort( rNewShortName ); String aNewName( rNewName ); pGlossary->Rename( nIdx, &aNewShort, &aNewName ); bRet = pGlossary->GetError() == 0; } if( !pCurGrp ) rStatGlossaries.PutGroupDoc(pGlossary); } return bRet; } sal_Bool SwGlossaryHdl::IsReadOnly( const String* pGrpNm ) const { SwTextBlocks *pGlossary = 0; if (pGrpNm) pGlossary = rStatGlossaries.GetGroupDoc( *pGrpNm ); else if (pCurGrp) pGlossary = pCurGrp; else pGlossary = rStatGlossaries.GetGroupDoc(aCurGrp); sal_Bool bRet = pGlossary ? pGlossary->IsReadOnly() : sal_True; if( pGrpNm || !pCurGrp ) delete pGlossary; return bRet; } sal_Bool SwGlossaryHdl::IsOld() const { SwTextBlocks *pGlossary = pCurGrp ? pCurGrp : rStatGlossaries.GetGroupDoc(aCurGrp); sal_Bool bRet = pGlossary ? pGlossary->IsOld() : sal_False; if( !pCurGrp ) delete pGlossary; return bRet; } /*-----------------09.06.97 16:15------------------- Gruppe ohne Pfadindex finden --------------------------------------------------*/ sal_Bool SwGlossaryHdl::FindGroupName(String & rGroup) { return rStatGlossaries.FindGroupName(rGroup); } /* -----------------29.07.99 08:34------------------- --------------------------------------------------*/ sal_Bool SwGlossaryHdl::CopyToClipboard(SwWrtShell& rSh, const String& rShortName) { SwTextBlocks *pGlossary = pCurGrp ? pCurGrp : rStatGlossaries.GetGroupDoc(aCurGrp); SwTransferable* pTransfer = new SwTransferable( rSh ); /*??*/uno::Reference< datatransfer::XTransferable > xRef( pTransfer ); int nRet = pTransfer->CopyGlossary( *pGlossary, rShortName ); if( !pCurGrp ) rStatGlossaries.PutGroupDoc( pGlossary ); return 0 != nRet; } sal_Bool SwGlossaryHdl::ImportGlossaries( const String& rName ) { sal_Bool bRet = sal_False; if( rName.Len() ) { const SfxFilter* pFilter = 0; SfxMedium* pMed = new SfxMedium( rName, STREAM_READ, sal_True, 0, 0 ); SfxFilterMatcher aMatcher( String::CreateFromAscii("swriter") ); pMed->UseInteractionHandler( sal_True ); if( !aMatcher.GuessFilter( *pMed, &pFilter, sal_False ) ) { SwTextBlocks *pGlossary; pMed->SetFilter( pFilter ); Reader* pR = SwReaderWriter::GetReader( pFilter->GetUserData() ); if( pR && 0 != ( pGlossary = pCurGrp ? pCurGrp : rStatGlossaries.GetGroupDoc(aCurGrp)) ) { SwReader aReader( *pMed, rName ); if( aReader.HasGlossaries( *pR ) ) { const SvxAutoCorrCfg* pCfg = SvxAutoCorrCfg::Get(); bRet = aReader.ReadGlossaries( *pR, *pGlossary, pCfg->IsSaveRelFile() ); } } } DELETEZ(pMed); } return bRet; }