svx/source/gallery2/galtheme.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: galtheme.cxx,v $
  10  * $Revision: 1.50 $
  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/urlobj.hxx>
  37 #include <tools/vcompat.hxx>
  38 #include <unotools/streamwrap.hxx>
  39 #include <unotools/ucbstreamhelper.hxx>
  40 #include <unotools/tempfile.hxx>
  41 #include <unotools/localfilehelper.hxx>
  42 #include <ucbhelper/content.hxx>
  43 #include <sot/storage.hxx>
  44 #include <sot/formats.hxx>
  45 #include <sot/filelist.hxx>
  46 #include <vcl/virdev.hxx>
  47 #include <vcl/cvtgrf.hxx>
  48 #include <svtools/itempool.hxx>
  49 #include <sfx2/docfile.hxx>
  50 #include <avmedia/mediawindow.hxx>
  51 #include <svx/svdograf.hxx>
  52 #include <svx/fmpage.hxx>
  53 #include "codec.hxx"
  54 #include <svx/unomodel.hxx>
  55 #include <svx/fmmodel.hxx>
  56 #include <svx/fmview.hxx>
  57 #include "galmisc.hxx"
  58 #include "galtheme.hxx"
  59 #include <com/sun/star/sdbc/XResultSet.hpp>
  60 #include <com/sun/star/ucb/XContentAccess.hpp>
  61 #include <com/sun/star/io/XInputStream.hpp>
  62
  63 #include "gallerydrawmodel.hxx"
  64
  65 // --------------
  66 // - Namespaces -
  67 // --------------
  68
  69 using namespace ::rtl;
  70 using namespace ::com::sun::star;
  71
  72 // ------------
  73 // - SgaTheme -
  74 // ------------
  75
  76 GalleryTheme::GalleryTheme( Gallery* pGallery, GalleryThemeEntry* pThemeEntry ) :
  77         pParent               ( pGallery ),
  78         pThm                      ( pThemeEntry ),
  79         mnThemeLockCount      ( 0 ),
  80         mnBroadcasterLockCount( 0 ),
  81         nDragPos                  ( 0 ),
  82         bDragging                 ( FALSE )
  83 {
  84     ImplCreateSvDrawStorage();
  85
  86     if( pThm->IsImported() )
  87         aImportName = pThm->GetThemeName();
  88 }
  89
  90 // ------------------------------------------------------------------------
  91
  92 GalleryTheme::~GalleryTheme()
  93 {
  94     ImplWrite();
  95
  96     for( GalleryObject* pEntry = aObjectList.First(); pEntry; pEntry = aObjectList.Next() )
  97     {
  98         Broadcast( GalleryHint( GALLERY_HINT_CLOSE_OBJECT, GetName(), reinterpret_cast< ULONG >( pEntry ) ) );
  99         delete pEntry;
 100         Broadcast( GalleryHint( GALLERY_HINT_OBJECT_REMOVED, GetName(), reinterpret_cast< ULONG >( pEntry ) ) );
 101     }
 102 }
 103
 104 // ------------------------------------------------------------------------
 105
 106 void GalleryTheme::ImplCreateSvDrawStorage()
 107 {
 108     if( !pThm->IsImported() )
 109     {
 110         aSvDrawStorageRef = new SvStorage( FALSE, GetSdvURL().GetMainURL( INetURLObject::NO_DECODE ), pThm->IsReadOnly() ? STREAM_READ : STREAM_STD_READWRITE );
 111         // #i50423# ReadOnly may not been set though the file can't be written (because of security reasons)
 112         if ( ( aSvDrawStorageRef->GetError() != ERRCODE_NONE ) && !pThm->IsReadOnly() )
 113             aSvDrawStorageRef = new SvStorage( FALSE, GetSdvURL().GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ );
 114     }
 115     else
 116         aSvDrawStorageRef.Clear();
 117 }
 118
 119 // ------------------------------------------------------------------------
 120
 121 BOOL GalleryTheme::ImplWriteSgaObject( const SgaObject& rObj, ULONG nPos, GalleryObject* pExistentEntry )
 122 {
 123     SvStream*   pOStm = ::utl::UcbStreamHelper::CreateStream( GetSdgURL().GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE );
 124     BOOL                bRet = FALSE;
 125
 126     if( pOStm )
 127     {
 128         const sal_uInt32 nOffset = pOStm->Seek( STREAM_SEEK_TO_END );
 129
 130         rObj.WriteData( *pOStm, m_aDestDir );
 131
 132         if( !pOStm->GetError() )
 133         {
 134             GalleryObject* pEntry;
 135
 136             if( !pExistentEntry )
 137             {
 138                 pEntry = new GalleryObject;
 139                 aObjectList.Insert( pEntry, nPos );
 140             }
 141             else
 142                 pEntry = pExistentEntry;
 143
 144             pEntry->aURL = rObj.GetURL();
 145             pEntry->nOffset = nOffset;
 146             pEntry->eObjKind = rObj.GetObjKind();
 147             bRet = TRUE;
 148         }
 149
 150         delete pOStm;
 151     }
 152
 153     return bRet;
 154 }
 155
 156 // ------------------------------------------------------------------------
 157
 158 SgaObject* GalleryTheme::ImplReadSgaObject( GalleryObject* pEntry )
 159 {
 160     SgaObject* pSgaObj = NULL;
 161
 162     if( pEntry )
 163     {
 164         SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( GetSdgURL().GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ );
 165
 166         if( pIStm )
 167         {
 168             sal_uInt32 nInventor;
 169
 170             // Ueberpruefen, ob das File ein gueltiges SGA-File ist
 171             pIStm->Seek( pEntry->nOffset );
 172             *pIStm >> nInventor;
 173
 174             if( nInventor == COMPAT_FORMAT( 'S', 'G', 'A', '3' ) )
 175             {
 176                 pIStm->Seek( pEntry->nOffset );
 177
 178                 switch( pEntry->eObjKind )
 179                 {
 180                     case( SGA_OBJ_BMP ):        pSgaObj = new SgaObjectBmp(); break;
 181                     case( SGA_OBJ_ANIM ):       pSgaObj = new SgaObjectAnim(); break;
 182                     case( SGA_OBJ_INET ):       pSgaObj = new SgaObjectINet(); break;
 183                     case( SGA_OBJ_SVDRAW ):     pSgaObj = new SgaObjectSvDraw(); break;
 184                     case( SGA_OBJ_SOUND ):      pSgaObj = new SgaObjectSound(); break;
 185
 186                     default:
 187                     break;
 188                 }
 189
 190                 if( pSgaObj )
 191                 {
 192                     *pIStm >> *pSgaObj;
 193                     pSgaObj->ImplUpdateURL( pEntry->aURL );
 194                 }
 195             }
 196
 197             delete pIStm;
 198         }
 199     }
 200
 201     return pSgaObj;
 202 }
 203
 204 // ------------------------------------------------------------------------
 205
 206 void GalleryTheme::ImplRead()
 207 {
 208     SvStream* pIStm     = ::utl::UcbStreamHelper::CreateStream( GetThmURL().GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ );
 209
 210     if( pIStm )
 211     {
 212         *pIStm >> *this;
 213         delete pIStm;
 214     }
 215 }
 216
 217 // ------------------------------------------------------------------------
 218
 219 void GalleryTheme::ImplWrite()
 220 {
 221     if( IsModified() )
 222     {
 223         INetURLObject aPathURL( GetThmURL() );
 224
 225         aPathURL.removeSegment();
 226         aPathURL.removeFinalSlash();
 227
 228         DBG_ASSERT( aPathURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
 229
 230         if( FileExists( aPathURL ) || CreateDir( aPathURL ) )
 231         {
 232 #ifdef UNX
 233             SvStream* pOStm     = ::utl::UcbStreamHelper::CreateStream( GetThmURL().GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE | STREAM_COPY_ON_SYMLINK | STREAM_TRUNC );
 234 #else
 235             SvStream* pOStm     = ::utl::UcbStreamHelper::CreateStream( GetThmURL().GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE | STREAM_TRUNC );
 236 #endif
 237
 238             if( pOStm )
 239             {
 240                 *pOStm << *this;
 241                 delete pOStm;
 242             }
 243
 244             ImplSetModified( FALSE );
 245         }
 246     }
 247 }
 248
 249 // ------------------------------------------------------------------------
 250
 251 const GalleryObject* GalleryTheme::ImplGetGalleryObject( const INetURLObject& rURL )
 252 {
 253     GalleryObject*      pEntry = aObjectList.First();
 254     GalleryObject*      pFoundEntry = NULL;
 255
 256     for( ; pEntry && !pFoundEntry; pEntry = aObjectList.Next() )
 257         if( pEntry->aURL == rURL )
 258             pFoundEntry = pEntry;
 259
 260     return pFoundEntry;
 261 }
 262
 263 // ------------------------------------------------------------------------
 264
 265 INetURLObject GalleryTheme::ImplGetURL( const GalleryObject* pObject ) const
 266 {
 267     INetURLObject aURL;
 268
 269     if( pObject )
 270     {
 271         if( IsImported() )
 272         {
 273             INetURLObject aPathURL( GetParent()->GetImportURL( GetName() ) );
 274
 275             aPathURL.removeSegment();
 276             aPathURL.removeFinalSlash();
 277             aPathURL.Append( pObject->aURL.GetName() );
 278             aURL = aPathURL;
 279         }
 280         else
 281             aURL = pObject->aURL;
 282     }
 283
 284     return aURL;
 285 }
 286
 287 // ------------------------------------------------------------------------
 288
 289 INetURLObject GalleryTheme::ImplCreateUniqueURL( SgaObjKind eObjKind, ULONG nFormat )
 290 {
 291     INetURLObject   aDir( GetParent()->GetUserURL() );
 292     INetURLObject   aInfoFileURL( GetParent()->GetUserURL() );
 293     INetURLObject   aNewURL;
 294     sal_uInt32          nNextNumber = 1999;
 295     sal_Char const* pExt = NULL;
 296     BOOL            bExists;
 297
 298     aDir.Append( String( RTL_CONSTASCII_USTRINGPARAM( "dragdrop" ) ) );
 299     CreateDir( aDir );
 300
 301     aInfoFileURL.Append( String( RTL_CONSTASCII_USTRINGPARAM( "sdddndx1" ) ) );
 302
 303     // read next possible number
 304     if( FileExists( aInfoFileURL ) )
 305     {
 306         SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( aInfoFileURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ );
 307
 308         if( pIStm )
 309         {
 310             *pIStm >> nNextNumber;
 311             delete pIStm;
 312         }
 313     }
 314
 315     // create extension
 316     if( nFormat )
 317     {
 318         switch( nFormat )
 319         {
 320             case( CVT_BMP ): pExt = ".bmp"; break;
 321             case( CVT_GIF ): pExt = ".gif"; break;
 322             case( CVT_JPG ): pExt = ".jpg"; break;
 323             case( CVT_MET ): pExt = ".met"; break;
 324             case( CVT_PCT ): pExt = ".pct"; break;
 325             case( CVT_PNG ): pExt = ".png"; break;
 326             case( CVT_SVM ): pExt = ".svm"; break;
 327             case( CVT_TIF ): pExt = ".tif"; break;
 328             case( CVT_WMF ): pExt = ".wmf"; break;
 329             case( CVT_EMF ): pExt = ".emf"; break;
 330
 331             default:
 332                 pExt = ".grf";
 333             break;
 334         }
 335     }
 336
 337     do
 338     {
 339         // get URL
 340         if( SGA_OBJ_SVDRAW == eObjKind )
 341         {
 342             String aFileName( RTL_CONSTASCII_USTRINGPARAM( "gallery/svdraw/dd" ) );
 343             aNewURL = INetURLObject( aFileName += String::CreateFromInt32( ++nNextNumber % 99999999 ), INET_PROT_PRIV_SOFFICE );
 344
 345             bExists = FALSE;
 346
 347             for( GalleryObject* pEntry = aObjectList.First(); pEntry && !bExists; pEntry = aObjectList.Next() )
 348                 if( pEntry->aURL == aNewURL )
 349                     bExists = TRUE;
 350         }
 351         else
 352         {
 353             String aFileName( RTL_CONSTASCII_USTRINGPARAM( "dd" ) );
 354
 355             aFileName += String::CreateFromInt32( ++nNextNumber % 999999 );
 356             aFileName += String( pExt, RTL_TEXTENCODING_ASCII_US );
 357
 358             aNewURL = aDir;
 359             aNewURL.Append( aFileName );
 360
 361             bExists = FileExists( aNewURL );
 362         }
 363     }
 364     while( bExists );
 365
 366     // write updated number
 367     SvStream* pOStm = ::utl::UcbStreamHelper::CreateStream( aInfoFileURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE );
 368
 369     if( pOStm )
 370     {
 371         *pOStm << nNextNumber;
 372         delete pOStm;
 373     }
 374
 375     return aNewURL;
 376 }
 377
 378 // ------------------------------------------------------------------------
 379
 380 void GalleryTheme::ImplBroadcast( ULONG nUpdatePos )
 381 {
 382     if( !IsBroadcasterLocked() )
 383     {
 384         if( GetObjectCount() && ( nUpdatePos >= GetObjectCount() ) )
 385             nUpdatePos = GetObjectCount() - 1;
 386
 387         Broadcast( GalleryHint( GALLERY_HINT_THEME_UPDATEVIEW, GetName(), nUpdatePos ) );
 388     }
 389 }
 390
 391 // ------------------------------------------------------------------------
 392
 393 BOOL GalleryTheme::UnlockTheme()
 394 {
 395     DBG_ASSERT( mnThemeLockCount, "Theme is not locked" );
 396
 397     BOOL bRet = FALSE;
 398
 399     if( mnThemeLockCount )
 400     {
 401         --mnThemeLockCount;
 402         bRet = TRUE;
 403     }
 404
 405     return bRet;
 406 }
 407
 408 // ------------------------------------------------------------------------
 409
 410 void GalleryTheme::UnlockBroadcaster( ULONG nUpdatePos )
 411 {
 412     DBG_ASSERT( mnBroadcasterLockCount, "Broadcaster is not locked" );
 413
 414     if( mnBroadcasterLockCount && !--mnBroadcasterLockCount )
 415         ImplBroadcast( nUpdatePos );
 416 }
 417
 418 // ------------------------------------------------------------------------
 419
 420 BOOL GalleryTheme::InsertObject( const SgaObject& rObj, ULONG nInsertPos )
 421 {
 422     BOOL bRet = FALSE;
 423
 424     if( rObj.IsValid() )
 425     {
 426         GalleryObject*  pEntry = aObjectList.First();
 427         GalleryObject*  pFoundEntry = NULL;
 428
 429         for( ; pEntry && !pFoundEntry; pEntry = aObjectList.Next() )
 430             if( pEntry->aURL == rObj.GetURL() )
 431                 pFoundEntry = pEntry;
 432
 433         if( pFoundEntry )
 434         {
 435             GalleryObject aNewEntry;
 436
 437             // update title of new object if neccessary
 438             if( !rObj.GetTitle().Len() )
 439             {
 440                 SgaObject* pOldObj = ImplReadSgaObject( pFoundEntry );
 441
 442                 if( pOldObj )
 443                 {
 444                     ( (SgaObject&) rObj ).SetTitle( pOldObj->GetTitle() );
 445                     delete pOldObj;
 446                 }
 447             }
 448             else if( rObj.GetTitle() == String( RTL_CONSTASCII_USTRINGPARAM( "__<empty>__" ) ) )
 449                 ( (SgaObject&) rObj ).SetTitle( String() );
 450
 451             ImplWriteSgaObject( rObj, nInsertPos, &aNewEntry );
 452             pFoundEntry->nOffset = aNewEntry.nOffset;
 453         }
 454         else
 455             ImplWriteSgaObject( rObj, nInsertPos, NULL );
 456
 457         ImplSetModified( bRet = TRUE );
 458         ImplBroadcast( pFoundEntry ? aObjectList.GetPos( pFoundEntry ) : nInsertPos );
 459     }
 460
 461     return bRet;
 462 }
 463
 464 // ------------------------------------------------------------------------
 465
 466 SgaObject* GalleryTheme::AcquireObject( ULONG nPos )
 467 {
 468     return ImplReadSgaObject( aObjectList.GetObject( nPos ) );
 469 }
 470
 471 // ------------------------------------------------------------------------
 472
 473 void GalleryTheme::ReleaseObject( SgaObject* pObject )
 474 {
 475     delete pObject;
 476 }
 477
 478 // ------------------------------------------------------------------------
 479
 480 BOOL GalleryTheme::RemoveObject( ULONG nPos )
 481 {
 482     GalleryObject* pEntry = aObjectList.Remove( nPos );
 483
 484     if( !aObjectList.Count() )
 485         KillFile( GetSdgURL() );
 486
 487     if( pEntry )
 488     {
 489         if( SGA_OBJ_SVDRAW == pEntry->eObjKind )
 490             aSvDrawStorageRef->Remove( pEntry->aURL.GetMainURL( INetURLObject::NO_DECODE ) );
 491
 492         Broadcast( GalleryHint( GALLERY_HINT_CLOSE_OBJECT, GetName(), reinterpret_cast< ULONG >( pEntry ) ) );
 493         delete pEntry;
 494         Broadcast( GalleryHint( GALLERY_HINT_OBJECT_REMOVED, GetName(), reinterpret_cast< ULONG >( pEntry ) ) );
 495
 496         ImplSetModified( TRUE );
 497         ImplBroadcast( nPos );
 498     }
 499
 500     return( pEntry != NULL );
 501 }
 502
 503 // ------------------------------------------------------------------------
 504
 505 BOOL GalleryTheme::ChangeObjectPos( ULONG nOldPos, ULONG nNewPos )
 506 {
 507     BOOL bRet = FALSE;
 508
 509     if( nOldPos != nNewPos )
 510     {
 511         GalleryObject* pEntry = aObjectList.GetObject( nOldPos );
 512
 513         if( pEntry )
 514         {
 515             aObjectList.Insert( pEntry, nNewPos );
 516
 517             if( nNewPos < nOldPos )
 518                 nOldPos++;
 519
 520             aObjectList.Remove( nOldPos );
 521             ImplSetModified( bRet = TRUE );
 522             ImplBroadcast( ( nNewPos < nOldPos ) ? nNewPos : ( nNewPos - 1 ) );
 523         }
 524     }
 525
 526     return bRet;
 527 }
 528
 529 // ------------------------------------------------------------------------
 530
 531 void GalleryTheme::Actualize( const Link& rActualizeLink, GalleryProgress* pProgress )
 532 {
 533     if( !IsReadOnly() && !IsImported() )
 534     {
 535         Graphic                 aGraphic;
 536         String                  aFormat;
 537         GalleryObject*  pEntry;
 538         const ULONG             nCount = aObjectList.Count();
 539         ULONG                   i;
 540
 541         LockBroadcaster();
 542         bAbortActualize = FALSE;
 543
 544         // LoeschFlag zuruecksetzen
 545         for ( i = 0; i < nCount; i++ )
 546             aObjectList.GetObject( i )->bDummy = FALSE;
 547
 548         for( i = 0; ( i < nCount ) && !bAbortActualize; i++ )
 549         {
 550             if( pProgress )
 551                 pProgress->Update( i, nCount - 1 );
 552
 553             pEntry = aObjectList.GetObject( i );
 554
 555             const INetURLObject aURL( pEntry->aURL );
 556
 557             rActualizeLink.Call( (void*) &aURL );
 558
 559             // SvDraw-Objekte werden spaeter aktualisiert
 560             if( pEntry->eObjKind != SGA_OBJ_SVDRAW )
 561             {
 562                 // Hier muss noch etwas eingebaut werden,
 563                 // das Files auf den ensprechenden Eintrag matched
 564                 // Grafiken als Grafik-Objekte in die Gallery aufnehmen
 565                 if( pEntry->eObjKind == SGA_OBJ_SOUND )
 566                 {
 567                     SgaObjectSound aObjSound( aURL );
 568                     if( !InsertObject( aObjSound ) )
 569                         pEntry->bDummy = TRUE;
 570                 }
 571                 else
 572                 {
 573                     aGraphic.Clear();
 574
 575                     if ( GalleryGraphicImport( aURL, aGraphic, aFormat ) )
 576                     {
 577                         SgaObject* pNewObj;
 578
 579                         if ( SGA_OBJ_INET == pEntry->eObjKind )
 580                             pNewObj = (SgaObject*) new SgaObjectINet( aGraphic, aURL, aFormat );
 581                         else if ( aGraphic.IsAnimated() )
 582                             pNewObj = (SgaObject*) new SgaObjectAnim( aGraphic, aURL, aFormat );
 583                         else
 584                             pNewObj = (SgaObject*) new SgaObjectBmp( aGraphic, aURL, aFormat );
 585
 586                         if( !InsertObject( *pNewObj ) )
 587                             pEntry->bDummy = TRUE;
 588
 589                         delete pNewObj;
 590                     }
 591                     else
 592                         pEntry->bDummy = TRUE; // Loesch-Flag setzen
 593                 }
 594             }
 595             else
 596             {
 597                 if ( aSvDrawStorageRef.Is() )
 598                 {
 599                     const String                aStmName( GetSvDrawStreamNameFromURL( pEntry->aURL ) );
 600                     SvStorageStreamRef  pIStm = aSvDrawStorageRef->OpenSotStream( aStmName, STREAM_READ );
 601
 602                     if( pIStm && !pIStm->GetError() )
 603                     {
 604                         pIStm->SetBufferSize( 16384 );
 605
 606                         SgaObjectSvDraw aNewObj( *pIStm, pEntry->aURL );
 607
 608                         if( !InsertObject( aNewObj ) )
 609                             pEntry->bDummy = TRUE;
 610
 611                         pIStm->SetBufferSize( 0L );
 612                     }
 613                 }
 614             }
 615         }
 616
 617         // remove all entries with set flag
 618         pEntry = aObjectList.First();
 619         while( pEntry )
 620         {
 621             if( pEntry->bDummy )
 622             {
 623                 Broadcast( GalleryHint( GALLERY_HINT_CLOSE_OBJECT, GetName(), reinterpret_cast< ULONG >( pEntry ) ) );
 624                 delete aObjectList.Remove( pEntry );
 625                 Broadcast( GalleryHint( GALLERY_HINT_OBJECT_REMOVED, GetName(), reinterpret_cast< ULONG >( pEntry ) ) );
 626
 627                 pEntry = aObjectList.GetCurObject();
 628             }
 629             else
 630                 pEntry = aObjectList.Next();
 631         }
 632
 633         // update theme
 634         ::utl::TempFile aTmp;
 635         INetURLObject   aInURL( GetSdgURL() );
 636         INetURLObject   aTmpURL( aTmp.GetURL() );
 637
 638         DBG_ASSERT( aInURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
 639         DBG_ASSERT( aTmpURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
 640
 641         SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( aInURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ );
 642         SvStream* pTmpStm = ::utl::UcbStreamHelper::CreateStream( aTmpURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE | STREAM_TRUNC );
 643
 644         if( pIStm && pTmpStm )
 645         {
 646             pEntry = aObjectList.First();
 647
 648             while( pEntry )
 649             {
 650                 SgaObject* pObj;
 651
 652                 switch( pEntry->eObjKind )
 653                 {
 654                     case( SGA_OBJ_BMP ):        pObj = new SgaObjectBmp(); break;
 655                     case( SGA_OBJ_ANIM ):       pObj = new SgaObjectAnim(); break;
 656                     case( SGA_OBJ_INET ):       pObj = new SgaObjectINet(); break;
 657                     case( SGA_OBJ_SVDRAW ):     pObj = new SgaObjectSvDraw(); break;
 658                     case (SGA_OBJ_SOUND):       pObj = new SgaObjectSound(); break;
 659
 660                     default:
 661                         pObj = NULL;
 662                     break;
 663                 }
 664
 665                 if( pObj )
 666                 {
 667                     pIStm->Seek( pEntry->nOffset );
 668                     *pIStm >> *pObj;
 669                     pEntry->nOffset = pTmpStm->Tell();
 670                     *pTmpStm << *pObj;
 671                     delete pObj;
 672                 }
 673
 674                 pEntry = aObjectList.Next();
 675             }
 676         }
 677         else
 678         {
 679             DBG_ERROR( "File(s) could not be opened" );
 680         }
 681
 682         delete pIStm;
 683         delete pTmpStm;
 684
 685         CopyFile( aTmpURL, aInURL );
 686         KillFile( aTmpURL );
 687
 688         ULONG nStorErr = 0;
 689
 690         {
 691             SvStorageRef aTempStorageRef( new SvStorage( FALSE, aTmpURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_STD_READWRITE ) );
 692             aSvDrawStorageRef->CopyTo( aTempStorageRef );
 693             nStorErr = aSvDrawStorageRef->GetError();
 694         }
 695
 696         if( !nStorErr )
 697         {
 698             aSvDrawStorageRef.Clear();
 699             CopyFile( aTmpURL, GetSdvURL() );
 700             ImplCreateSvDrawStorage();
 701         }
 702
 703         KillFile( aTmpURL );
 704         ImplSetModified( TRUE );
 705         ImplWrite();
 706         UnlockBroadcaster();
 707     }
 708 }
 709
 710 // ------------------------------------------------------------------------
 711
 712 GalleryThemeEntry* GalleryTheme::CreateThemeEntry( const INetURLObject& rURL, BOOL bReadOnly )
 713 {
 714     DBG_ASSERT( rURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
 715
 716     GalleryThemeEntry*  pRet = NULL;
 717
 718     if( FileExists( rURL ) )
 719     {
 720         SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( rURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ );
 721
 722         if( pIStm )
 723         {
 724             String                      aThemeName;
 725             sal_uInt32          nThemeId = 0;
 726             sal_uInt16          nVersion;
 727             BOOL                        bThemeNameFromResource = FALSE;
 728
 729             *pIStm >> nVersion;
 730
 731             if( nVersion <= 0x00ff )
 732             {
 733                 ByteString aTmpStr;
 734
 735                 *pIStm >> aTmpStr; aThemeName = String( aTmpStr.GetBuffer(), RTL_TEXTENCODING_UTF8 );
 736
 737                 // Charakterkonvertierung durchfuehren
 738                 if( nVersion >= 0x0004 )
 739                 {
 740                     sal_uInt32  nCount;
 741                     sal_uInt16  nTemp16;
 742
 743                     *pIStm >> nCount >> nTemp16;
 744                     pIStm->Seek( STREAM_SEEK_TO_END );
 745
 746                     // pruefen, ob es sich um eine neuere Version handelt;
 747                     // daher um 520Bytes (8Bytes Kennung + 512Bytes Reserverpuffer ) zurueckspringen,
 748                     // falls dies ueberhaupt moeglich ist
 749                     if( pIStm->Tell() >= 520 )
 750                     {
 751                         sal_uInt32 nId1, nId2;
 752
 753                         pIStm->SeekRel( -520 );
 754                         *pIStm >> nId1 >> nId2;
 755
 756                         if( nId1 == COMPAT_FORMAT( 'G', 'A', 'L', 'R' ) &&
 757                             nId2 == COMPAT_FORMAT( 'E', 'S', 'R', 'V' ) )
 758                         {
 759                             VersionCompat* pCompat = new VersionCompat( *pIStm, STREAM_READ );
 760
 761                             *pIStm >> nThemeId;
 762
 763                             if( pCompat->GetVersion() >= 2 )
 764                             {
 765                                 *pIStm >> bThemeNameFromResource;
 766                             }
 767
 768                             delete pCompat;
 769                         }
 770                     }
 771                 }
 772
 773                 INetURLObject aPathURL( rURL );
 774
 775                 aPathURL.removeSegment();
 776                 aPathURL.removeFinalSlash();
 777                 pRet = new GalleryThemeEntry( aPathURL, aThemeName,
 778                                               String(rURL.GetBase()).Copy( 2, 6 ).ToInt32(),
 779                                               bReadOnly, FALSE, FALSE, nThemeId,
 780                                               bThemeNameFromResource );
 781             }
 782
 783             delete pIStm;
 784         }
 785     }
 786
 787     return pRet;
 788 }
 789
 790 // -----------------------------------------------------------------------------
 791
 792 BOOL GalleryTheme::GetThumb( ULONG nPos, Bitmap& rBmp, BOOL )
 793 {
 794     SgaObject*  pObj = AcquireObject( nPos );
 795     BOOL                bRet = FALSE;
 796
 797     if( pObj )
 798     {
 799         rBmp = pObj->GetThumbBmp();
 800         ReleaseObject( pObj );
 801         bRet = TRUE;
 802     }
 803
 804     return bRet;
 805 }
 806
 807 // -----------------------------------------------------------------------------
 808
 809 BOOL GalleryTheme::GetGraphic( ULONG nPos, Graphic& rGraphic, BOOL bProgress )
 810 {
 811     const GalleryObject*        pObject = ImplGetGalleryObject( nPos );
 812     BOOL                                        bRet = FALSE;
 813
 814     if( pObject )
 815     {
 816         const INetURLObject aURL( ImplGetURL( pObject ) );
 817
 818         switch( pObject->eObjKind )
 819         {
 820             case( SGA_OBJ_BMP ):
 821             case( SGA_OBJ_ANIM ):
 822             case( SGA_OBJ_INET ):
 823             {
 824                 String aFilterDummy;
 825                 bRet = ( GalleryGraphicImport( aURL, rGraphic, aFilterDummy, bProgress ) != SGA_IMPORT_NONE );
 826             }
 827             break;
 828
 829             case( SGA_OBJ_SVDRAW ):
 830             {
 831                 SvxGalleryDrawModel aModel;
 832
 833                 if( aModel.GetModel() )
 834                 {
 835                     if( GetModel( nPos, *aModel.GetModel(), bProgress ) )
 836                     {
 837                         ImageMap aIMap;
 838
 839                         if( CreateIMapGraphic( *aModel.GetModel(), rGraphic, aIMap ) )
 840                             bRet = TRUE;
 841                         else
 842                         {
 843                             VirtualDevice aVDev;
 844                             aVDev.SetMapMode( MapMode( MAP_100TH_MM ) );
 845                             FmFormView aView( aModel.GetModel(), &aVDev );
 846
 847                             aView.hideMarkHandles();
 848                             aView.ShowSdrPage(aView.GetModel()->GetPage(0));
 849                             aView.MarkAll();
 850                             rGraphic = aView.GetAllMarkedGraphic();
 851                             bRet = TRUE;
 852                         }
 853                     }
 854                 }
 855             }
 856             break;
 857
 858             case( SGA_OBJ_SOUND ):
 859             {
 860                 SgaObject* pObj = AcquireObject( nPos );
 861
 862                 if( pObj )
 863                 {
 864                     Bitmap aBmp( pObj->GetThumbBmp() );
 865                     aBmp.Replace( COL_LIGHTMAGENTA, COL_WHITE );
 866                     rGraphic = aBmp;
 867                     ReleaseObject( pObj );
 868                     bRet = TRUE;
 869                 }
 870             }
 871             break;
 872
 873             default:
 874             break;
 875         }
 876     }
 877
 878     return bRet;
 879 }
 880
 881 // -----------------------------------------------------------------------------
 882
 883 BOOL GalleryTheme::InsertGraphic( const Graphic& rGraphic, ULONG nInsertPos )
 884 {
 885     BOOL bRet = FALSE;
 886
 887     if( rGraphic.GetType() != GRAPHIC_NONE )
 888     {
 889         ULONG           nExportFormat = CVT_UNKNOWN;
 890         const GfxLink   aGfxLink( ( (Graphic&) rGraphic ).GetLink() );
 891
 892         if( aGfxLink.GetDataSize() )
 893         {
 894             switch( aGfxLink.GetType() )
 895             {
 896                 case( GFX_LINK_TYPE_EPS_BUFFER ): nExportFormat = CVT_SVM; break;
 897                 case( GFX_LINK_TYPE_NATIVE_GIF ): nExportFormat = CVT_GIF; break;
 898                 case( GFX_LINK_TYPE_NATIVE_JPG ): nExportFormat = CVT_JPG; break;
 899                 case( GFX_LINK_TYPE_NATIVE_PNG ): nExportFormat = CVT_PNG; break;
 900                 case( GFX_LINK_TYPE_NATIVE_TIF ): nExportFormat = CVT_TIF; break;
 901                 case( GFX_LINK_TYPE_NATIVE_WMF ): nExportFormat = CVT_WMF; break;
 902                 case( GFX_LINK_TYPE_NATIVE_MET ): nExportFormat = CVT_MET; break;
 903                 case( GFX_LINK_TYPE_NATIVE_PCT ): nExportFormat = CVT_PCT; break;
 904                 default:
 905                     break;
 906             }
 907         }
 908         else
 909         {
 910             if( rGraphic.GetType() == GRAPHIC_BITMAP )
 911             {
 912                 if( rGraphic.IsAnimated() )
 913                     nExportFormat = CVT_GIF;
 914                 else
 915                     nExportFormat = CVT_PNG;
 916             }
 917             else
 918                 nExportFormat = CVT_SVM;
 919         }
 920
 921         const INetURLObject aURL( ImplCreateUniqueURL( SGA_OBJ_BMP, nExportFormat ) );
 922         SvStream*           pOStm = ::utl::UcbStreamHelper::CreateStream( aURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE | STREAM_TRUNC );
 923
 924         if( pOStm )
 925         {
 926             pOStm->SetVersion( SOFFICE_FILEFORMAT_50 );
 927
 928             if( CVT_SVM == nExportFormat )
 929             {
 930                 GDIMetaFile aMtf( rGraphic.GetGDIMetaFile() );
 931
 932                 aMtf.Write( *pOStm );
 933                 bRet = ( pOStm->GetError() == ERRCODE_NONE );
 934             }
 935             else
 936             {
 937                 if( aGfxLink.GetDataSize() && aGfxLink.GetData() )
 938                 {
 939                     pOStm->Write( aGfxLink.GetData(), aGfxLink.GetDataSize() );
 940                     bRet = ( pOStm->GetError() == ERRCODE_NONE );
 941                 }
 942                 else
 943                     bRet = ( GraphicConverter::Export( *pOStm, rGraphic, nExportFormat ) == ERRCODE_NONE );
 944             }
 945
 946             delete pOStm;
 947         }
 948
 949         if( bRet )
 950         {
 951             const SgaObjectBmp aObjBmp( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
 952             InsertObject( aObjBmp, nInsertPos );
 953         }
 954     }
 955
 956     return bRet;
 957 }
 958
 959 // -----------------------------------------------------------------------------
 960
 961 BOOL GalleryTheme::GetModel( ULONG nPos, SdrModel& rModel, BOOL )
 962 {
 963     const GalleryObject*        pObject = ImplGetGalleryObject( nPos );
 964     BOOL                                        bRet = FALSE;
 965
 966     if( pObject && ( SGA_OBJ_SVDRAW == pObject->eObjKind ) )
 967     {
 968         const INetURLObject aURL( ImplGetURL( pObject ) );
 969         SvStorageRef            xStor( GetSvDrawStorage() );
 970
 971         if( xStor.Is() )
 972         {
 973             const String                aStmName( GetSvDrawStreamNameFromURL( aURL ) );
 974             SvStorageStreamRef  xIStm( xStor->OpenSotStream( aStmName, STREAM_READ ) );
 975
 976             if( xIStm.Is() && !xIStm->GetError() )
 977             {
 978                 xIStm->SetBufferSize( STREAMBUF_SIZE );
 979                 bRet = GallerySvDrawImport( *xIStm, rModel );
 980                 xIStm->SetBufferSize( 0L );
 981             }
 982         }
 983     }
 984
 985     return bRet;
 986 }
 987
 988 // -----------------------------------------------------------------------------
 989
 990 BOOL GalleryTheme::InsertModel( const FmFormModel& rModel, ULONG nInsertPos )
 991 {
 992     INetURLObject       aURL( ImplCreateUniqueURL( SGA_OBJ_SVDRAW ) );
 993     SvStorageRef        xStor( GetSvDrawStorage() );
 994     BOOL                        bRet = FALSE;
 995
 996     if( xStor.Is() )
 997     {
 998         const String            aStmName( GetSvDrawStreamNameFromURL( aURL ) );
 999         SvStorageStreamRef      xOStm( xStor->OpenSotStream( aStmName, STREAM_WRITE | STREAM_TRUNC ) );
1000
1001         if( xOStm.Is() && !xOStm->GetError() )
1002         {
1003             SvMemoryStream      aMemStm( 65535, 65535 );
1004             FmFormModel*        pFormModel = (FmFormModel*) &rModel;
1005
1006             pFormModel->BurnInStyleSheetAttributes();
1007
1008             {
1009                 uno::Reference< io::XOutputStream > xDocOut( new utl::OOutputStreamWrapper( aMemStm ) );
1010
1011                 if( xDocOut.is() )
1012                     SvxDrawingLayerExport( pFormModel, xDocOut );
1013             }
1014
1015             aMemStm.Seek( 0 );
1016
1017             xOStm->SetBufferSize( 16348 );
1018             GalleryCodec aCodec( *xOStm );
1019             aCodec.Write( aMemStm );
1020
1021             if( !xOStm->GetError() )
1022             {
1023                 SgaObjectSvDraw aObjSvDraw( rModel, aURL );
1024                 bRet = InsertObject( aObjSvDraw, nInsertPos );
1025             }
1026
1027             xOStm->SetBufferSize( 0L );
1028             xOStm->Commit();
1029         }
1030     }
1031
1032     return bRet;
1033 }
1034
1035 // -----------------------------------------------------------------------------
1036
1037 BOOL GalleryTheme::GetModelStream( ULONG nPos, SotStorageStreamRef& rxModelStream, BOOL )
1038 {
1039     const GalleryObject*        pObject = ImplGetGalleryObject( nPos );
1040     BOOL                                        bRet = FALSE;
1041
1042     if( pObject && ( SGA_OBJ_SVDRAW == pObject->eObjKind ) )
1043     {
1044         const INetURLObject aURL( ImplGetURL( pObject ) );
1045         SvStorageRef            xStor( GetSvDrawStorage() );
1046
1047         if( xStor.Is() )
1048         {
1049             const String                aStmName( GetSvDrawStreamNameFromURL( aURL ) );
1050             SvStorageStreamRef  xIStm( xStor->OpenSotStream( aStmName, STREAM_READ ) );
1051
1052             if( xIStm.Is() && !xIStm->GetError() )
1053             {
1054                 UINT32 nVersion = 0;
1055
1056                 xIStm->SetBufferSize( 16348 );
1057
1058                 if( GalleryCodec::IsCoded( *xIStm, nVersion ) )
1059                 {
1060                     SvxGalleryDrawModel aModel;
1061
1062                     if( aModel.GetModel() )
1063                     {
1064                         if( GallerySvDrawImport( *xIStm, *aModel.GetModel() ) )
1065                         {
1066                             aModel.GetModel()->BurnInStyleSheetAttributes();
1067
1068                             {
1069                                 uno::Reference< io::XOutputStream > xDocOut( new utl::OOutputStreamWrapper( *rxModelStream ) );
1070
1071                                 if( SvxDrawingLayerExport( aModel.GetModel(), xDocOut ) )
1072                                     rxModelStream->Commit();
1073                             }
1074                         }
1075
1076                         bRet = ( rxModelStream->GetError() == ERRCODE_NONE );
1077                     }
1078                 }
1079
1080                 xIStm->SetBufferSize( 0 );
1081             }
1082         }
1083     }
1084
1085     return bRet;
1086 }
1087
1088 // -----------------------------------------------------------------------------
1089
1090 BOOL GalleryTheme::InsertModelStream( const SotStorageStreamRef& rxModelStream, ULONG nInsertPos )
1091 {
1092     INetURLObject       aURL( ImplCreateUniqueURL( SGA_OBJ_SVDRAW ) );
1093     SvStorageRef        xStor( GetSvDrawStorage() );
1094     BOOL                        bRet = FALSE;
1095
1096     if( xStor.Is() )
1097     {
1098         const String            aStmName( GetSvDrawStreamNameFromURL( aURL ) );
1099         SvStorageStreamRef      xOStm( xStor->OpenSotStream( aStmName, STREAM_WRITE | STREAM_TRUNC ) );
1100
1101         if( xOStm.Is() && !xOStm->GetError() )
1102         {
1103             GalleryCodec    aCodec( *xOStm );
1104             SvMemoryStream  aMemStm( 65535, 65535 );
1105
1106             xOStm->SetBufferSize( 16348 );
1107             aCodec.Write( *rxModelStream );
1108
1109             if( !xOStm->GetError() )
1110             {
1111                 xOStm->Seek( 0 );
1112                 SgaObjectSvDraw aObjSvDraw( *xOStm, aURL );
1113                 bRet = InsertObject( aObjSvDraw, nInsertPos );
1114             }
1115
1116             xOStm->SetBufferSize( 0L );
1117             xOStm->Commit();
1118         }
1119     }
1120
1121     return bRet;
1122 }
1123
1124 // -----------------------------------------------------------------------------
1125
1126 BOOL GalleryTheme::GetURL( ULONG nPos, INetURLObject& rURL, BOOL )
1127 {
1128     const GalleryObject*        pObject = ImplGetGalleryObject( nPos );
1129     BOOL                                        bRet = FALSE;
1130
1131     if( pObject )
1132     {
1133         rURL = INetURLObject( ImplGetURL( pObject ) );
1134         bRet = TRUE;
1135     }
1136
1137     return bRet;
1138 }
1139
1140 // -----------------------------------------------------------------------------
1141
1142 BOOL GalleryTheme::InsertURL( const INetURLObject& rURL, ULONG nInsertPos )
1143 {
1144     Graphic                     aGraphic;
1145     String                      aFormat;
1146     SgaObject*          pNewObj = NULL;
1147     const USHORT        nImportRet = GalleryGraphicImport( rURL, aGraphic, aFormat );
1148     BOOL                        bRet = FALSE;
1149
1150     if( nImportRet != SGA_IMPORT_NONE )
1151     {
1152         if ( SGA_IMPORT_INET == nImportRet )
1153             pNewObj = (SgaObject*) new SgaObjectINet( aGraphic, rURL, aFormat );
1154         else if ( aGraphic.IsAnimated() )
1155             pNewObj = (SgaObject*) new SgaObjectAnim( aGraphic, rURL, aFormat );
1156         else
1157             pNewObj = (SgaObject*) new SgaObjectBmp( aGraphic, rURL, aFormat );
1158     }
1159     else if( ::avmedia::MediaWindow::isMediaURL( rURL.GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS ) ) )
1160         pNewObj = (SgaObject*) new SgaObjectSound( rURL );
1161
1162     if( pNewObj && InsertObject( *pNewObj, nInsertPos ) )
1163         bRet = TRUE;
1164
1165     delete pNewObj;
1166
1167     return bRet;
1168 }
1169
1170 // -----------------------------------------------------------------------------
1171
1172 BOOL GalleryTheme::InsertFileOrDirURL( const INetURLObject& rFileOrDirURL, ULONG nInsertPos )
1173 {
1174     INetURLObject                   aURL;
1175     ::std::vector< INetURLObject >  aURLVector;
1176     BOOL                            bRet = FALSE;
1177
1178     try
1179     {
1180         ::ucbhelper::Content         aCnt( rFileOrDirURL.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ucb::XCommandEnvironment >() );
1181         sal_Bool        bFolder = false;
1182
1183         aCnt.getPropertyValue( OUString::createFromAscii( "IsFolder" ) ) >>= bFolder;
1184
1185         if( bFolder )
1186         {
1187             uno::Sequence< OUString > aProps( 1 );
1188             aProps.getArray()[ 0 ] = OUString::createFromAscii( "Url" );
1189             uno::Reference< sdbc::XResultSet > xResultSet( aCnt.createCursor( aProps, ::ucbhelper::INCLUDE_DOCUMENTS_ONLY ) );
1190
1191             if( xResultSet.is() )
1192             {
1193                 uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
1194
1195                 if( xContentAccess.is() )
1196                 {
1197                     while( xResultSet->next() )
1198                     {
1199                         aURL.SetSmartURL( xContentAccess->queryContentIdentifierString() );
1200                         aURLVector.push_back( aURL );
1201                     }
1202                 }
1203             }
1204         }
1205         else
1206             aURLVector.push_back( rFileOrDirURL );
1207     }
1208     catch( const ucb::ContentCreationException& )
1209     {
1210     }
1211     catch( const uno::RuntimeException& )
1212     {
1213     }
1214     catch( const uno::Exception& )
1215     {
1216     }
1217
1218     ::std::vector< INetURLObject >::const_iterator aIter( aURLVector.begin() ), aEnd( aURLVector.end() );
1219
1220     while( aIter != aEnd )
1221         bRet = bRet || InsertURL( *aIter++, nInsertPos );
1222
1223     return bRet;
1224 }
1225
1226 // -----------------------------------------------------------------------------
1227
1228 BOOL GalleryTheme::InsertTransferable( const uno::Reference< datatransfer::XTransferable >& rxTransferable, ULONG nInsertPos )
1229 {
1230     BOOL bRet = FALSE;
1231
1232     if( rxTransferable.is() )
1233     {
1234         TransferableDataHelper  aDataHelper( rxTransferable );
1235         Graphic*                                pGraphic = NULL;
1236
1237         if( aDataHelper.HasFormat( SOT_FORMATSTR_ID_DRAWING ) )
1238         {
1239             SotStorageStreamRef xModelStm;
1240
1241             if( aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_DRAWING, xModelStm ) )
1242                 bRet = InsertModelStream( xModelStm, nInsertPos );
1243         }
1244         else if( aDataHelper.HasFormat( SOT_FORMAT_FILE_LIST ) ||
1245                  aDataHelper.HasFormat( FORMAT_FILE ) )
1246         {
1247             FileList aFileList;
1248
1249             if( aDataHelper.HasFormat( SOT_FORMAT_FILE_LIST ) )
1250                 aDataHelper.GetFileList( SOT_FORMAT_FILE_LIST, aFileList );
1251             else
1252             {
1253                 String aFile;
1254
1255                 aDataHelper.GetString( FORMAT_FILE, aFile );
1256
1257                 if( aFile.Len() )
1258                     aFileList.AppendFile( aFile );
1259             }
1260
1261             for( sal_uInt32 i = 0, nCount = aFileList.Count(); i < nCount; ++i )
1262             {
1263                 const String    aFile( aFileList.GetFile( i ) );
1264                 INetURLObject   aURL( aFile );
1265
1266                 if( aURL.GetProtocol() == INET_PROT_NOT_VALID )
1267                 {
1268                     String aLocalURL;
1269
1270                     if( ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aFile, aLocalURL ) )
1271                         aURL = INetURLObject( aLocalURL );
1272                 }
1273
1274                 if( aURL.GetProtocol() != INET_PROT_NOT_VALID )
1275                     bRet = InsertFileOrDirURL( aURL, nInsertPos );
1276             }
1277         }
1278         else
1279         {
1280             Graphic     aGraphic;
1281             ULONG       nFormat = 0;
1282
1283             if( aDataHelper.HasFormat( SOT_FORMATSTR_ID_SVXB ) )
1284                 nFormat = SOT_FORMATSTR_ID_SVXB;
1285             else if( aDataHelper.HasFormat( FORMAT_GDIMETAFILE ) )
1286                 nFormat = FORMAT_GDIMETAFILE;
1287             else if( aDataHelper.HasFormat( FORMAT_BITMAP ) )
1288                 nFormat = FORMAT_BITMAP;
1289
1290             if( nFormat && aDataHelper.GetGraphic( nFormat, aGraphic ) )
1291                 pGraphic = new Graphic( aGraphic );
1292         }
1293
1294         if( pGraphic )
1295         {
1296             bRet = FALSE;
1297
1298             if( aDataHelper.HasFormat( SOT_FORMATSTR_ID_SVIM ) )
1299             {
1300
1301                 ImageMap aImageMap;
1302
1303                 // according to KA we don't need a BaseURL here
1304                 if( aDataHelper.GetImageMap( SOT_FORMATSTR_ID_SVIM, aImageMap ) )
1305                 {
1306                     SvxGalleryDrawModel aModel;
1307
1308                     if( aModel.GetModel() )
1309                     {
1310                         SgaUserDataFactory      aFactory;
1311
1312                         SdrPage*        pPage = aModel.GetModel()->GetPage(0);
1313                         SdrGrafObj*     pGrafObj = new SdrGrafObj( *pGraphic );
1314
1315                         pGrafObj->InsertUserData( new SgaIMapInfo( aImageMap ) );
1316                         pPage->InsertObject( pGrafObj );
1317                         bRet = InsertModel( *aModel.GetModel(), nInsertPos );
1318                     }
1319                 }
1320             }
1321
1322             if( !bRet )
1323                 bRet = InsertGraphic( *pGraphic, nInsertPos );
1324
1325             delete pGraphic;
1326         }
1327     }
1328
1329     return bRet;
1330 }
1331
1332 // -----------------------------------------------------------------------------
1333
1334 void GalleryTheme::CopyToClipboard( Window* pWindow, ULONG nPos )
1335 {
1336     GalleryTransferable* pTransferable = new GalleryTransferable( this, nPos, false );
1337     pTransferable->CopyToClipboard( pWindow );
1338 }
1339
1340 // -----------------------------------------------------------------------------
1341
1342 void GalleryTheme::StartDrag( Window* pWindow, ULONG nPos )
1343 {
1344     GalleryTransferable* pTransferable = new GalleryTransferable( this, nPos, true );
1345     pTransferable->StartDrag( pWindow, DND_ACTION_COPY | DND_ACTION_LINK );
1346 }
1347
1348 // -----------------------------------------------------------------------------
1349
1350 SvStream& GalleryTheme::WriteData( SvStream& rOStm ) const
1351 {
1352     const INetURLObject aRelURL1( GetParent()->GetRelativeURL() );
1353     const INetURLObject aRelURL2( GetParent()->GetUserURL() );
1354     INetURLObject               aNewURL, aTempURL;
1355     sal_uInt32                  nCount = GetObjectCount();
1356     BOOL                                bRel;
1357
1358     rOStm << (sal_uInt16) 0x0004;
1359     rOStm << ByteString( GetRealName(), RTL_TEXTENCODING_UTF8 );
1360     rOStm << nCount << (sal_uInt16) gsl_getSystemTextEncoding();
1361
1362     for( sal_uInt32 i = 0; i < nCount; i++ )
1363     {
1364         const GalleryObject* pObj = ImplGetGalleryObject( i );
1365         String                           aPath;
1366
1367         if( SGA_OBJ_SVDRAW == pObj->eObjKind )
1368         {
1369             aPath = GetSvDrawStreamNameFromURL( pObj->aURL );
1370             bRel = FALSE;
1371         }
1372         else
1373         {
1374             aPath = pObj->aURL.GetMainURL( INetURLObject::NO_DECODE );
1375             bRel = ( ( aPath.Erase( sal::static_int_cast< xub_StrLen >( aRelURL1.GetMainURL( INetURLObject::NO_DECODE ).getLength() ) ) ) == String(aRelURL1.GetMainURL( INetURLObject::NO_DECODE ) ));
1376
1377             if( bRel && ( pObj->aURL.GetMainURL( INetURLObject::NO_DECODE ).getLength() > ( aRelURL1.GetMainURL( INetURLObject::NO_DECODE ).getLength() + 1 ) ) )
1378             {
1379                 aPath = pObj->aURL.GetMainURL( INetURLObject::NO_DECODE );
1380                 aPath = aPath.Erase( 0, sal::static_int_cast< xub_StrLen >( aRelURL1.GetMainURL( INetURLObject::NO_DECODE ).getLength() ) );
1381             }
1382             else
1383             {
1384                 aPath = pObj->aURL.GetMainURL( INetURLObject::NO_DECODE );
1385                 bRel = ( ( aPath.Erase( sal::static_int_cast< xub_StrLen >( aRelURL2.GetMainURL( INetURLObject::NO_DECODE ).getLength() ) ) ) == String(aRelURL2.GetMainURL( INetURLObject::NO_DECODE ) ));
1386
1387                 if( bRel && ( pObj->aURL.GetMainURL( INetURLObject::NO_DECODE ).getLength() > ( aRelURL2.GetMainURL( INetURLObject::NO_DECODE ).getLength() + 1 ) ) )
1388                 {
1389                     aPath = pObj->aURL.GetMainURL( INetURLObject::NO_DECODE );
1390                     aPath = aPath.Erase( 0, sal::static_int_cast< xub_StrLen >( aRelURL2.GetMainURL( INetURLObject::NO_DECODE ).getLength() ) );
1391                 }
1392                 else
1393                     aPath = pObj->aURL.GetMainURL( INetURLObject::NO_DECODE );
1394             }
1395         }
1396
1397         aPath.SearchAndReplace(m_aDestDir, String());
1398         rOStm << bRel << ByteString( aPath, RTL_TEXTENCODING_UTF8 ) << pObj->nOffset << (sal_uInt16) pObj->eObjKind;
1399     }
1400
1401     // neuerdings wird ein 512-Byte-Reservepuffer gechrieben;
1402     // um diesen zu erkennen werden zwei ULONG-Ids geschrieben
1403     rOStm << COMPAT_FORMAT( 'G', 'A', 'L', 'R' ) << COMPAT_FORMAT( 'E', 'S', 'R', 'V' );
1404
1405     const long          nReservePos = rOStm.Tell();
1406     VersionCompat*      pCompat = new VersionCompat( rOStm, STREAM_WRITE, 2 );
1407
1408     rOStm << (sal_uInt32) GetId() << IsThemeNameFromResource(); // ab Version 2
1409
1410     delete pCompat;
1411
1412     // Rest des Puffers auffuellen
1413     const long  nRest = Max( 512L - ( (long) rOStm.Tell() - nReservePos ), 0L );
1414
1415     if( nRest )
1416     {
1417         char* pReserve = new char[ nRest ];
1418         memset( pReserve, 0, nRest );
1419         rOStm.Write( pReserve, nRest );
1420         delete[] pReserve;
1421     }
1422
1423     return rOStm;
1424 }
1425
1426 // ------------------------------------------------------------------------
1427
1428 SvStream& GalleryTheme::ReadData( SvStream& rIStm )
1429 {
1430     sal_uInt32                  nCount;
1431     sal_uInt16                  nVersion;
1432     ByteString                  aTmpStr;
1433     String                              aThemeName;
1434     rtl_TextEncoding    nTextEncoding;
1435
1436     aImportName = String();
1437     rIStm >> nVersion >> aTmpStr >> nCount;
1438
1439     if( nVersion >= 0x0004 )
1440     {
1441         UINT16 nTmp16;
1442         rIStm >> nTmp16;
1443         nTextEncoding = (rtl_TextEncoding) nTmp16;
1444     }
1445     else
1446         nTextEncoding = RTL_TEXTENCODING_UTF8;
1447
1448     aThemeName = String( aTmpStr.GetBuffer(), nTextEncoding );
1449
1450     if( nCount <= ( 1L << 14 ) )
1451     {
1452         GalleryObject*  pObj;
1453         INetURLObject   aRelURL1( GetParent()->GetRelativeURL() );
1454         INetURLObject   aRelURL2( GetParent()->GetUserURL() );
1455         sal_uInt32              nId1, nId2;
1456         BOOL                    bRel;
1457
1458         for( pObj = aObjectList.First(); pObj; pObj = aObjectList.Next() )
1459         {
1460             Broadcast( GalleryHint( GALLERY_HINT_CLOSE_OBJECT, GetName(), reinterpret_cast< ULONG >( pObj ) ) );
1461             delete pObj;
1462             Broadcast( GalleryHint( GALLERY_HINT_OBJECT_REMOVED, GetName(), reinterpret_cast< ULONG >( pObj ) ) );
1463         }
1464
1465         aObjectList.Clear();
1466
1467         for( sal_uInt32 i = 0; i < nCount; i++ )
1468         {
1469             pObj = new GalleryObject;
1470
1471             ByteString  aTempFileName;
1472             String              aFileName;
1473             String              aPath;
1474             sal_uInt16  nTemp;
1475
1476             rIStm >> bRel >> aTempFileName >> pObj->nOffset;
1477             rIStm >> nTemp; pObj->eObjKind = (SgaObjKind) nTemp;
1478
1479             aFileName = String( aTempFileName.GetBuffer(), gsl_getSystemTextEncoding() );
1480
1481             if( bRel )
1482             {
1483                 aFileName.SearchAndReplaceAll( '\\', '/' );
1484                 aPath = aRelURL1.GetMainURL( INetURLObject::NO_DECODE );
1485
1486                 if( aFileName.GetChar( 0 ) != '/' )
1487                         aPath += '/';
1488
1489                 aPath += aFileName;
1490
1491                 pObj->aURL = INetURLObject( aPath );
1492
1493                 if( !FileExists( pObj->aURL ) )
1494                 {
1495                     aPath = aRelURL2.GetMainURL( INetURLObject::NO_DECODE );
1496
1497                     if( aFileName.GetChar( 0 ) != '/' )
1498                         aPath += '/';
1499
1500                     aPath += aFileName;
1501
1502                     // assign this URL, even in the case it is not valid (#94482)
1503                     pObj->aURL = INetURLObject( aPath );
1504                 }
1505             }
1506             else
1507             {
1508                 if( SGA_OBJ_SVDRAW == pObj->eObjKind )
1509                 {
1510                     const static String aBaseURLStr( RTL_CONSTASCII_USTRINGPARAM( "gallery/svdraw/" ) );
1511
1512                     String aDummyURL( aBaseURLStr );
1513                     pObj->aURL = INetURLObject( aDummyURL += aFileName, INET_PROT_PRIV_SOFFICE );
1514                 }
1515                 else
1516                 {
1517                     String aLocalURL;
1518
1519                     pObj->aURL = INetURLObject( aFileName );
1520
1521                     if( ( pObj->aURL.GetProtocol() == INET_PROT_NOT_VALID ) &&
1522                         ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aFileName, aLocalURL ) )
1523                     {
1524                         pObj->aURL = INetURLObject( aLocalURL );
1525                     }
1526                 }
1527             }
1528
1529             aObjectList.Insert( pObj, LIST_APPEND );
1530         }
1531
1532         rIStm >> nId1 >> nId2;
1533
1534         // in neueren Versionen befindet sich am Ende ein 512-Byte-Reservepuffer;
1535         // die Daten befinden sich am Anfang dieses Puffers und
1536         // sind durch eine VersionCompat geklammert
1537         if( !rIStm.IsEof() &&
1538             nId1 == COMPAT_FORMAT( 'G', 'A', 'L', 'R' ) &&
1539             nId2 == COMPAT_FORMAT( 'E', 'S', 'R', 'V' ) )
1540         {
1541             VersionCompat*      pCompat = new VersionCompat( rIStm, STREAM_READ );
1542             sal_uInt32          nTemp32;
1543             BOOL                        bThemeNameFromResource = FALSE;
1544
1545             rIStm >> nTemp32;
1546
1547             if( pCompat->GetVersion() >= 2 )
1548             {
1549                 rIStm >> bThemeNameFromResource;
1550             }
1551
1552             SetId( nTemp32, bThemeNameFromResource );
1553             delete pCompat;
1554         }
1555     }
1556     else
1557         rIStm.SetError( SVSTREAM_READ_ERROR );
1558
1559     ImplSetModified( FALSE );
1560
1561     return rIStm;
1562 }
1563
1564 // ------------------------------------------------------------------------
1565
1566 SvStream& operator<<( SvStream& rOut, const GalleryTheme& rTheme )
1567 {
1568     return rTheme.WriteData( rOut );
1569 }
1570
1571 // ------------------------------------------------------------------------
1572
1573 SvStream& operator>>( SvStream& rIn, GalleryTheme& rTheme )
1574 {
1575     return rTheme.ReadData( rIn );
1576 }