sw/source/ui/misc/glosdoc.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: glosdoc.cxx,v $
  10  * $Revision: 1.23 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sw.hxx"
  33
  34 #include <memory>
  35
  36 #include <com/sun/star/container/XNamed.hpp>
  37
  38 #define _SVSTDARR_STRINGS
  39 #include <unotools/transliterationwrapper.hxx>
  40
  41 #include <svtools/svstdarr.hxx>
  42
  43 #ifndef __RSC //autogen
  44 #include <tools/errinf.hxx>
  45 #endif
  46 #include <tools/debug.hxx>
  47 #include <svtools/urihelper.hxx>
  48 #ifndef SVTOOLS_FSTATHELPER_HXX
  49 #include <svtools/fstathelper.hxx>
  50 #endif
  51 #include <svtools/pathoptions.hxx>
  52 #include <unotools/tempfile.hxx>
  53 #include <swtypes.hxx>
  54 #include <errhdl.hxx>           // ASSERT
  55 #include <uitool.hxx>
  56 #include <glosdoc.hxx>
  57 #include <shellio.hxx>
  58 #include <swunohelper.hxx>
  59
  60 #include <unoatxt.hxx>
  61 #include <swerror.h>
  62 #ifndef _GLOBALS_HRC
  63 #include <globals.hrc>
  64 #endif
  65
  66 using namespace ::com::sun::star;
  67 using namespace ::com::sun::star::uno;
  68
  69
  70 // PUBLIC METHODES -------------------------------------------------------
  71 /* -----------------------------08.02.00 15:54--------------------------------
  72
  73  ---------------------------------------------------------------------------*/
  74 String lcl_CheckFileName( const String& rNewFilePath,
  75                           const String& rNewGroupName )
  76 {
  77     String sRet;
  78     //group name should contain only A-Z and a-z and spaces
  79     for( xub_StrLen i = 0; i < rNewGroupName.Len(); i++ )
  80     {
  81         sal_Unicode cChar = rNewGroupName.GetChar(i);
  82         if(     (cChar >= 'A' && cChar <= 'Z') ||
  83             (cChar >= 'a' && cChar <= 'z') ||
  84             (cChar >= '0' && cChar <= '9') ||
  85             cChar == '_' || cChar == 0x20 )
  86         {
  87             sRet += cChar;
  88         }
  89     }
  90     sRet.EraseLeadingChars();
  91     sRet.EraseTrailingChars();
  92
  93     BOOL bOk = FALSE;
  94     if( sRet.Len() )
  95     {
  96         String sTmpDir(rNewFilePath);
  97         sTmpDir += INET_PATH_TOKEN;
  98         sTmpDir += sRet;
  99         sTmpDir += SwGlossaries::GetExtension();
 100         bOk = !FStatHelper::IsDocument( sTmpDir );
 101     }
 102
 103     if( !bOk )
 104     {
 105         String rSG = SwGlossaries::GetExtension();
 106         //generate generic name
 107         utl::TempFile aTemp(
 108             String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "group" )),
 109             &rSG, &rNewFilePath );
 110         aTemp.EnableKillingFile();
 111
 112         INetURLObject aTempURL( aTemp.GetURL() );
 113         sRet = aTempURL.GetBase();
 114     }
 115     return sRet;
 116 }
 117 /*------------------------------------------------------------------------
 118     Beschreibung: Liefert den Namen der Default-Gruppe
 119 ------------------------------------------------------------------------*/
 120
 121
 122 String  SwGlossaries::GetDefName()
 123 {
 124     return String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "standard" ));
 125
 126 }
 127 /*------------------------------------------------------------------------
 128     Beschreibung: Liefert die Anzahl der Textbausteingruppen
 129 ------------------------------------------------------------------------*/
 130
 131
 132 sal_uInt16 SwGlossaries::GetGroupCnt()
 133 {
 134     return  GetNameList()->Count();
 135 }
 136 /*------------------------------------------------------------------------
 137     Beschreibung: Liefert den Gruppennamen
 138 ------------------------------------------------------------------------*/
 139 sal_Bool SwGlossaries::FindGroupName(String & rGroup)
 140 {
 141     //  enthaelt der Gruppenname keinen Pfad, kann hier ein passender
 142     // Gruppeneintrag gesucht werden;
 143     sal_uInt16 nCount = GetGroupCnt();
 144     sal_uInt16 i;
 145     for(i= 0; i < nCount; i++)
 146     {
 147         String sTemp(GetGroupName(i));
 148         if(rGroup.Equals( sTemp.GetToken(0, GLOS_DELIM)))
 149         {
 150             rGroup = sTemp;
 151             return sal_True;
 152         }
 153     }
 154     //man darf zweimal suchen, denn bei mehreren Verzeichnissen koennte
 155     //der caseinsensitive Name mehrfach auftreten
 156     const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore();
 157     for(i = 0; i < nCount; i++)
 158     {
 159         String sTemp( GetGroupName( i ));
 160         sal_uInt16 nPath = (sal_uInt16)sTemp.GetToken(1, GLOS_DELIM).ToInt32();
 161
 162         if( !SWUnoHelper::UCB_IsCaseSensitiveFileName( *(*m_pPathArr)[nPath] )
 163              && rSCmp.isEqual( rGroup, sTemp.GetToken( 0, GLOS_DELIM) ) )
 164         {
 165             rGroup = sTemp;
 166             return sal_True;
 167         }
 168     }
 169     return sal_False;
 170 }
 171 /* ---------------------------------------------------------------------------
 172
 173  ---------------------------------------------------------------------------*/
 174
 175 String SwGlossaries::GetGroupName(sal_uInt16 nGroupId)
 176 {
 177     ASSERT(nGroupId < m_pGlosArr->Count(), Textbausteinarray ueberindiziert);
 178     return *(*m_pGlosArr)[nGroupId];
 179 }
 180 /* -----------------------------08.02.00 13:04--------------------------------
 181
 182  ---------------------------------------------------------------------------*/
 183 String  SwGlossaries::GetGroupTitle( const String& rGroupName )
 184 {
 185     String      sRet;
 186     String sGroup(rGroupName);
 187     if(STRING_NOTFOUND == sGroup.Search(GLOS_DELIM))
 188         FindGroupName(sGroup);
 189     SwTextBlocks* pGroup = GetGroupDoc(sGroup, sal_False);
 190     if(pGroup)
 191     {
 192         sRet = pGroup->GetName();
 193          PutGroupDoc( pGroup );
 194     }
 195     return sRet;
 196 }
 197
 198 /*------------------------------------------------------------------------
 199     Beschreibung: Liefert das Textbaustein-Dokument der Gruppe rName
 200 ------------------------------------------------------------------------*/
 201
 202 SwTextBlocks* SwGlossaries::GetGroupDoc(const String &rName,
 203                                         sal_Bool bCreate) const
 204 {
 205         // gfs. in die Liste der Textbausteine eintragen
 206     if(bCreate && m_pGlosArr)
 207     {
 208         const String aName(rName);
 209         const sal_uInt16 nCount = m_pGlosArr->Count();
 210         sal_uInt16 i;
 211
 212         for( i = 0; i < nCount; ++i)
 213         {
 214             const String *pName = (*m_pGlosArr)[i];
 215             if(*pName == aName)
 216                 break;
 217         }
 218         if(i == nCount)
 219         {       // Baustein nicht in der Liste
 220             String *pTmp = new String(aName);
 221             m_pGlosArr->Insert(pTmp, m_pGlosArr->Count());
 222         }
 223     }
 224     return GetGlosDoc( rName, bCreate );
 225 }
 226
 227 /*------------------------------------------------------------------------
 228  Beschreibung:  Loeschen Textblock
 229 ------------------------------------------------------------------------*/
 230
 231 void SwGlossaries::PutGroupDoc(SwTextBlocks *pBlock) {
 232     delete pBlock;
 233 }
 234 /*------------------------------------------------------------------------
 235     Beschreibung:       Erzeugt ein neues Dokument mit dem Gruppenname
 236                     Wird temp. auch als File angelegt, damit die
 237                     Gruppen auch spaeter (ohne Zugriff) vorhanden sind.
 238 ------------------------------------------------------------------------*/
 239
 240
 241 sal_Bool SwGlossaries::NewGroupDoc(String& rGroupName, const String& rTitle)
 242 {
 243     sal_uInt16 nNewPath = (sal_uInt16)rGroupName.GetToken(1, GLOS_DELIM).ToInt32();
 244     String sNewFilePath(*(*m_pPathArr)[nNewPath]);
 245     String sNewGroup = lcl_CheckFileName(sNewFilePath, rGroupName.GetToken(0, GLOS_DELIM));
 246     sNewGroup += GLOS_DELIM;
 247     sNewGroup += rGroupName.GetToken(1, GLOS_DELIM);
 248     SwTextBlocks *pBlock = GetGlosDoc( sNewGroup );
 249     if(pBlock)
 250     {
 251         String *pTmp =
 252             new String(sNewGroup);
 253         SvStrings* pList = GetNameList();
 254         pList->Insert(pTmp, pList->Count());
 255         pBlock->SetName(rTitle);
 256         PutGroupDoc(pBlock);
 257         rGroupName = sNewGroup;
 258         return sal_True;
 259     }
 260     return sal_False;
 261 }
 262 /* -----------------23.11.98 13:13-------------------
 263  *
 264  * --------------------------------------------------*/
 265 sal_Bool        SwGlossaries::RenameGroupDoc(
 266     const String& rOldGroup, String& rNewGroup, const String& rNewTitle )
 267 {
 268     sal_Bool bRet = sal_False;
 269     sal_uInt16 nOldPath = (sal_uInt16)rOldGroup.GetToken(1, GLOS_DELIM).ToInt32();
 270     if(nOldPath < m_pPathArr->Count())
 271     {
 272         String sOldFileURL(*(*m_pPathArr)[nOldPath]);
 273         sOldFileURL += INET_PATH_TOKEN;
 274         sOldFileURL += rOldGroup.GetToken(0, GLOS_DELIM);
 275         sOldFileURL += SwGlossaries::GetExtension();
 276         BOOL bExist = FStatHelper::IsDocument( sOldFileURL );
 277         DBG_ASSERT(bExist, "Gruppe existiert nicht!");
 278         if(bExist)
 279         {
 280             sal_uInt16 nNewPath = (sal_uInt16)rNewGroup.GetToken(1, GLOS_DELIM).ToInt32();
 281             if( nNewPath < m_pPathArr->Count())
 282             {
 283                 String sNewFilePath(*(*m_pPathArr)[nNewPath]);
 284                 String sNewFileName = lcl_CheckFileName(
 285                                     sNewFilePath, rNewGroup.GetToken(0, GLOS_DELIM));
 286                 //String aTmp( rNewGroup.GetToken(0, GLOS_DELIM));
 287                 const sal_uInt16 nFileNameLen = sNewFileName.Len();
 288                 sNewFileName += SwGlossaries::GetExtension();
 289                 String sTempNewFilePath(sNewFilePath);
 290                 sTempNewFilePath += INET_PATH_TOKEN;
 291                 sTempNewFilePath += sNewFileName ;
 292                 bExist = FStatHelper::IsDocument( sTempNewFilePath );
 293                 DBG_ASSERT(!bExist, "Gruppe existiert bereits!");
 294                 if(!bExist)
 295                 {
 296                     BOOL bCopyCompleted = SWUnoHelper::UCB_CopyFile(
 297                                         sOldFileURL, sTempNewFilePath, TRUE );
 298                     if(bCopyCompleted)
 299                     {
 300                         bRet = sal_True;
 301                         RemoveFileFromList( rOldGroup );
 302
 303                         rNewGroup = sNewFileName.Copy(0, nFileNameLen);
 304                         rNewGroup += GLOS_DELIM;
 305                         rNewGroup += String::CreateFromInt32(nNewPath);
 306                         String *pTmp = new String(rNewGroup);
 307                         if(!m_pGlosArr)
 308                             GetNameList();
 309                         else
 310                             m_pGlosArr->Insert(pTmp, m_pGlosArr->Count());
 311
 312                         sNewFilePath += INET_PATH_TOKEN;
 313                         sNewFilePath += sNewFileName ;
 314                         SwTextBlocks* pNewBlock = new SwTextBlocks( sNewFilePath );
 315                         pNewBlock->SetName(rNewTitle);
 316                         delete pNewBlock;
 317                     }
 318                 }
 319             }
 320         }
 321     }
 322     return bRet;
 323 }
 324
 325 /*------------------------------------------------------------------------
 326     Beschreibung: Loescht eine Textbausteingruppe
 327 ------------------------------------------------------------------------*/
 328
 329
 330 sal_Bool SwGlossaries::DelGroupDoc(const String &rName)
 331 {
 332     sal_uInt16 nPath = (sal_uInt16)rName.GetToken(1, GLOS_DELIM).ToInt32();
 333     if(nPath >= m_pPathArr->Count())
 334         return sal_False;
 335     String sFileURL(*(*m_pPathArr)[nPath]);
 336     String aTmp( rName.GetToken(0, GLOS_DELIM));
 337     String aName(aTmp);
 338     aName += GLOS_DELIM;
 339     aName += String::CreateFromInt32(nPath);
 340
 341     aTmp += SwGlossaries::GetExtension();
 342     sFileURL += INET_PATH_TOKEN;
 343     sFileURL += aTmp;
 344         // Auch, wenn das File nicht existiert, muss es aus der Liste
 345         // der Textbausteinbereiche entfernt werden
 346     // Kein && wegen CFfront
 347     BOOL bRemoved = SWUnoHelper::UCB_DeleteFile( sFileURL );
 348     DBG_ASSERT(bRemoved, "file has not been removed");
 349     RemoveFileFromList( aName );
 350     return bRemoved;
 351 }
 352 /*------------------------------------------------------------------------
 353     Beschreibung: DTOR
 354 ------------------------------------------------------------------------*/
 355
 356
 357 SwGlossaries::~SwGlossaries()
 358 {
 359     sal_uInt16 nCount = m_pGlosArr? m_pGlosArr->Count() : 0;
 360     sal_uInt16 i;
 361
 362     for( i = 0; i < nCount; ++i)
 363     {
 364         String *pTmp = (*m_pGlosArr)[i];
 365         delete pTmp;
 366     }
 367     nCount = m_pPathArr? m_pPathArr->Count() : 0;
 368     for(i = 0; i < nCount; ++i)
 369     {
 370         String *pTmp = (*m_pPathArr)[i];
 371         delete pTmp;
 372     }
 373     delete m_pGlosArr;
 374     delete m_pPathArr;
 375
 376     InvalidateUNOOjects();
 377 }
 378 /*------------------------------------------------------------------------
 379     Beschreibung: Bausteindokument einlesen
 380 ------------------------------------------------------------------------*/
 381
 382
 383 SwTextBlocks* SwGlossaries::GetGlosDoc( const String &rName, sal_Bool bCreate ) const
 384 {
 385     sal_uInt16 nPath = (sal_uInt16)rName.GetToken(1, GLOS_DELIM).ToInt32();
 386     SwTextBlocks *pTmp = 0;
 387     if(nPath < m_pPathArr->Count())
 388     {
 389         String sFileURL(*(*m_pPathArr)[nPath]);
 390         String aTmp( rName.GetToken(0, GLOS_DELIM));
 391         aTmp += SwGlossaries::GetExtension();
 392         sFileURL += INET_PATH_TOKEN;
 393         sFileURL += aTmp;
 394
 395         BOOL bExist = FALSE;
 396         if(!bCreate)
 397             bExist = FStatHelper::IsDocument( sFileURL );
 398
 399         if (bCreate || bExist)
 400         {
 401             pTmp = new SwTextBlocks( sFileURL );
 402             sal_Bool bOk = sal_True;
 403             if( pTmp->GetError() )
 404             {
 405                 ErrorHandler::HandleError( pTmp->GetError() );
 406                 bOk = !IsError( pTmp->GetError() );
 407             }
 408
 409             if( bOk && !pTmp->GetName().Len() )
 410                 pTmp->SetName( rName );
 411         }
 412     }
 413
 414     return pTmp;
 415 }
 416
 417 /*------------------------------------------------------------------------
 418     Beschreibung: Zugriff auf die Liste der Name; diese wird gfs. eingelesen
 419 ------------------------------------------------------------------------*/
 420
 421 SvStrings* SwGlossaries::GetNameList()
 422 {
 423     if( !m_pGlosArr )
 424     {
 425         m_pGlosArr = new SvStrings;
 426         String sExt( SwGlossaries::GetExtension() );
 427         for( sal_uInt16 i = 0; i < m_pPathArr->Count(); i++ )
 428         {
 429             SvStrings aFiles( 16, 16 );
 430
 431             SWUnoHelper::UCB_GetFileListOfFolder( *(*m_pPathArr)[i], aFiles,
 432                                                     &sExt );
 433             for( USHORT nFiles = 0, nFEnd = aFiles.Count();
 434                     nFiles < nFEnd; ++nFiles )
 435             {
 436                 String* pTitle = aFiles[ nFiles ];
 437                 String sName( pTitle->Copy( 0, pTitle->Len() - sExt.Len() ));
 438                 sName += GLOS_DELIM;
 439                 sName += String::CreateFromInt32( i );
 440                 m_pGlosArr->Insert( new String(sName), m_pGlosArr->Count() );
 441
 442                 // don't need any more these pointers
 443                 delete pTitle;
 444             }
 445         }
 446         if(!m_pGlosArr->Count())
 447         {
 448             // Der Standard-Baustein steht im ersten Teil des Pfades
 449             String *pTmp = new String( SwGlossaries::GetDefName() );
 450             (*pTmp) += GLOS_DELIM;
 451             (*pTmp) += '0';
 452             m_pGlosArr->Insert(pTmp, m_pGlosArr->Count());
 453         }
 454     }
 455     return m_pGlosArr;
 456 }
 457
 458 /*------------------------------------------------------------------------
 459     Beschreibung: CTOR
 460 ------------------------------------------------------------------------*/
 461
 462
 463 SwGlossaries::SwGlossaries() :
 464     m_pPathArr(0),
 465     m_pGlosArr(0)
 466 {
 467     m_pPathArr = new SvStrings;
 468     UpdateGlosPath(sal_True);
 469 }
 470
 471 /*------------------------------------------------------------------------
 472     Beschreibung: Neuen Pfad einstellen und internes Array neu aufbauen
 473 ------------------------------------------------------------------------*/
 474
 475 /* -----------------21.01.99 15:36-------------------
 476 *       #61050# Doppelte Pfade fuehren zu Verwirrung - als raus damit
 477  * --------------------------------------------------*/
 478 sal_Bool lcl_FindSameEntry(const SvStrings& rDirArr, const String& rEntryURL)
 479 {
 480     for(sal_uInt16 i = 0; i < rDirArr.Count(); i++)
 481         if(rEntryURL == (*rDirArr.GetObject(i)))
 482             return sal_True;
 483     return sal_False;
 484 }
 485
 486 void SwGlossaries::UpdateGlosPath(sal_Bool bFull)
 487 {
 488     SvtPathOptions aPathOpt;
 489     String aNewPath( aPathOpt.GetAutoTextPath() );
 490     sal_Bool bPathChanged = m_aPath != aNewPath;
 491     if (bFull || bPathChanged)
 492     {
 493         m_aPath = aNewPath;
 494         sal_uInt16 nCount = m_pPathArr? m_pPathArr->Count() : 0;
 495         sal_uInt16 i;
 496
 497         for( i = nCount; i; --i)
 498         {
 499             String *pTmp = (*m_pPathArr)[i - 1];
 500             m_pPathArr->Remove(i - 1);
 501             delete pTmp;
 502         }
 503         sal_uInt16 nTokenCount = m_aPath.GetTokenCount(SVT_SEARCHPATH_DELIMITER);
 504         SvStrings aDirArr;
 505         for( i = 0; i < nTokenCount; i++ )
 506         {
 507             String sPth(m_aPath.GetToken(i, SVT_SEARCHPATH_DELIMITER));
 508             sPth = URIHelper::SmartRel2Abs(
 509                 INetURLObject(), sPth, URIHelper::GetMaybeFileHdl());
 510
 511             if(i && lcl_FindSameEntry(aDirArr, sPth))
 512             {
 513                 continue;
 514             }
 515             aDirArr.Insert(new String(sPth), aDirArr.Count());
 516             if( !FStatHelper::IsFolder( sPth ) )
 517             {
 518                 if( m_sErrPath.Len() )
 519                     m_sErrPath += SVT_SEARCHPATH_DELIMITER;
 520                 INetURLObject aTemp( sPth );
 521                 m_sErrPath += String(aTemp.GetFull());
 522             }
 523             else
 524                 m_pPathArr->Insert(new String(sPth), m_pPathArr->Count());
 525         }
 526         aDirArr.DeleteAndDestroy(0, aDirArr.Count());
 527
 528         if(!nTokenCount ||
 529             m_sErrPath.Len() && (bPathChanged || m_sOldErrPath != m_sErrPath) )
 530         {
 531             m_sOldErrPath = m_sErrPath;
 532             // Falscher Pfad, d.h. AutoText-Verzeichnis existiert nicht
 533
 534             ErrorHandler::HandleError( *new StringErrorInfo(
 535                                     ERR_AUTOPATH_ERROR, m_sErrPath,
 536                                     ERRCODE_BUTTON_OK | ERRCODE_MSG_ERROR ));
 537             m_bError = sal_True;
 538         }
 539         else
 540             m_bError = sal_False;
 541
 542         if(m_pGlosArr)
 543         {
 544             for(i = 0; i < m_pGlosArr->Count(); ++i)
 545             {
 546                 delete (String *)(*m_pGlosArr)[i];
 547             }
 548             DELETEZ(m_pGlosArr);
 549             GetNameList();
 550         }
 551     }
 552 }
 553
 554 /*------------------------------------------------------------------------
 555     Beschreibung:
 556 ------------------------------------------------------------------------*/
 557
 558
 559 void SwGlossaries::ShowError()
 560 {
 561     sal_uInt32 nPathError = *new StringErrorInfo(ERR_AUTOPATH_ERROR,
 562                                             m_sErrPath, ERRCODE_BUTTON_OK );
 563     ErrorHandler::HandleError( nPathError );
 564 }
 565 /* -----------------------------09.02.00 11:37--------------------------------
 566
 567  ---------------------------------------------------------------------------*/
 568 String SwGlossaries::GetExtension()
 569 {
 570     return String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( ".bau" ));
 571 }
 572
 573
 574
 575 void SwGlossaries::RemoveFileFromList( const String& rGroup )
 576 {
 577     if(m_pGlosArr)
 578     {
 579         const sal_uInt16 nCount = m_pGlosArr->Count();
 580         for(sal_uInt16 i = 0; i < nCount; ++i)
 581         {
 582             String *pTmp = (*m_pGlosArr)[i];
 583             if(*pTmp == rGroup)
 584             {
 585                 rtl::OUString aUName = rGroup;
 586                 {
 587                     // tell the UNO AutoTextGroup object that it's not valid anymore
 588                     for (       UnoAutoTextGroups::iterator aLoop = m_aGlossaryGroups.begin();
 589                             aLoop != m_aGlossaryGroups.end();
 590                             ++aLoop
 591                         )
 592                     {
 593                         Reference< container::XNamed > xNamed( aLoop->get(), UNO_QUERY );
 594                         if ( xNamed.is() && ( xNamed->getName() == aUName ) )
 595                         {
 596                             static_cast< SwXAutoTextGroup* >( xNamed.get() )->Invalidate();
 597                                 // note that this static_cast works because we know that the array only
 598                                 // contains SwXAutoTextGroup implementation
 599                             m_aGlossaryGroups.erase( aLoop );
 600                             break;
 601                         }
 602                     }
 603                 }
 604
 605                 {
 606                     // tell all our UNO AutoTextEntry objects that they're not valid anymore
 607                     for (       UnoAutoTextEntries::iterator aLoop = m_aGlossaryEntries.begin();
 608                             aLoop != m_aGlossaryEntries.end();
 609                         )
 610                     {
 611                         Reference< lang::XUnoTunnel > xEntryTunnel( aLoop->get(), UNO_QUERY );
 612
 613                         SwXAutoTextEntry* pEntry = NULL;
 614                         if ( xEntryTunnel.is() )
 615                             pEntry = reinterpret_cast< SwXAutoTextEntry* >(
 616                                 xEntryTunnel->getSomething( SwXAutoTextEntry::getUnoTunnelId() ) );
 617
 618                         if ( pEntry && ( pEntry->GetGroupName() == rGroup ) )
 619                         {
 620                             pEntry->Invalidate();
 621                             aLoop = m_aGlossaryEntries.erase( aLoop );
 622                         }
 623                         else
 624                             ++aLoop;
 625                     }
 626                 }
 627
 628                 m_pGlosArr->Remove(i);
 629                 delete pTmp;
 630                 break;
 631             }
 632         }
 633     }
 634 }
 635
 636
 637 String SwGlossaries::GetCompleteGroupName( const rtl::OUString& GroupName )
 638 {
 639     sal_uInt16 nCount = GetGroupCnt();
 640     //wenn der Gruppenname intern erzeugt wurde, dann steht auch hier der Pfad drin
 641     String sGroup(GroupName);
 642     String sGroupName(sGroup.GetToken(0, GLOS_DELIM));
 643     String sPath = sGroup.GetToken(1, GLOS_DELIM);
 644     sal_Bool bPathLen = sPath.Len() > 0;
 645     for ( sal_uInt16 i = 0; i < nCount; i++ )
 646     {
 647         String sGrpName = GetGroupName(i);
 648         if(bPathLen ? sGroup == sGrpName : sGroupName == sGrpName.GetToken(0, GLOS_DELIM))
 649         {
 650             return sGrpName;
 651         }
 652     }
 653     return aEmptyStr;
 654 }
 655
 656
 657 void SwGlossaries::InvalidateUNOOjects()
 658 {
 659     // invalidate all the AutoTextGroup-objects
 660     for (       UnoAutoTextGroups::iterator aGroupLoop = m_aGlossaryGroups.begin();
 661             aGroupLoop != m_aGlossaryGroups.end();
 662             ++aGroupLoop
 663         )
 664     {
 665         Reference< text::XAutoTextGroup > xGroup( aGroupLoop->get(), UNO_QUERY );
 666         if ( xGroup.is() )
 667             static_cast< SwXAutoTextGroup* >( xGroup.get() )->Invalidate();
 668     }
 669     UnoAutoTextGroups aTmpg = UnoAutoTextGroups();
 670     m_aGlossaryGroups.swap( aTmpg );
 671
 672     // invalidate all the AutoTextEntry-objects
 673     for (       UnoAutoTextEntries::const_iterator aEntryLoop = m_aGlossaryEntries.begin();
 674             aEntryLoop != m_aGlossaryEntries.end();
 675             ++aEntryLoop
 676         )
 677     {
 678         Reference< lang::XUnoTunnel > xEntryTunnel( aEntryLoop->get(), UNO_QUERY );
 679         SwXAutoTextEntry* pEntry = NULL;
 680         if ( xEntryTunnel.is() )
 681             pEntry = reinterpret_cast< SwXAutoTextEntry* >(
 682                 xEntryTunnel->getSomething( SwXAutoTextEntry::getUnoTunnelId() ) );
 683
 684         if ( pEntry )
 685             pEntry->Invalidate();
 686     }
 687     UnoAutoTextEntries aTmpe = UnoAutoTextEntries();
 688     m_aGlossaryEntries.swap( aTmpe );
 689 }
 690
 691 //-----------------------------------------------------------------------
 692 //--- 03.03.2003 14:15:32 -----------------------------------------------
 693
 694 Reference< text::XAutoTextGroup > SwGlossaries::GetAutoTextGroup( const ::rtl::OUString& _rGroupName, bool _bCreate )
 695 {
 696     // first, find the name with path-extension
 697     String sCompleteGroupName = GetCompleteGroupName( _rGroupName );
 698
 699     Reference< text::XAutoTextGroup >  xGroup;
 700
 701     // look up the group in the cache
 702     UnoAutoTextGroups::iterator aSearch = m_aGlossaryGroups.begin();
 703     for ( ; aSearch != m_aGlossaryGroups.end(); )
 704     {
 705         Reference< lang::XUnoTunnel > xGroupTunnel( aSearch->get(), UNO_QUERY );
 706
 707         SwXAutoTextGroup* pSwGroup = 0;
 708         if ( xGroupTunnel.is() )
 709             pSwGroup = reinterpret_cast< SwXAutoTextGroup* >( xGroupTunnel->getSomething( SwXAutoTextGroup::getUnoTunnelId() ) );
 710
 711         if ( !pSwGroup )
 712         {
 713             // the object is dead in the meantime -> remove from cache
 714             aSearch = m_aGlossaryGroups.erase( aSearch );
 715             continue;
 716         }
 717
 718         if ( _rGroupName == pSwGroup->getName() )
 719         {                                   // the group is already cached
 720             if ( sCompleteGroupName.Len() )
 721             {   // the group still exists -> return it
 722                 xGroup = pSwGroup;
 723                 break;
 724             }
 725             else
 726             {
 727                 // this group does not exist (anymore) -> release the cached UNO object for it
 728                 aSearch = m_aGlossaryGroups.erase( aSearch );
 729                 // so it won't be created below
 730                 _bCreate = sal_False;
 731                 break;
 732             }
 733         }
 734
 735         ++aSearch;
 736     }
 737
 738     if ( !xGroup.is() && _bCreate )
 739     {
 740         xGroup = new SwXAutoTextGroup( sCompleteGroupName, this );
 741         // cache it
 742         m_aGlossaryGroups.push_back( AutoTextGroupRef( xGroup ) );
 743     }
 744
 745     return xGroup;
 746 }
 747
 748 //-----------------------------------------------------------------------
 749 //--- 03.03.2003 13:46:06 -----------------------------------------------
 750
 751 Reference< text::XAutoTextEntry > SwGlossaries::GetAutoTextEntry( const String& _rCompleteGroupName, const ::rtl::OUString& _rGroupName, const ::rtl::OUString& _rEntryName,
 752     bool _bCreate )
 753 {
 754     //standard must be created
 755     sal_Bool bCreate = ( _rCompleteGroupName == GetDefName() );
 756     ::std::auto_ptr< SwTextBlocks > pGlosGroup( GetGroupDoc( _rCompleteGroupName, bCreate ) );
 757
 758     if ( pGlosGroup.get() && !pGlosGroup->GetError() )
 759     {
 760         sal_uInt16 nIdx = pGlosGroup->GetIndex( _rEntryName );
 761         if ( USHRT_MAX == nIdx )
 762             throw container::NoSuchElementException();
 763     }
 764     else
 765         throw lang::WrappedTargetException();
 766
 767     Reference< text::XAutoTextEntry > xReturn;
 768     String sGroupName( _rGroupName );
 769     String sEntryName( _rEntryName );
 770
 771     UnoAutoTextEntries::iterator aSearch( m_aGlossaryEntries.begin() );
 772     for ( ; aSearch != m_aGlossaryEntries.end(); )
 773     {
 774         Reference< lang::XUnoTunnel > xEntryTunnel( aSearch->get(), UNO_QUERY );
 775
 776         SwXAutoTextEntry* pEntry = NULL;
 777         if ( xEntryTunnel.is() )
 778             pEntry = reinterpret_cast< SwXAutoTextEntry* >( xEntryTunnel->getSomething( SwXAutoTextEntry::getUnoTunnelId() ) );
 779         else
 780         {
 781             // the object is dead in the meantime -> remove from cache
 782             aSearch = m_aGlossaryEntries.erase( aSearch );
 783             continue;
 784         }
 785
 786         if      (       pEntry
 787             &&  ( COMPARE_EQUAL == pEntry->GetGroupName().CompareTo( sGroupName ) )
 788             &&  ( COMPARE_EQUAL == pEntry->GetEntryName().CompareTo( sEntryName ) )
 789             )
 790         {
 791             xReturn = pEntry;
 792             break;
 793         }
 794
 795         ++aSearch;
 796     }
 797
 798     if ( !xReturn.is() && _bCreate )
 799     {
 800         xReturn = new SwXAutoTextEntry( this, sGroupName, sEntryName );
 801         // cache it
 802         m_aGlossaryEntries.push_back( AutoTextEntryRef( xReturn ) );
 803     }
 804
 805     return xReturn;
 806 }
 807
 808
 809