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