svx/source/gallery2/gallery1.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 // MARKER(update_precomp.py): autogen include statement, do not remove
  30 #include "precompiled_svx.hxx"
  31
  32 #define ENABLE_BYTESTRING_STREAM_OPERATORS
  33
  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
  47 #define ENABLE_BYTESTRING_STREAM_OPERATORS
  48
  49 // --------------
  50 // - Namespaces -
  51 // --------------
  52
  53 using namespace ::rtl;
  54 using namespace ::com::sun::star;
  55
  56 // ---------------------
  57 // - GalleryThemeEntry -
  58 // ---------------------
  59
  60 GalleryThemeEntry::GalleryThemeEntry( const INetURLObject& rBaseURL, const String& rName,
  61                                       sal_uInt32 _nFileNumber, sal_Bool _bReadOnly, sal_Bool _bImported,
  62                                       sal_Bool _bNewFile, sal_uInt32 _nId, sal_Bool _bThemeNameFromResource ) :
  63         nFileNumber                             ( _nFileNumber ),
  64         nId                                     ( _nId ),
  65         bReadOnly                               ( _bReadOnly || _bImported ),
  66         bImported                               ( _bImported ),
  67         bThemeNameFromResource  ( _bThemeNameFromResource )
  68 {
  69     INetURLObject aURL( rBaseURL );
  70     DBG_ASSERT( aURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
  71     String aFileName( String( RTL_CONSTASCII_USTRINGPARAM( "sg" ) ) );
  72
  73     aURL.Append( ( aFileName += String::CreateFromInt32( nFileNumber ) ) += String( RTL_CONSTASCII_USTRINGPARAM( ".thm" ) ) );
  74     aThmURL = ImplGetURLIgnoreCase( aURL );
  75
  76     aURL.setExtension( String( RTL_CONSTASCII_USTRINGPARAM( "sdg" ) ) );
  77     aSdgURL = ImplGetURLIgnoreCase( aURL );
  78
  79     aURL.setExtension( String( RTL_CONSTASCII_USTRINGPARAM( "sdv" ) ) );
  80     aSdvURL = ImplGetURLIgnoreCase( aURL );
  81
  82     SetModified( _bNewFile );
  83
  84     if( nId && bThemeNameFromResource )
  85         aName = String( GAL_RESID( RID_GALLERYSTR_THEME_START + (sal_uInt16) nId ) );
  86
  87     if( !aName.Len() )
  88         aName = rName;
  89 }
  90
  91 // -----------------------------------------------------------------------------
  92
  93 INetURLObject GalleryThemeEntry::ImplGetURLIgnoreCase( const INetURLObject& rURL ) const
  94 {
  95     INetURLObject   aURL( rURL );
  96     String          aFileName;
  97
  98     // check original file name
  99     if( !FileExists( aURL ) )
 100     {
 101         // check upper case file name
 102         aURL.setName( aURL.getName().toAsciiUpperCase() );
 103
 104         if(!FileExists( aURL ) )
 105         {
 106             // check lower case file name
 107             aURL.setName( aURL.getName().toAsciiLowerCase() );
 108         }
 109     }
 110
 111     return aURL;
 112 }
 113
 114 // -----------------------------------------------------------------------------
 115
 116 void GalleryThemeEntry::SetName( const String& rNewName )
 117 {
 118     if( aName != rNewName )
 119     {
 120         aName = rNewName;
 121         SetModified( sal_True );
 122         bThemeNameFromResource = sal_False;
 123     }
 124 }
 125
 126 // -----------------------------------------------------------------------------
 127
 128 void GalleryThemeEntry::SetId( sal_uInt32 nNewId, sal_Bool bResetThemeName )
 129 {
 130     nId = nNewId;
 131     SetModified( sal_True );
 132     bThemeNameFromResource = ( nId && bResetThemeName );
 133 }
 134
 135 // ---------------------------
 136 // - GalleryImportThemeEntry -
 137 // ---------------------------
 138
 139 SvStream& operator<<( SvStream& rOut, const GalleryImportThemeEntry& rEntry )
 140 {
 141     ByteString aDummy;
 142
 143     rOut << ByteString( rEntry.aThemeName, RTL_TEXTENCODING_UTF8 ) <<
 144             ByteString( rEntry.aUIName, RTL_TEXTENCODING_UTF8 ) <<
 145             ByteString( String(rEntry.aURL.GetMainURL( INetURLObject::NO_DECODE )), RTL_TEXTENCODING_UTF8 ) <<
 146             ByteString( rEntry.aImportName, RTL_TEXTENCODING_UTF8 ) <<
 147             aDummy;
 148
 149     return rOut;
 150 }
 151
 152 // ------------------------------------------------------------------------
 153
 154 SvStream& operator>>( SvStream& rIn, GalleryImportThemeEntry& rEntry )
 155 {
 156     ByteString aTmpStr;
 157
 158     rIn >> aTmpStr; rEntry.aThemeName = String( aTmpStr, RTL_TEXTENCODING_UTF8 );
 159     rIn >> aTmpStr; rEntry.aUIName = String( aTmpStr, RTL_TEXTENCODING_UTF8 );
 160     rIn >> aTmpStr; rEntry.aURL = INetURLObject( String( aTmpStr, RTL_TEXTENCODING_UTF8 ) );
 161     rIn >> aTmpStr; rEntry.aImportName = String( aTmpStr, RTL_TEXTENCODING_UTF8 );
 162     rIn >> aTmpStr;
 163
 164     return rIn;
 165 }
 166
 167 // --------------------------
 168 // - GalleryThemeCacheEntry -
 169 // --------------------------
 170
 171 class GalleryThemeCacheEntry
 172 {
 173 private:
 174
 175     const GalleryThemeEntry*        mpThemeEntry;
 176     GalleryTheme*                           mpTheme;
 177
 178 public:
 179
 180                                 GalleryThemeCacheEntry( const GalleryThemeEntry* pThemeEntry, GalleryTheme* pTheme ) :
 181                                     mpThemeEntry( pThemeEntry ), mpTheme( pTheme ) {}
 182                                 ~GalleryThemeCacheEntry() { delete mpTheme; }
 183
 184     const GalleryThemeEntry*        GetThemeEntry() const { return mpThemeEntry; }
 185     GalleryTheme*                           GetTheme() const { return mpTheme; }
 186 };
 187
 188 // -----------
 189 // - Gallery -
 190 // -----------
 191
 192 Gallery::Gallery( const String& rMultiPath )
 193 :       nReadTextEncoding   ( gsl_getSystemTextEncoding() )
 194 ,       nLastFileNumber     ( 0 )
 195 ,       bMultiPath          ( sal_False )
 196 {
 197     ImplLoad( rMultiPath );
 198 }
 199
 200 // ------------------------------------------------------------------------
 201
 202 Gallery::~Gallery()
 203 {
 204     // Themen-Liste loeschen
 205     for ( size_t i = 0, n = aThemeList.size(); i < n; ++i )
 206         delete aThemeList[ i ];
 207     aThemeList.clear();
 208
 209     // Import-Liste loeschen
 210     for ( size_t i = 0, n = aImportList.size(); i < n; ++i )
 211         delete aImportList[ i ];
 212     aImportList.clear();
 213 }
 214
 215 // ------------------------------------------------------------------------
 216
 217 Gallery* Gallery::GetGalleryInstance()
 218 {
 219     static Gallery* pGallery = NULL;
 220
 221     if( !pGallery )
 222     {
 223         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 224         if( !pGallery )
 225         {
 226             pGallery = new Gallery( SvtPathOptions().GetGalleryPath() );
 227         }
 228     }
 229
 230     return pGallery;
 231 }
 232
 233 // ------------------------------------------------------------------------
 234
 235 void Gallery::ImplLoad( const String& rMultiPath )
 236 {
 237     const sal_uInt16    nTokenCount = rMultiPath.GetTokenCount( ';' );
 238     sal_Bool        bIsReadOnlyDir;
 239
 240     bMultiPath = ( nTokenCount > 0 );
 241
 242     INetURLObject aCurURL(SvtPathOptions().GetConfigPath());
 243     ImplLoadSubDirs( aCurURL, bIsReadOnlyDir );
 244
 245     if( !bIsReadOnlyDir )
 246         aUserURL = aCurURL;
 247
 248     if( bMultiPath )
 249     {
 250         aRelURL = INetURLObject( rMultiPath.GetToken( 0, ';' ) );
 251
 252         for( sal_uInt16 i = 0UL; i < nTokenCount; i++ )
 253         {
 254             aCurURL = INetURLObject(rMultiPath.GetToken( i, ';' ));
 255
 256             ImplLoadSubDirs( aCurURL, bIsReadOnlyDir );
 257
 258             if( !bIsReadOnlyDir )
 259                 aUserURL = aCurURL;
 260         }
 261     }
 262     else
 263         aRelURL = INetURLObject( rMultiPath );
 264
 265     DBG_ASSERT( aUserURL.GetProtocol() != INET_PROT_NOT_VALID, "no writable Gallery user directory available" );
 266     DBG_ASSERT( aRelURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
 267
 268     ImplLoadImports();
 269 }
 270
 271 // ------------------------------------------------------------------------
 272
 273 void Gallery::ImplLoadSubDirs( const INetURLObject& rBaseURL, sal_Bool& rbDirIsReadOnly )
 274 {
 275     rbDirIsReadOnly = sal_False;
 276
 277     try
 278     {
 279         uno::Reference< ucb::XCommandEnvironment > xEnv;
 280         ::ucbhelper::Content                       aCnt( rBaseURL.GetMainURL( INetURLObject::NO_DECODE ), xEnv );
 281
 282         uno::Sequence< OUString > aProps( 1 );
 283         aProps.getArray()[ 0 ] = OUString(RTL_CONSTASCII_USTRINGPARAM("Url"));
 284
 285         uno::Reference< sdbc::XResultSet > xResultSet( aCnt.createCursor( aProps, ::ucbhelper::INCLUDE_DOCUMENTS_ONLY ) );
 286
 287         try
 288         {
 289             // check readonlyness the very hard way
 290             INetURLObject   aTestURL( rBaseURL );
 291             String          aTestFile( RTL_CONSTASCII_USTRINGPARAM( "cdefghij.klm" ) );
 292
 293             aTestURL.Append( aTestFile );
 294             SvStream* pTestStm = ::utl::UcbStreamHelper::CreateStream( aTestURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE );
 295
 296             if( pTestStm )
 297             {
 298                 *pTestStm << 1;
 299
 300                 if( pTestStm->GetError() )
 301                     rbDirIsReadOnly = sal_True;
 302
 303                 delete pTestStm;
 304                 KillFile( aTestURL );
 305             }
 306             else
 307                 rbDirIsReadOnly = sal_True;
 308         }
 309         catch( const ucb::ContentCreationException& )
 310         {
 311         }
 312         catch( const uno::RuntimeException& )
 313         {
 314         }
 315         catch( const uno::Exception& )
 316         {
 317         }
 318
 319         if( xResultSet.is() )
 320         {
 321             uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
 322
 323             if( xContentAccess.is() )
 324             {
 325                 while( xResultSet->next() )
 326                 {
 327                     INetURLObject aThmURL( xContentAccess->queryContentIdentifierString() );
 328
 329                     if(aThmURL.GetExtension().equalsIgnoreAsciiCaseAscii("thm"))
 330                     {
 331                         INetURLObject   aSdgURL( aThmURL); aSdgURL.SetExtension( OUString(RTL_CONSTASCII_USTRINGPARAM("sdg")) );
 332                         INetURLObject   aSdvURL( aThmURL ); aSdvURL.SetExtension( OUString(RTL_CONSTASCII_USTRINGPARAM("sdv")) );
 333                         const OUString aTitleProp( RTL_CONSTASCII_USTRINGPARAM("Title") );
 334                         const OUString aReadOnlyProp( RTL_CONSTASCII_USTRINGPARAM("IsReadOnly") );
 335                         OUString        aTitle;
 336                         sal_Bool        bReadOnly = sal_False;
 337
 338                         try
 339                         {
 340                             ::ucbhelper::Content aThmCnt( aThmURL.GetMainURL( INetURLObject::NO_DECODE ), xEnv );
 341                             ::ucbhelper::Content aSdgCnt( aSdgURL.GetMainURL( INetURLObject::NO_DECODE ), xEnv );
 342                             ::ucbhelper::Content aSdvCnt( aSdvURL.GetMainURL( INetURLObject::NO_DECODE ), xEnv );
 343
 344                             try
 345                             {
 346                                 aThmCnt.getPropertyValue( aTitleProp ) >>= aTitle;
 347                             }
 348                             catch( const uno::RuntimeException& )
 349                             {
 350                             }
 351                             catch( const uno::Exception& )
 352                             {
 353                             }
 354
 355                             if( aTitle.getLength() )
 356                             {
 357                                 try
 358                                 {
 359                                     aThmCnt.getPropertyValue( aReadOnlyProp ) >>= bReadOnly;
 360                                 }
 361                                 catch( const uno::RuntimeException& )
 362                                 {
 363                                 }
 364                                 catch( const uno::Exception& )
 365                                 {
 366                                 }
 367
 368                                 if( !bReadOnly )
 369                                 {
 370                                     try
 371                                     {
 372                                         aSdgCnt.getPropertyValue( aTitleProp ) >>= aTitle;
 373                                     }
 374                                     catch( const ::com::sun::star::uno::RuntimeException& )
 375                                     {
 376                                     }
 377                                     catch( const ::com::sun::star::uno::Exception& )
 378                                     {
 379                                     }
 380
 381                                     if( aTitle.getLength() )
 382                                     {
 383                                         try
 384                                         {
 385                                             aSdgCnt.getPropertyValue( aReadOnlyProp ) >>= bReadOnly;
 386                                         }
 387                                         catch( const uno::RuntimeException& )
 388                                         {
 389                                         }
 390                                         catch( const uno::Exception& )
 391                                         {
 392                                         }
 393                                     }
 394                                 }
 395
 396                                 if( !bReadOnly )
 397                                 {
 398                                     try
 399                                     {
 400                                         aSdvCnt.getPropertyValue( aTitleProp ) >>= aTitle;
 401                                     }
 402                                     catch( const ::com::sun::star::uno::RuntimeException& )
 403                                     {
 404                                     }
 405                                     catch( const ::com::sun::star::uno::Exception& )
 406                                     {
 407                                     }
 408
 409                                     if( aTitle.getLength() )
 410                                     {
 411                                         try
 412                                         {
 413                                             aSdvCnt.getPropertyValue( aReadOnlyProp ) >>= bReadOnly;
 414                                         }
 415                                         catch( const uno::RuntimeException& )
 416                                         {
 417                                         }
 418                                         catch( const uno::Exception& )
 419                                         {
 420                                         }
 421                                     }
 422                                 }
 423
 424                                 GalleryThemeEntry* pEntry = GalleryTheme::CreateThemeEntry( aThmURL, rbDirIsReadOnly || bReadOnly );
 425
 426                                 if( pEntry )
 427                                 {
 428                                     const sal_uIntPtr nFileNumber = (sal_uIntPtr) String(aThmURL.GetBase()).Erase( 0, 2 ).Erase( 6 ).ToInt32();
 429
 430                                     aThemeList.push_back( pEntry );
 431
 432                                     if( nFileNumber > nLastFileNumber )
 433                                         nLastFileNumber = nFileNumber;
 434                                 }
 435                             }
 436                         }
 437                         catch( const ucb::ContentCreationException& )
 438                         {
 439                         }
 440                         catch( const uno::RuntimeException& )
 441                         {
 442                         }
 443                         catch( const uno::Exception& )
 444                         {
 445                         }
 446                     }
 447                 }
 448             }
 449         }
 450     }
 451     catch( const ucb::ContentCreationException& )
 452     {
 453     }
 454     catch( const uno::RuntimeException& )
 455     {
 456     }
 457     catch( const uno::Exception& )
 458     {
 459     }
 460 }
 461
 462 // ------------------------------------------------------------------------
 463
 464 void Gallery::ImplLoadImports()
 465 {
 466     INetURLObject aURL( GetUserURL() );
 467
 468     aURL.Append( String( RTL_CONSTASCII_USTRINGPARAM( "gallery.sdi" ) ) );
 469
 470     if( FileExists( aURL ) )
 471     {
 472         SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( aURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ );
 473
 474         if( pIStm )
 475         {
 476             GalleryThemeEntry*          pThemeEntry;
 477             GalleryImportThemeEntry*    pImportEntry;
 478             INetURLObject               aFile;
 479             sal_uInt32                      nInventor;
 480             sal_uInt32                      nCount;
 481             sal_uInt16                      nId;
 482             sal_uInt16                      i;
 483             sal_uInt16                      nTempCharSet;
 484
 485             for ( size_t j = 0, n = aImportList.size(); j < n; ++j )
 486                 delete aImportList[ j ];
 487             aImportList.clear();
 488
 489             *pIStm >> nInventor;
 490
 491             if( nInventor == COMPAT_FORMAT( 'S', 'G', 'A', '3' ) )
 492             {
 493                 *pIStm >> nId >> nCount >> nTempCharSet;
 494
 495                 for( i = 0; i < nCount; i++ )
 496                 {
 497                     pImportEntry = new GalleryImportThemeEntry;
 498
 499                     *pIStm >> *pImportEntry;
 500                     aImportList.push_back( pImportEntry );
 501                     aFile = INetURLObject( pImportEntry->aURL );
 502                     pThemeEntry = new GalleryThemeEntry( aFile,
 503                                                          pImportEntry->aUIName,
 504                                                          String(aFile.GetBase()).Erase( 0, 2 ).Erase( 6 ).ToInt32(),
 505                                                          sal_True, sal_True, sal_False, 0, sal_False );
 506
 507                     aThemeList.push_back( pThemeEntry );
 508                 }
 509             }
 510
 511             delete pIStm;
 512         }
 513     }
 514 }
 515
 516 // ------------------------------------------------------------------------
 517
 518 void Gallery::ImplWriteImportList()
 519 {
 520     INetURLObject aURL( GetUserURL() );
 521     aURL.Append( ( String( "gallery.sdi", RTL_TEXTENCODING_UTF8 ) ) );
 522     SvStream* pOStm = ::utl::UcbStreamHelper::CreateStream( aURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE | STREAM_TRUNC );
 523
 524     if( pOStm )
 525     {
 526         const sal_uInt32 nInventor = (sal_uInt32) COMPAT_FORMAT( 'S', 'G', 'A', '3' );
 527         const sal_uInt16 nId = 0x0004;
 528
 529         *pOStm << nInventor << nId << (sal_uInt32) aImportList.size() << (sal_uInt16) gsl_getSystemTextEncoding();
 530
 531         for ( size_t i = 0, n = aImportList.size(); i < n; ++i )
 532             *pOStm << *aImportList[ i ];
 533
 534         if( pOStm->GetError() )
 535             ErrorHandler::HandleError( ERRCODE_IO_GENERAL );
 536
 537         delete pOStm;
 538     }
 539 }
 540
 541 // ------------------------------------------------------------------------
 542
 543 GalleryThemeEntry* Gallery::ImplGetThemeEntry( const String& rThemeName )
 544 {
 545     GalleryThemeEntry* pFound = NULL;
 546
 547     if( rThemeName.Len() )
 548         for ( size_t i = 0, n = aThemeList.size(); i < n && !pFound; ++i )
 549             if( rThemeName == aThemeList[ i ]->GetThemeName() )
 550                 pFound = aThemeList[ i ];
 551
 552     return pFound;
 553 }
 554
 555 // ------------------------------------------------------------------------
 556
 557 GalleryImportThemeEntry* Gallery::ImplGetImportThemeEntry( const String& rImportName )
 558 {
 559     for ( size_t i = 0, n = aImportList.size(); i < n; ++i )
 560         if ( rImportName == aImportList[ i ]->aUIName )
 561             return aImportList[ i ];
 562     return NULL;
 563 }
 564
 565 // ------------------------------------------------------------------------
 566
 567 String Gallery::GetThemeName( sal_uIntPtr nThemeId ) const
 568 {
 569     GalleryThemeEntry* pFound = NULL;
 570
 571     for ( size_t i = 0, n = aThemeList.size(); i < n && !pFound; ++i )
 572     {
 573         GalleryThemeEntry* pEntry = aThemeList[ i ];
 574         if( nThemeId == pEntry->GetId() )
 575             pFound = pEntry;
 576     }
 577
 578     // try fallback, if no entry was found
 579     if( !pFound )
 580     {
 581         ByteString      aFallback;
 582
 583         switch( nThemeId )
 584         {
 585             case( GALLERY_THEME_3D ): aFallback = "3D"; break;
 586             case( GALLERY_THEME_BULLETS ): aFallback = "Bullets"; break;
 587             case( GALLERY_THEME_HOMEPAGE ): aFallback = "Homepage"; break;
 588             case( GALLERY_THEME_HTMLBUTTONS ): aFallback = "private://gallery/hidden/HtmlExportButtons"; break;
 589             case( GALLERY_THEME_POWERPOINT ): aFallback = "private://gallery/hidden/imgppt"; break;
 590             case( GALLERY_THEME_FONTWORK ): aFallback = "private://gallery/hidden/fontwork"; break;
 591             case( GALLERY_THEME_FONTWORK_VERTICAL ): aFallback = "private://gallery/hidden/fontworkvertical"; break;
 592             case( GALLERY_THEME_RULERS ): aFallback = "Rulers"; break;
 593             case( GALLERY_THEME_SOUNDS ): aFallback = "Sounds"; break;
 594
 595             default:
 596             break;
 597         }
 598
 599         pFound = ( (Gallery*) this )->ImplGetThemeEntry( String::CreateFromAscii( aFallback.GetBuffer() ) );
 600     }
 601
 602     return( pFound ? pFound->GetThemeName() : String() );
 603 }
 604
 605 // ------------------------------------------------------------------------
 606
 607 sal_Bool Gallery::HasTheme( const String& rThemeName )
 608 {
 609     return( ImplGetThemeEntry( rThemeName ) != NULL );
 610 }
 611
 612 // ------------------------------------------------------------------------
 613
 614 sal_Bool Gallery::CreateTheme( const String& rThemeName, sal_uInt32 nNumFrom )
 615 {
 616     sal_Bool bRet = sal_False;
 617
 618     if( !HasTheme( rThemeName ) && ( GetUserURL().GetProtocol() != INET_PROT_NOT_VALID ) )
 619     {
 620         nLastFileNumber = nNumFrom > nLastFileNumber ? nNumFrom : nLastFileNumber + 1;
 621         GalleryThemeEntry* pNewEntry = new GalleryThemeEntry( GetUserURL(), rThemeName,
 622                                                               nLastFileNumber,
 623                                                               sal_False, sal_False, sal_True, 0, sal_False );
 624
 625         aThemeList.push_back( pNewEntry );
 626         delete( new GalleryTheme( this, pNewEntry ) );
 627         Broadcast( GalleryHint( GALLERY_HINT_THEME_CREATED, rThemeName ) );
 628         bRet = sal_True;
 629     }
 630
 631     return bRet;
 632 }
 633
 634 // ------------------------------------------------------------------------
 635
 636 sal_Bool Gallery::RenameTheme( const String& rOldName, const String& rNewName )
 637 {
 638     GalleryThemeEntry*      pThemeEntry = ImplGetThemeEntry( rOldName );
 639     sal_Bool                            bRet = sal_False;
 640
 641     // Ueberpruefen, ob neuer Themenname schon vorhanden ist
 642     if( pThemeEntry && !HasTheme( rNewName ) && ( !pThemeEntry->IsReadOnly() || pThemeEntry->IsImported() ) )
 643     {
 644         SfxListener   aListener;
 645         GalleryTheme* pThm = AcquireTheme( rOldName, aListener );
 646
 647         if( pThm )
 648         {
 649             const String aOldName( rOldName );
 650
 651             pThemeEntry->SetName( rNewName );
 652             pThm->ImplWrite();
 653
 654             if( pThemeEntry->IsImported() )
 655             {
 656                 pThm->SetImportName( rNewName );
 657
 658                 GalleryImportThemeEntry* pImportEntry = ImplGetImportThemeEntry( rOldName );
 659
 660                 if( pImportEntry )
 661                 {
 662                     pImportEntry->aUIName = rNewName;
 663                     ImplWriteImportList();
 664                 }
 665             }
 666
 667             Broadcast( GalleryHint( GALLERY_HINT_THEME_RENAMED, aOldName, pThm->GetName() ) );
 668             ReleaseTheme( pThm, aListener );
 669             bRet = sal_True;
 670         }
 671     }
 672
 673     return bRet;
 674 }
 675
 676 // ------------------------------------------------------------------------
 677
 678 sal_Bool Gallery::RemoveTheme( const String& rThemeName )
 679 {
 680     GalleryThemeEntry*  pThemeEntry = ImplGetThemeEntry( rThemeName );
 681     sal_Bool                bRet = sal_False;
 682
 683     if( pThemeEntry && ( !pThemeEntry->IsReadOnly() || pThemeEntry->IsImported() ) )
 684     {
 685         Broadcast( GalleryHint( GALLERY_HINT_CLOSE_THEME, rThemeName ) );
 686
 687         if( pThemeEntry->IsImported() )
 688         {
 689             GalleryImportThemeEntry* pImportEntry = ImplGetImportThemeEntry( rThemeName );
 690
 691             if( pImportEntry )
 692             {
 693                 for ( GalleryImportThemeList::iterator it = aImportList.begin(); it < aImportList.end(); ++it )
 694                 {
 695                     if ( *it == pImportEntry )
 696                     {
 697                         delete pImportEntry;
 698                         aImportList.erase( it );
 699                         break;
 700                     }
 701                 }
 702             }
 703         }
 704         else
 705         {
 706             SfxListener     aListener;
 707             GalleryTheme*   pThm = AcquireTheme( rThemeName, aListener );
 708
 709             if( pThm )
 710             {
 711                 INetURLObject   aThmURL( pThm->GetThmURL() );
 712                 INetURLObject   aSdgURL( pThm->GetSdgURL() );
 713                 INetURLObject   aSdvURL( pThm->GetSdvURL() );
 714
 715                 ReleaseTheme( pThm, aListener );
 716
 717                 KillFile( aThmURL );
 718                 KillFile( aSdgURL );
 719                 KillFile( aSdvURL );
 720             }
 721         }
 722
 723         for ( GalleryThemeList::iterator it = aThemeList.begin(); it < aThemeList.end(); ++it )
 724         {
 725             if ( pThemeEntry == *it ) {
 726                 delete pThemeEntry;
 727                 aThemeList.erase( it );
 728                 break;
 729             }
 730         }
 731
 732         Broadcast( GalleryHint( GALLERY_HINT_THEME_REMOVED, rThemeName ) );
 733
 734         bRet = sal_True;
 735     }
 736
 737     return bRet;
 738 }
 739
 740 // ------------------------------------------------------------------------
 741
 742 INetURLObject Gallery::GetImportURL( const String& rThemeName )
 743 {
 744     INetURLObject               aURL;
 745     GalleryImportThemeEntry*    pImportEntry = ImplGetImportThemeEntry( rThemeName );
 746
 747     if( pImportEntry )
 748     {
 749         aURL = pImportEntry->aURL;
 750         DBG_ASSERT( aURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
 751     }
 752
 753     return aURL;
 754 }
 755
 756 // ------------------------------------------------------------------------
 757
 758 GalleryTheme* Gallery::ImplGetCachedTheme( const GalleryThemeEntry* pThemeEntry )
 759 {
 760     GalleryTheme* pTheme = NULL;
 761
 762     if( pThemeEntry )
 763     {
 764         for (GalleryCacheThemeList::const_iterator it = aThemeCache.begin(); it != aThemeCache.end(); ++it)
 765         {
 766             if (pThemeEntry == (*it)->GetThemeEntry())
 767             {
 768                 pTheme = (*it)->GetTheme();
 769                 break;
 770             }
 771         }
 772
 773         if( !pTheme )
 774         {
 775             INetURLObject aURL;
 776
 777             if( !pThemeEntry->IsImported() )
 778                 aURL = pThemeEntry->GetThmURL();
 779             else
 780                 aURL = GetImportURL( pThemeEntry->GetThemeName() );
 781
 782             DBG_ASSERT( aURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
 783
 784             if( FileExists( aURL ) )
 785             {
 786                 SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( aURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ );
 787
 788                 if( pIStm )
 789                 {
 790                     pTheme = new GalleryTheme( this, (GalleryThemeEntry*) pThemeEntry );
 791                     *pIStm >> *pTheme;
 792
 793                     if( pIStm->GetError() )
 794                         delete pTheme, pTheme = NULL;
 795                     else if( pThemeEntry->IsImported() )
 796                         pTheme->SetImportName( pThemeEntry->GetThemeName() );
 797
 798                     delete pIStm;
 799                 }
 800             }
 801
 802             if( pTheme )
 803                 aThemeCache.push_back( new GalleryThemeCacheEntry( pThemeEntry, pTheme ));
 804         }
 805     }
 806
 807     return pTheme;
 808 }
 809
 810 // ------------------------------------------------------------------------
 811
 812 void Gallery::ImplDeleteCachedTheme( GalleryTheme* pTheme )
 813 {
 814     for (GalleryCacheThemeList::iterator it = aThemeCache.begin(); it != aThemeCache.end(); ++it)
 815     {
 816         if (pTheme == (*it)->GetTheme())
 817         {
 818             delete *it;
 819             aThemeCache.erase(it);
 820             break;
 821         }
 822     }
 823 }
 824
 825 // ------------------------------------------------------------------------
 826
 827 GalleryTheme* Gallery::AcquireTheme( const String& rThemeName, SfxListener& rListener )
 828 {
 829     GalleryTheme*           pTheme = NULL;
 830     GalleryThemeEntry*      pThemeEntry = ImplGetThemeEntry( rThemeName );
 831
 832     if( pThemeEntry && ( ( pTheme = ImplGetCachedTheme( pThemeEntry ) ) != NULL ) )
 833         rListener.StartListening( *pTheme );
 834
 835     return pTheme;
 836 }
 837
 838 // ------------------------------------------------------------------------
 839
 840 void Gallery::ReleaseTheme( GalleryTheme* pTheme, SfxListener& rListener )
 841 {
 842     if( pTheme )
 843     {
 844         rListener.EndListening( *pTheme );
 845
 846         if( !pTheme->HasListeners() )
 847             ImplDeleteCachedTheme( pTheme );
 848     }
 849 }
 850
 851 sal_Bool GalleryThemeEntry::IsDefault() const
 852 { return( ( nId > 0 ) && ( nId != ( RID_GALLERYSTR_THEME_MYTHEME - RID_GALLERYSTR_THEME_START ) ) ); }
 853
 854 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */