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