svx/source/gallery2/galtheme.cxx

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