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