svx/source/gallery2/gallery1.cxx

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