svx/source/gallery2/gallery1.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "sal/config.h"
  21
  22 #include <comphelper/processfactory.hxx>
  23 #include <comphelper/string.hxx>
  24 #include <tools/vcompat.hxx>
  25 #include <ucbhelper/content.hxx>
  26 #include <unotools/ucbstreamhelper.hxx>
  27 #include <unotools/pathoptions.hxx>
  28 #include <sfx2/docfile.hxx>
  29 #include "svx/gallery.hxx"
  30 #include "gallery.hrc"
  31 #include "svx/galmisc.hxx"
  32 #include "svx/galtheme.hxx"
  33 #include "svx/gallery1.hxx"
  34 #include <com/sun/star/sdbc/XResultSet.hpp>
  35 #include <com/sun/star/ucb/XContentAccess.hpp>
  36
  37 // --------------
  38 // - Namespaces -
  39 // --------------
  40
  41 using namespace ::rtl;
  42 using namespace ::com::sun::star;
  43
  44 // ---------------------
  45 // - GalleryThemeEntry -
  46 // ---------------------
  47
  48 static bool FileExists( const INetURLObject &rURL, const rtl::OUString &rExt )
  49 {
  50     INetURLObject aURL( rURL );
  51     aURL.setExtension( rExt );
  52     return FileExists( aURL );
  53 }
  54
  55 GalleryThemeEntry::GalleryThemeEntry( bool bCreateUniqueURL,
  56                                       const INetURLObject& rBaseURL,
  57                                       const String& rName,
  58                                       sal_Bool _bReadOnly, sal_Bool _bNewFile,
  59                                       sal_uInt32 _nId, sal_Bool _bThemeNameFromResource ) :
  60         nId                                     ( _nId ),
  61         bReadOnly                               ( _bReadOnly ),
  62         bThemeNameFromResource  ( _bThemeNameFromResource )
  63 {
  64     INetURLObject aURL( rBaseURL );
  65     DBG_ASSERT( aURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
  66
  67     if (bCreateUniqueURL)
  68     {
  69         INetURLObject aBaseNoCase( ImplGetURLIgnoreCase( rBaseURL ) );
  70         aURL = aBaseNoCase;
  71         static sal_Int32 nIdx = 0;
  72         while( FileExists( aURL, "thm" ) )
  73         { // create new URLs
  74             nIdx++;
  75             aURL = aBaseNoCase;
  76             aURL.setName( aURL.getName() + OUString::number(nIdx));
  77         }
  78     }
  79
  80     aURL.setExtension( "thm" );
  81     aThmURL = ImplGetURLIgnoreCase( aURL );
  82
  83     aURL.setExtension( "sdg" );
  84     aSdgURL = ImplGetURLIgnoreCase( aURL );
  85
  86     aURL.setExtension( "sdv" );
  87     aSdvURL = ImplGetURLIgnoreCase( aURL );
  88
  89     aURL.setExtension( "str" );
  90     aStrURL = ImplGetURLIgnoreCase( aURL );
  91
  92     SetModified( _bNewFile );
  93
  94     aName = ReadStrFromIni( "name" );
  95
  96     // This is awful - we shouldn't use these resources if we
  97     // possibly can avoid them
  98     if( aName.isEmpty() && nId && bThemeNameFromResource )
  99         aName = GAL_RESSTR( RID_GALLERYSTR_THEME_START + (sal_uInt16) nId );
 100
 101     if( aName.isEmpty() )
 102         aName = rName;
 103 }
 104
 105 // -----------------------------------------------------------------------------
 106
 107 INetURLObject GalleryThemeEntry::ImplGetURLIgnoreCase( const INetURLObject& rURL ) const
 108 {
 109     INetURLObject   aURL( rURL );
 110
 111     // check original file name
 112     if( !FileExists( aURL ) )
 113     {
 114         // check upper case file name
 115         aURL.setName( aURL.getName().toAsciiUpperCase() );
 116
 117         if(!FileExists( aURL ) )
 118         {
 119             // check lower case file name
 120             aURL.setName( aURL.getName().toAsciiLowerCase() );
 121         }
 122     }
 123
 124     return aURL;
 125 }
 126
 127 // -----------------------------------------------------------------------------
 128
 129 void GalleryThemeEntry::SetName( const OUString& rNewName )
 130 {
 131     if( aName != rNewName )
 132     {
 133         aName = rNewName;
 134         SetModified( sal_True );
 135         bThemeNameFromResource = sal_False;
 136     }
 137 }
 138
 139 // -----------------------------------------------------------------------------
 140
 141 void GalleryThemeEntry::SetId( sal_uInt32 nNewId, sal_Bool bResetThemeName )
 142 {
 143     nId = nNewId;
 144     SetModified( sal_True );
 145     bThemeNameFromResource = ( nId && bResetThemeName );
 146 }
 147
 148 // --------------------------
 149 // - GalleryThemeCacheEntry -
 150 // --------------------------
 151
 152 class GalleryThemeCacheEntry
 153 {
 154 private:
 155
 156     const GalleryThemeEntry*        mpThemeEntry;
 157     GalleryTheme*                           mpTheme;
 158
 159 public:
 160
 161                                 GalleryThemeCacheEntry( const GalleryThemeEntry* pThemeEntry, GalleryTheme* pTheme ) :
 162                                     mpThemeEntry( pThemeEntry ), mpTheme( pTheme ) {}
 163                                 ~GalleryThemeCacheEntry() { delete mpTheme; }
 164
 165     const GalleryThemeEntry*        GetThemeEntry() const { return mpThemeEntry; }
 166     GalleryTheme*                           GetTheme() const { return mpTheme; }
 167 };
 168
 169 // -----------
 170 // - Gallery -
 171 // -----------
 172
 173 Gallery::Gallery( const OUString& rMultiPath )
 174 :       nReadTextEncoding   ( osl_getThreadTextEncoding() )
 175 ,       bMultiPath          ( sal_False )
 176 {
 177     ImplLoad( rMultiPath );
 178 }
 179
 180 // ------------------------------------------------------------------------
 181
 182 Gallery::~Gallery()
 183 {
 184     // Themen-Liste loeschen
 185     for ( size_t i = 0, n = aThemeList.size(); i < n; ++i )
 186         delete aThemeList[ i ];
 187     aThemeList.clear();
 188 }
 189
 190 // ------------------------------------------------------------------------
 191
 192 Gallery* Gallery::GetGalleryInstance()
 193 {
 194     static Gallery* pGallery = NULL;
 195
 196     if( !pGallery )
 197     {
 198         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 199         if( !pGallery )
 200         {
 201             pGallery = new Gallery( SvtPathOptions().GetGalleryPath() );
 202         }
 203     }
 204
 205     return pGallery;
 206 }
 207
 208 // ------------------------------------------------------------------------
 209
 210 void Gallery::ImplLoad( const OUString& rMultiPath )
 211 {
 212     const sal_Int32 nTokenCount = comphelper::string::getTokenCount(rMultiPath, ';');
 213     sal_Bool        bIsReadOnlyDir;
 214
 215     bMultiPath = ( nTokenCount > 0 );
 216
 217     INetURLObject aCurURL(SvtPathOptions().GetConfigPath());
 218     ImplLoadSubDirs( aCurURL, bIsReadOnlyDir );
 219
 220     if( !bIsReadOnlyDir )
 221         aUserURL = aCurURL;
 222
 223     if( bMultiPath )
 224     {
 225         aRelURL = INetURLObject( comphelper::string::getToken(rMultiPath, 0, ';') );
 226
 227         for( sal_Int32 i = 0; i < nTokenCount; ++i )
 228         {
 229             aCurURL = INetURLObject(comphelper::string::getToken(rMultiPath, i, ';'));
 230
 231             ImplLoadSubDirs( aCurURL, bIsReadOnlyDir );
 232
 233             if( !bIsReadOnlyDir )
 234                 aUserURL = aCurURL;
 235         }
 236     }
 237     else
 238         aRelURL = INetURLObject( rMultiPath );
 239
 240     DBG_ASSERT( aUserURL.GetProtocol() != INET_PROT_NOT_VALID, "no writable Gallery user directory available" );
 241     DBG_ASSERT( aRelURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
 242 }
 243
 244 // ------------------------------------------------------------------------
 245
 246 void Gallery::ImplLoadSubDirs( const INetURLObject& rBaseURL, sal_Bool& rbDirIsReadOnly )
 247 {
 248     rbDirIsReadOnly = sal_False;
 249
 250     try
 251     {
 252         uno::Reference< ucb::XCommandEnvironment > xEnv;
 253         ::ucbhelper::Content                       aCnt( rBaseURL.GetMainURL( INetURLObject::NO_DECODE ), xEnv, comphelper::getProcessComponentContext() );
 254
 255         uno::Sequence< OUString > aProps( 1 );
 256         aProps.getArray()[ 0 ] = OUString("Url");
 257
 258         uno::Reference< sdbc::XResultSet > xResultSet( aCnt.createCursor( aProps, ::ucbhelper::INCLUDE_DOCUMENTS_ONLY ) );
 259
 260         try
 261         {
 262             // check readonlyness the very hard way
 263             INetURLObject   aTestURL( rBaseURL );
 264             String          aTestFile( RTL_CONSTASCII_USTRINGPARAM( "cdefghij.klm" ) );
 265
 266             aTestURL.Append( aTestFile );
 267             SvStream* pTestStm = ::utl::UcbStreamHelper::CreateStream( aTestURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE );
 268
 269             if( pTestStm )
 270             {
 271                 *pTestStm << sal_Int32(1);
 272
 273                 if( pTestStm->GetError() )
 274                     rbDirIsReadOnly = sal_True;
 275
 276                 delete pTestStm;
 277                 KillFile( aTestURL );
 278             }
 279             else
 280                 rbDirIsReadOnly = sal_True;
 281         }
 282         catch( const ucb::ContentCreationException& )
 283         {
 284         }
 285         catch( const uno::RuntimeException& )
 286         {
 287         }
 288         catch( const uno::Exception& )
 289         {
 290         }
 291
 292         if( xResultSet.is() )
 293         {
 294             uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
 295
 296             if( xContentAccess.is() )
 297             {
 298                 static const OUString s_sTitle("Title");
 299                 static const OUString s_sIsReadOnly("IsReadOnly");
 300                 static const OUString s_sSDG_EXT("sdg");
 301                 static const OUString s_sSDV_EXT("sdv");
 302
 303                 while( xResultSet->next() )
 304                 {
 305                     INetURLObject aThmURL( xContentAccess->queryContentIdentifierString() );
 306
 307                     if(aThmURL.GetExtension().equalsIgnoreAsciiCase("thm"))
 308                     {
 309                         INetURLObject   aSdgURL( aThmURL); aSdgURL.SetExtension( s_sSDG_EXT );
 310                         INetURLObject   aSdvURL( aThmURL ); aSdvURL.SetExtension( s_sSDV_EXT );
 311                         OUString        aTitle;
 312                         sal_Bool        bReadOnly = sal_False;
 313
 314                         try
 315                         {
 316                             ::ucbhelper::Content aThmCnt( aThmURL.GetMainURL( INetURLObject::NO_DECODE ), xEnv, comphelper::getProcessComponentContext() );
 317                             ::ucbhelper::Content aSdgCnt( aSdgURL.GetMainURL( INetURLObject::NO_DECODE ), xEnv, comphelper::getProcessComponentContext() );
 318                             ::ucbhelper::Content aSdvCnt( aSdvURL.GetMainURL( INetURLObject::NO_DECODE ), xEnv, comphelper::getProcessComponentContext() );
 319
 320                             try
 321                             {
 322                                 aThmCnt.getPropertyValue( s_sTitle ) >>= aTitle;
 323                             }
 324                             catch( const uno::RuntimeException& )
 325                             {
 326                             }
 327                             catch( const uno::Exception& )
 328                             {
 329                             }
 330
 331                             if( !aTitle.isEmpty() )
 332                             {
 333                                 try
 334                                 {
 335                                     aThmCnt.getPropertyValue( s_sIsReadOnly ) >>= bReadOnly;
 336                                 }
 337                                 catch( const uno::RuntimeException& )
 338                                 {
 339                                 }
 340                                 catch( const uno::Exception& )
 341                                 {
 342                                 }
 343
 344                                 if( !bReadOnly )
 345                                 {
 346                                     try
 347                                     {
 348                                         aSdgCnt.getPropertyValue( s_sTitle ) >>= aTitle;
 349                                     }
 350                                     catch( const ::com::sun::star::uno::RuntimeException& )
 351                                     {
 352                                     }
 353                                     catch( const ::com::sun::star::uno::Exception& )
 354                                     {
 355                                     }
 356
 357                                     if( !aTitle.isEmpty() )
 358                                     {
 359                                         try
 360                                         {
 361                                             aSdgCnt.getPropertyValue( s_sIsReadOnly ) >>= bReadOnly;
 362                                         }
 363                                         catch( const uno::RuntimeException& )
 364                                         {
 365                                         }
 366                                         catch( const uno::Exception& )
 367                                         {
 368                                         }
 369                                     }
 370                                 }
 371
 372                                 if( !bReadOnly )
 373                                 {
 374                                     try
 375                                     {
 376                                         aSdvCnt.getPropertyValue( s_sTitle ) >>= aTitle;
 377                                     }
 378                                     catch( const ::com::sun::star::uno::RuntimeException& )
 379                                     {
 380                                     }
 381                                     catch( const ::com::sun::star::uno::Exception& )
 382                                     {
 383                                     }
 384
 385                                     if( !aTitle.isEmpty() )
 386                                     {
 387                                         try
 388                                         {
 389                                             aSdvCnt.getPropertyValue( s_sIsReadOnly ) >>= bReadOnly;
 390                                         }
 391                                         catch( const uno::RuntimeException& )
 392                                         {
 393                                         }
 394                                         catch( const uno::Exception& )
 395                                         {
 396                                         }
 397                                     }
 398                                 }
 399
 400                                 GalleryThemeEntry* pEntry = GalleryTheme::CreateThemeEntry( aThmURL, rbDirIsReadOnly || bReadOnly );
 401
 402                                 if( pEntry )
 403                                     aThemeList.push_back( pEntry );
 404                             }
 405                         }
 406                         catch( const ucb::ContentCreationException& )
 407                         {
 408                         }
 409                         catch( const uno::RuntimeException& )
 410                         {
 411                         }
 412                         catch( const uno::Exception& )
 413                         {
 414                         }
 415                     }
 416                 }
 417             }
 418         }
 419     }
 420     catch( const ucb::ContentCreationException& )
 421     {
 422     }
 423     catch( const uno::RuntimeException& )
 424     {
 425     }
 426     catch( const uno::Exception& )
 427     {
 428     }
 429 }
 430
 431 // ------------------------------------------------------------------------
 432
 433 GalleryThemeEntry* Gallery::ImplGetThemeEntry( const OUString& rThemeName )
 434 {
 435     GalleryThemeEntry* pFound = NULL;
 436
 437     if( !rThemeName.isEmpty() )
 438     {
 439         for ( size_t i = 0, n = aThemeList.size(); i < n && !pFound; ++i )
 440             if( rThemeName == aThemeList[ i ]->GetThemeName() )
 441                 pFound = aThemeList[ i ];
 442     }
 443
 444     return pFound;
 445 }
 446
 447 // ------------------------------------------------------------------------
 448
 449 OUString Gallery::GetThemeName( sal_uIntPtr nThemeId ) const
 450 {
 451     GalleryThemeEntry* pFound = NULL;
 452
 453     for ( size_t i = 0, n = aThemeList.size(); i < n && !pFound; ++i )
 454     {
 455         GalleryThemeEntry* pEntry = aThemeList[ i ];
 456         if( nThemeId == pEntry->GetId() )
 457             pFound = pEntry;
 458     }
 459
 460     // try fallback, if no entry was found
 461     if( !pFound )
 462     {
 463         OString aFallback;
 464
 465         switch( nThemeId )
 466         {
 467             case( GALLERY_THEME_3D ):
 468                 aFallback = "3D";
 469                 break;
 470             case( GALLERY_THEME_BULLETS ):
 471                 aFallback = "Bullets";
 472                 break;
 473             case( GALLERY_THEME_HOMEPAGE ):
 474                 aFallback = "Homepage";
 475                 break;
 476             case( GALLERY_THEME_POWERPOINT ):
 477                 aFallback = "private://gallery/hidden/imgppt";
 478                 break;
 479             case( GALLERY_THEME_FONTWORK ):
 480                 aFallback = "private://gallery/hidden/fontwork";
 481                 break;
 482             case( GALLERY_THEME_FONTWORK_VERTICAL ):
 483                 aFallback = "private://gallery/hidden/fontworkvertical";
 484                 break;
 485             case( GALLERY_THEME_SOUNDS ):
 486                 aFallback = "Sounds";
 487                 break;
 488             case( RID_GALLERYSTR_THEME_ARROWS ):
 489                 aFallback = "Arrows";
 490                 break;
 491             case( RID_GALLERYSTR_THEME_COMPUTERS ):
 492                 aFallback = "Computers";
 493                 break;
 494             case( RID_GALLERYSTR_THEME_DIAGRAMS ):
 495                 aFallback = "Diagrams";
 496                 break;
 497             case( RID_GALLERYSTR_THEME_EDUCATION ):
 498                 aFallback = "Education";
 499                 break;
 500             case( RID_GALLERYSTR_THEME_ENVIRONMENT ):
 501                 aFallback = "Environment";
 502                 break;
 503             case( RID_GALLERYSTR_THEME_FINANCE ):
 504                 aFallback = "Finance";
 505                 break;
 506             case( RID_GALLERYSTR_THEME_PEOPLE ):
 507                 aFallback = "People";
 508                 break;
 509             case( RID_GALLERYSTR_THEME_SYMBOLS ):
 510                 aFallback = "Symbols";
 511                 break;
 512             case( RID_GALLERYSTR_THEME_TRANSPORT ):
 513                 aFallback = "Transport";
 514                 break;
 515             case( RID_GALLERYSTR_THEME_TXTSHAPES ):
 516                 aFallback = "Textshapes";
 517                 break;
 518             default:
 519                 break;
 520         }
 521
 522         pFound = const_cast<Gallery*>(this)->ImplGetThemeEntry(OStringToOUString(aFallback, RTL_TEXTENCODING_ASCII_US));
 523     }
 524
 525     return( pFound ? pFound->GetThemeName() : OUString() );
 526 }
 527
 528 // ------------------------------------------------------------------------
 529
 530 sal_Bool Gallery::HasTheme( const String& rThemeName )
 531 {
 532     return( ImplGetThemeEntry( rThemeName ) != NULL );
 533 }
 534
 535 // ------------------------------------------------------------------------
 536
 537 sal_Bool Gallery::CreateTheme( const String& rThemeName )
 538 {
 539     sal_Bool bRet = sal_False;
 540
 541     if( !HasTheme( rThemeName ) && ( GetUserURL().GetProtocol() != INET_PROT_NOT_VALID ) )
 542     {
 543         INetURLObject aURL( GetUserURL() );
 544         aURL.Append( rThemeName );
 545         GalleryThemeEntry* pNewEntry = new GalleryThemeEntry(
 546                 true, aURL, rThemeName,
 547                 sal_False, sal_True, 0, sal_False );
 548
 549         aThemeList.push_back( pNewEntry );
 550         delete( new GalleryTheme( this, pNewEntry ) );
 551         Broadcast( GalleryHint( GALLERY_HINT_THEME_CREATED, rThemeName ) );
 552         bRet = sal_True;
 553     }
 554
 555     return bRet;
 556 }
 557
 558 // ------------------------------------------------------------------------
 559
 560 sal_Bool Gallery::RenameTheme( const String& rOldName, const String& rNewName )
 561 {
 562     GalleryThemeEntry*      pThemeEntry = ImplGetThemeEntry( rOldName );
 563     sal_Bool                            bRet = sal_False;
 564
 565     // Ueberpruefen, ob neuer Themenname schon vorhanden ist
 566     if( pThemeEntry && !HasTheme( rNewName ) && !pThemeEntry->IsReadOnly() )
 567     {
 568         SfxListener   aListener;
 569         GalleryTheme* pThm = AcquireTheme( rOldName, aListener );
 570
 571         if( pThm )
 572         {
 573             const String aOldName( rOldName );
 574
 575             pThemeEntry->SetName( rNewName );
 576             pThm->ImplWrite();
 577
 578             Broadcast( GalleryHint( GALLERY_HINT_THEME_RENAMED, aOldName, pThm->GetName() ) );
 579             ReleaseTheme( pThm, aListener );
 580             bRet = sal_True;
 581         }
 582     }
 583
 584     return bRet;
 585 }
 586
 587 // ------------------------------------------------------------------------
 588
 589 sal_Bool Gallery::RemoveTheme( const String& rThemeName )
 590 {
 591     GalleryThemeEntry*  pThemeEntry = ImplGetThemeEntry( rThemeName );
 592     sal_Bool                bRet = sal_False;
 593
 594     if( pThemeEntry && !pThemeEntry->IsReadOnly() )
 595     {
 596         Broadcast( GalleryHint( GALLERY_HINT_CLOSE_THEME, rThemeName ) );
 597
 598         SfxListener     aListener;
 599         GalleryTheme*   pThm = AcquireTheme( rThemeName, aListener );
 600
 601         if( pThm )
 602         {
 603             INetURLObject   aThmURL( pThm->GetThmURL() );
 604             INetURLObject   aSdgURL( pThm->GetSdgURL() );
 605             INetURLObject   aSdvURL( pThm->GetSdvURL() );
 606             INetURLObject   aStrURL( pThm->GetSdvURL() );
 607
 608             ReleaseTheme( pThm, aListener );
 609
 610             KillFile( aThmURL );
 611             KillFile( aSdgURL );
 612             KillFile( aSdvURL );
 613             KillFile( aStrURL );
 614         }
 615
 616         for ( GalleryThemeList::iterator it = aThemeList.begin(); it != aThemeList.end(); ++it )
 617         {
 618             if ( pThemeEntry == *it ) {
 619                 delete pThemeEntry;
 620                 aThemeList.erase( it );
 621                 break;
 622             }
 623         }
 624
 625         Broadcast( GalleryHint( GALLERY_HINT_THEME_REMOVED, rThemeName ) );
 626
 627         bRet = sal_True;
 628     }
 629
 630     return bRet;
 631 }
 632
 633 // ------------------------------------------------------------------------
 634
 635 GalleryTheme* Gallery::ImplGetCachedTheme( const GalleryThemeEntry* pThemeEntry )
 636 {
 637     GalleryTheme* pTheme = NULL;
 638
 639     if( pThemeEntry )
 640     {
 641         for (GalleryCacheThemeList::const_iterator it = aThemeCache.begin(); it != aThemeCache.end(); ++it)
 642         {
 643             if (pThemeEntry == (*it)->GetThemeEntry())
 644             {
 645                 pTheme = (*it)->GetTheme();
 646                 break;
 647             }
 648         }
 649
 650         if( !pTheme )
 651         {
 652             INetURLObject aURL = pThemeEntry->GetThmURL();
 653
 654             DBG_ASSERT( aURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
 655
 656             if( FileExists( aURL ) )
 657             {
 658                 SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( aURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ );
 659
 660                 if( pIStm )
 661                 {
 662                     pTheme = new GalleryTheme( this, (GalleryThemeEntry*) pThemeEntry );
 663                     *pIStm >> *pTheme;
 664
 665                     if( pIStm->GetError() )
 666                     {
 667                         delete pTheme, pTheme = NULL;
 668                     }
 669
 670                     delete pIStm;
 671                 }
 672             }
 673
 674             if( pTheme )
 675                 aThemeCache.push_back( new GalleryThemeCacheEntry( pThemeEntry, pTheme ));
 676         }
 677     }
 678
 679     return pTheme;
 680 }
 681
 682 // ------------------------------------------------------------------------
 683
 684 void Gallery::ImplDeleteCachedTheme( GalleryTheme* pTheme )
 685 {
 686     for (GalleryCacheThemeList::iterator it = aThemeCache.begin(); it != aThemeCache.end(); ++it)
 687     {
 688         if (pTheme == (*it)->GetTheme())
 689         {
 690             delete *it;
 691             aThemeCache.erase(it);
 692             break;
 693         }
 694     }
 695 }
 696
 697 // ------------------------------------------------------------------------
 698
 699 GalleryTheme* Gallery::AcquireTheme( const String& rThemeName, SfxListener& rListener )
 700 {
 701     GalleryTheme*           pTheme = NULL;
 702     GalleryThemeEntry*      pThemeEntry = ImplGetThemeEntry( rThemeName );
 703
 704     if( pThemeEntry && ( ( pTheme = ImplGetCachedTheme( pThemeEntry ) ) != NULL ) )
 705         rListener.StartListening( *pTheme );
 706
 707     return pTheme;
 708 }
 709
 710 // ------------------------------------------------------------------------
 711
 712 void Gallery::ReleaseTheme( GalleryTheme* pTheme, SfxListener& rListener )
 713 {
 714     if( pTheme )
 715     {
 716         rListener.EndListening( *pTheme );
 717
 718         if( !pTheme->HasListeners() )
 719             ImplDeleteCachedTheme( pTheme );
 720     }
 721 }
 722
 723 sal_Bool GalleryThemeEntry::IsDefault() const
 724 { return( ( nId > 0 ) && ( nId != ( RID_GALLERYSTR_THEME_MYTHEME - RID_GALLERYSTR_THEME_START ) ) ); }
 725
 726 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */