sd/source/ui/app/sdxfer.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 <com/sun/star/embed/XTransactedObject.hpp>
  21 #include <com/sun/star/embed/XEmbedPersist.hpp>
  22 #include <com/sun/star/embed/ElementModes.hpp>
  23 #include <com/sun/star/lang/XComponent.hpp>
  24 #include <osl/mutex.hxx>
  25 #include <unotools/ucbstreamhelper.hxx>
  26 #include <unotools/tempfile.hxx>
  27 #include <editeng/eeitem.hxx>
  28 #include <editeng/flditem.hxx>
  29 #include <svx/svdpagv.hxx>
  30 #include <sfx2/app.hxx>
  31 #include <vcl/msgbox.hxx>
  32 #include <svx/svdoole2.hxx>
  33 #include <svx/svdograf.hxx>
  34 #include <svx/svdotext.hxx>
  35 #include <editeng/outlobj.hxx>
  36 #include <sot/storage.hxx>
  37 #include <svl/itempool.hxx>
  38 #include <editeng/editobj.hxx>
  39 #include <svx/fmglob.hxx>
  40 #include <svx/svdouno.hxx>
  41 #include <sot/formats.hxx>
  42 #include <svl/urlbmk.hxx>
  43 #include <editeng/outliner.hxx>
  44
  45 #include <com/sun/star/form/FormButtonType.hpp>
  46 #include <com/sun/star/beans/XPropertySet.hpp>
  47 #include <unotools/streamwrap.hxx>
  48
  49 #include <svx/svdotable.hxx>
  50 #include <svx/unomodel.hxx>
  51 #include <svx/svditer.hxx>
  52 #include <sfx2/docfile.hxx>
  53 #include <comphelper/storagehelper.hxx>
  54 #include <comphelper/servicehelper.hxx>
  55 #include <svtools/embedtransfer.hxx>
  56 #include "DrawDocShell.hxx"
  57 #include "View.hxx"
  58 #include "sdpage.hxx"
  59 #include "drawview.hxx"
  60 #include "drawdoc.hxx"
  61 #include "stlpool.hxx"
  62 #include "strings.hrc"
  63 #include "sdresid.hxx"
  64 #include "imapinfo.hxx"
  65 #include "sdxfer.hxx"
  66 #include "unomodel.hxx"
  67 #include <vcl/virdev.hxx>
  68
  69 using namespace ::com::sun::star;
  70 using namespace ::com::sun::star::lang;
  71 using namespace ::com::sun::star::uno;
  72 using namespace ::com::sun::star::io;
  73 using namespace ::com::sun::star::datatransfer;
  74 using namespace ::com::sun::star::datatransfer::clipboard;
  75
  76 #define SDTRANSFER_OBJECTTYPE_DRAWMODEL         0x00000001
  77 #define SDTRANSFER_OBJECTTYPE_DRAWOLE           0x00000002
  78
  79 SdTransferable::SdTransferable( SdDrawDocument* pSrcDoc, ::sd::View* pWorkView, sal_Bool bInitOnGetData )
  80 :   mpPageDocShell( NULL )
  81 ,   mpOLEDataHelper( NULL )
  82 ,   mpObjDesc( NULL )
  83 ,   mpSdView( pWorkView )
  84 ,   mpSdViewIntern( pWorkView )
  85 ,   mpSdDrawDocument( NULL )
  86 ,   mpSdDrawDocumentIntern( NULL )
  87 ,   mpSourceDoc( pSrcDoc )
  88 ,   mpVDev( NULL )
  89 ,   mpBookmark( NULL )
  90 ,   mpGraphic( NULL )
  91 ,   mpImageMap( NULL )
  92 ,   mbInternalMove( sal_False )
  93 ,   mbOwnDocument( sal_False )
  94 ,   mbOwnView( sal_False )
  95 ,   mbLateInit( bInitOnGetData )
  96 ,   mbPageTransferable( sal_False )
  97 ,   mbPageTransferablePersistent( sal_False )
  98 ,   mbIsUnoObj( false )
  99 ,   maUserData()
 100 {
 101     if( mpSourceDoc )
 102         StartListening( *mpSourceDoc );
 103
 104     if( pWorkView )
 105         StartListening( *pWorkView );
 106
 107     if( !mbLateInit )
 108         CreateData();
 109 }
 110
 111 SdTransferable::~SdTransferable()
 112 {
 113     if( mpSourceDoc )
 114         EndListening( *mpSourceDoc );
 115
 116     if( mpSdView )
 117         EndListening( *const_cast< sd::View *>( mpSdView) );
 118
 119     SolarMutexGuard aSolarGuard;
 120
 121     ObjectReleased();
 122
 123     if( mbOwnView )
 124         delete mpSdViewIntern;
 125
 126     delete mpOLEDataHelper;
 127
 128     if( maDocShellRef.Is() )
 129     {
 130         SfxObjectShell* pObj = maDocShellRef;
 131         ::sd::DrawDocShell* pDocSh = static_cast< ::sd::DrawDocShell*>(pObj);
 132         pDocSh->DoClose();
 133     }
 134
 135     maDocShellRef.Clear();
 136
 137     if( mbOwnDocument )
 138         delete mpSdDrawDocumentIntern;
 139
 140     delete mpGraphic;
 141     delete mpBookmark;
 142     delete mpImageMap;
 143
 144     delete mpVDev;
 145     delete mpObjDesc;
 146
 147 }
 148
 149 void SdTransferable::CreateObjectReplacement( SdrObject* pObj )
 150 {
 151     if( pObj )
 152     {
 153         delete mpOLEDataHelper, mpOLEDataHelper = NULL;
 154         delete mpGraphic, mpGraphic = NULL;
 155         delete mpBookmark, mpBookmark = NULL;
 156         delete mpImageMap, mpImageMap = NULL;
 157
 158         if( pObj->ISA( SdrOle2Obj ) )
 159         {
 160             try
 161             {
 162                 uno::Reference < embed::XEmbeddedObject > xObj = static_cast< SdrOle2Obj* >( pObj )->GetObjRef();
 163                 uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY );
 164                 if( xObj.is() && xPersist.is() && xPersist->hasEntry() )
 165                 {
 166                     mpOLEDataHelper = new TransferableDataHelper( new SvEmbedTransferHelper( xObj, static_cast< SdrOle2Obj* >( pObj )->GetGraphic(), static_cast< SdrOle2Obj* >( pObj )->GetAspect() ) );
 167
 168                     // TODO/LATER: the standalone handling of the graphic should not be used any more in future
 169                     // The EmbedDataHelper should bring the graphic in future
 170                     const Graphic* pObjGr = static_cast< SdrOle2Obj* >( pObj )->GetGraphic();
 171                     if ( pObjGr )
 172                         mpGraphic = new Graphic( *pObjGr );
 173                 }
 174             }
 175             catch( uno::Exception& )
 176             {}
 177         }
 178         else if( pObj->ISA( SdrGrafObj ) && (mpSourceDoc && !mpSourceDoc->GetAnimationInfo( pObj )) )
 179         {
 180             mpGraphic = new Graphic( static_cast< SdrGrafObj* >( pObj )->GetTransformedGraphic() );
 181         }
 182         else if( pObj->IsUnoObj() && FmFormInventor == pObj->GetObjInventor() && ( pObj->GetObjIdentifier() == (sal_uInt16) OBJ_FM_BUTTON ) )
 183         {
 184             SdrUnoObj* pUnoCtrl = static_cast< SdrUnoObj* >( pObj );
 185
 186             if (pUnoCtrl && FmFormInventor == pUnoCtrl->GetObjInventor())
 187             {
 188                 Reference< ::com::sun::star::awt::XControlModel > xControlModel( pUnoCtrl->GetUnoControlModel() );
 189
 190                 if( !xControlModel.is() )
 191                     return;
 192
 193                 Reference< ::com::sun::star::beans::XPropertySet > xPropSet( xControlModel, UNO_QUERY );
 194
 195                 if( !xPropSet.is() )
 196                     return;
 197
 198                 ::com::sun::star::form::FormButtonType  eButtonType;
 199                 Any                                     aTmp( xPropSet->getPropertyValue( "ButtonType" ) );
 200
 201                 if( aTmp >>= eButtonType )
 202                 {
 203                     OUString aLabel, aURL;
 204
 205                     xPropSet->getPropertyValue( "Label" ) >>= aLabel;
 206                     xPropSet->getPropertyValue( "TargetURL" ) >>= aURL;
 207
 208                     mpBookmark = new INetBookmark( String( aURL ), String( aLabel ) );
 209                 }
 210             }
 211         }
 212         else if( pObj->ISA( SdrTextObj ) )
 213         {
 214             const OutlinerParaObject* pPara;
 215
 216             if( (pPara = static_cast< SdrTextObj* >( pObj )->GetOutlinerParaObject()) != 0 )
 217             {
 218                 const SvxFieldItem* pField;
 219
 220                 if( (pField = pPara->GetTextObject().GetField()) != 0 )
 221                 {
 222                     const SvxFieldData* pData = pField->GetField();
 223
 224                     if( pData && pData->ISA( SvxURLField ) )
 225                     {
 226                         const SvxURLField* pURL = (SvxURLField*) pData;
 227
 228                         mpBookmark = new INetBookmark( pURL->GetURL(), pURL->GetRepresentation() );
 229                     }
 230                 }
 231             }
 232         }
 233
 234         SdIMapInfo* pInfo = static_cast< SdDrawDocument* >( pObj->GetModel() )->GetIMapInfo( static_cast< SdrObject* >( pObj ) );
 235
 236         if( pInfo )
 237             mpImageMap = new ImageMap( pInfo->GetImageMap() );
 238
 239         mbIsUnoObj = pObj && pObj->IsUnoObj();
 240     }
 241 }
 242
 243 void SdTransferable::CreateData()
 244 {
 245     if( mpSdDrawDocument && !mpSdViewIntern )
 246     {
 247         mbOwnView = sal_True;
 248
 249         SdPage* pPage = mpSdDrawDocument->GetSdPage(0, PK_STANDARD);
 250
 251         if( 1 == pPage->GetObjCount() )
 252             CreateObjectReplacement( pPage->GetObj( 0 ) );
 253
 254         mpVDev = new VirtualDevice( *Application::GetDefaultDevice() );
 255         mpVDev->SetMapMode( MapMode( mpSdDrawDocumentIntern->GetScaleUnit(), Point(), mpSdDrawDocumentIntern->GetScaleFraction(), mpSdDrawDocumentIntern->GetScaleFraction() ) );
 256         mpSdViewIntern = new ::sd::View( *mpSdDrawDocumentIntern, mpVDev );
 257         mpSdViewIntern->EndListening(*mpSdDrawDocumentIntern );
 258         mpSdViewIntern->hideMarkHandles();
 259         SdrPageView* pPageView = mpSdViewIntern->ShowSdrPage(pPage);
 260         ((SdrMarkView*)mpSdViewIntern)->MarkAllObj(pPageView);
 261     }
 262     else if( mpSdView && !mpSdDrawDocumentIntern )
 263     {
 264         const SdrMarkList& rMarkList = mpSdView->GetMarkedObjectList();
 265
 266         if( rMarkList.GetMarkCount() == 1 )
 267             CreateObjectReplacement( rMarkList.GetMark( 0 )->GetMarkedSdrObj() );
 268
 269         if( mpSourceDoc )
 270             mpSourceDoc->CreatingDataObj(this);
 271         mpSdDrawDocumentIntern = (SdDrawDocument*) mpSdView->GetMarkedObjModel();
 272         if( mpSourceDoc )
 273             mpSourceDoc->CreatingDataObj(0);
 274
 275         if( !maDocShellRef.Is() && mpSdDrawDocumentIntern->GetDocSh() )
 276             maDocShellRef = mpSdDrawDocumentIntern->GetDocSh();
 277
 278         if( !maDocShellRef.Is() )
 279         {
 280             OSL_FAIL( "SdTransferable::CreateData(), failed to create a model with persist, clipboard operation will fail for OLE objects!" );
 281             mbOwnDocument = sal_True;
 282         }
 283
 284         // Use dimension of source page
 285         SdrPageView*        pPgView = mpSdView->GetSdrPageView();
 286         SdPage*             pOldPage = (SdPage*) pPgView->GetPage();
 287         SdrModel*           pOldModel = mpSdView->GetModel();
 288         SdStyleSheetPool*   pOldStylePool = (SdStyleSheetPool*) pOldModel->GetStyleSheetPool();
 289         SdStyleSheetPool*   pNewStylePool = (SdStyleSheetPool*) mpSdDrawDocumentIntern->GetStyleSheetPool();
 290         SdPage*             pPage = mpSdDrawDocumentIntern->GetSdPage( 0, PK_STANDARD );
 291         String              aOldLayoutName( pOldPage->GetLayoutName() );
 292
 293         pPage->SetSize( pOldPage->GetSize() );
 294         pPage->SetLayoutName( aOldLayoutName );
 295         pNewStylePool->CopyGraphicSheets( *pOldStylePool );
 296         pNewStylePool->CopyCellSheets( *pOldStylePool );
 297         pNewStylePool->CopyTableStyles( *pOldStylePool );
 298         aOldLayoutName.Erase( aOldLayoutName.SearchAscii( SD_LT_SEPARATOR ) );
 299         SdStyleSheetVector aCreatedSheets;
 300         pNewStylePool->CopyLayoutSheets( aOldLayoutName, *pOldStylePool, aCreatedSheets );
 301     }
 302
 303     // set VisArea and adjust objects if necessary
 304     if( maVisArea.IsEmpty() &&
 305         mpSdDrawDocumentIntern && mpSdViewIntern &&
 306         mpSdDrawDocumentIntern->GetPageCount() )
 307     {
 308         SdPage* pPage = mpSdDrawDocumentIntern->GetSdPage( 0, PK_STANDARD );
 309
 310         if( 1 == mpSdDrawDocumentIntern->GetPageCount() )
 311         {
 312             // #112978# need to use GetAllMarkedBoundRect instead of GetAllMarkedRect to get
 313             // fat lines correctly
 314             Point   aOrigin( ( maVisArea = mpSdViewIntern->GetAllMarkedBoundRect() ).TopLeft() );
 315             Size    aVector( -aOrigin.X(), -aOrigin.Y() );
 316
 317             for( sal_uLong nObj = 0, nObjCount = pPage->GetObjCount(); nObj < nObjCount; nObj++ )
 318             {
 319                 SdrObject* pObj = pPage->GetObj( nObj );
 320                 pObj->NbcMove( aVector );
 321             }
 322         }
 323         else
 324             maVisArea.SetSize( pPage->GetSize() );
 325
 326         // output is at the zero point
 327         maVisArea.SetPos( Point() );
 328     }
 329 }
 330
 331 static sal_Bool lcl_HasOnlyControls( SdrModel* pModel )
 332 {
 333     sal_Bool bOnlyControls = sal_False;         // default if there are no objects
 334
 335     if ( pModel )
 336     {
 337         SdrPage* pPage = pModel->GetPage(0);
 338         if (pPage)
 339         {
 340             SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
 341             SdrObject* pObj = aIter.Next();
 342             if ( pObj )
 343             {
 344                 bOnlyControls = sal_True;   // only set if there are any objects at all
 345                 while ( pObj )
 346                 {
 347                     if (!pObj->ISA(SdrUnoObj))
 348                     {
 349                         bOnlyControls = sal_False;
 350                         break;
 351                     }
 352                     pObj = aIter.Next();
 353                 }
 354             }
 355         }
 356     }
 357
 358     return bOnlyControls;
 359 }
 360
 361 static bool lcl_HasOnlyOneTable( SdrModel* pModel )
 362 {
 363     if ( pModel )
 364     {
 365         SdrPage* pPage = pModel->GetPage(0);
 366         if (pPage && pPage->GetObjCount() == 1 )
 367         {
 368             if( dynamic_cast< sdr::table::SdrTableObj* >( pPage->GetObj(0) ) != 0 )
 369                 return true;
 370         }
 371     }
 372     return false;
 373 }
 374
 375 void SdTransferable::AddSupportedFormats()
 376 {
 377     if( !mbPageTransferable || mbPageTransferablePersistent )
 378     {
 379         if( !mbLateInit )
 380             CreateData();
 381
 382         if( mpObjDesc )
 383             AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR );
 384
 385         if( mpOLEDataHelper )
 386         {
 387             AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE );
 388
 389             DataFlavorExVector              aVector( mpOLEDataHelper->GetDataFlavorExVector() );
 390             DataFlavorExVector::iterator    aIter( aVector.begin() ), aEnd( aVector.end() );
 391
 392             while( aIter != aEnd )
 393                 AddFormat( *aIter++ );
 394         }
 395         else if( mpGraphic )
 396         {
 397             // #i25616#
 398             AddFormat( SOT_FORMATSTR_ID_DRAWING );
 399
 400             AddFormat( SOT_FORMATSTR_ID_SVXB );
 401
 402             if( mpGraphic->GetType() == GRAPHIC_BITMAP )
 403             {
 404                 AddFormat( SOT_FORMAT_BITMAP );
 405                 AddFormat( SOT_FORMAT_GDIMETAFILE );
 406             }
 407             else
 408             {
 409                 AddFormat( SOT_FORMAT_GDIMETAFILE );
 410                 AddFormat( SOT_FORMAT_BITMAP );
 411             }
 412         }
 413         else if( mpBookmark )
 414         {
 415             AddFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK );
 416             AddFormat( FORMAT_STRING );
 417         }
 418         else
 419         {
 420             AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE );
 421             AddFormat( SOT_FORMATSTR_ID_DRAWING );
 422             if( !mpSdDrawDocument || !lcl_HasOnlyControls( mpSdDrawDocument ) )
 423             {
 424                 AddFormat( SOT_FORMAT_GDIMETAFILE );
 425                 AddFormat( SOT_FORMAT_BITMAP );
 426             }
 427
 428             if( lcl_HasOnlyOneTable( mpSdDrawDocument ) )
 429                 AddFormat( SOT_FORMAT_RTF );
 430         }
 431
 432         if( mpImageMap )
 433             AddFormat( SOT_FORMATSTR_ID_SVIM );
 434     }
 435 }
 436
 437 sal_Bool SdTransferable::GetData( const DataFlavor& rFlavor )
 438 {
 439     if (SD_MOD()==NULL)
 440         return sal_False;
 441
 442     sal_uInt32  nFormat = SotExchange::GetFormat( rFlavor );
 443     sal_Bool    bOK = sal_False;
 444
 445     CreateData();
 446
 447     if( nFormat == SOT_FORMAT_RTF && lcl_HasOnlyOneTable( mpSdDrawDocument ) )
 448     {
 449         bOK = SetTableRTF( mpSdDrawDocument, rFlavor );
 450     }
 451     else if( mpOLEDataHelper && mpOLEDataHelper->HasFormat( rFlavor ) )
 452     {
 453         sal_uLong nOldSwapMode = 0;
 454
 455         if( mpSdDrawDocumentIntern )
 456         {
 457             nOldSwapMode = mpSdDrawDocumentIntern->GetSwapGraphicsMode();
 458             mpSdDrawDocumentIntern->SetSwapGraphicsMode( SDR_SWAPGRAPHICSMODE_PURGE );
 459         }
 460
 461         // TODO/LATER: support all the graphical formats, the embedded object scenario should not have separated handling
 462         if( nFormat == FORMAT_GDIMETAFILE && mpGraphic )
 463             bOK = SetGDIMetaFile( mpGraphic->GetGDIMetaFile(), rFlavor );
 464         else
 465             bOK = SetAny( mpOLEDataHelper->GetAny( rFlavor ), rFlavor );
 466
 467         if( mpSdDrawDocumentIntern )
 468             mpSdDrawDocumentIntern->SetSwapGraphicsMode( nOldSwapMode );
 469     }
 470     else if( HasFormat( nFormat ) )
 471     {
 472         if( ( nFormat == SOT_FORMATSTR_ID_LINKSRCDESCRIPTOR || nFormat == SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) && mpObjDesc )
 473         {
 474             bOK = SetTransferableObjectDescriptor( *mpObjDesc, rFlavor );
 475         }
 476         else if( nFormat == SOT_FORMATSTR_ID_DRAWING )
 477         {
 478             SfxObjectShellRef aOldRef( maDocShellRef );
 479
 480             maDocShellRef.Clear();
 481
 482             if( mpSdViewIntern )
 483             {
 484                 SdDrawDocument& rInternDoc = mpSdViewIntern->GetDoc();
 485                 rInternDoc.CreatingDataObj(this);
 486                 SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( mpSdViewIntern->GetMarkedObjModel() );
 487                 rInternDoc.CreatingDataObj(0);
 488
 489                 bOK = SetObject( pDoc, SDTRANSFER_OBJECTTYPE_DRAWMODEL, rFlavor );
 490
 491                 if( maDocShellRef.Is() )
 492                 {
 493                     maDocShellRef->DoClose();
 494                 }
 495                 else
 496                 {
 497                     delete pDoc;
 498                 }
 499             }
 500
 501             maDocShellRef = aOldRef;
 502         }
 503         else if( nFormat == FORMAT_GDIMETAFILE )
 504         {
 505             if( mpSdViewIntern )
 506                 bOK = SetGDIMetaFile( mpSdViewIntern->GetMarkedObjMetaFile( true ), rFlavor );
 507         }
 508         else if( nFormat == FORMAT_BITMAP )
 509         {
 510             if( mpSdViewIntern )
 511                 bOK = SetBitmap( mpSdViewIntern->GetMarkedObjBitmapEx( true ).GetBitmap(), rFlavor );
 512         }
 513         else if( ( nFormat == FORMAT_STRING ) && mpBookmark )
 514         {
 515             bOK = SetString( mpBookmark->GetURL(), rFlavor );
 516         }
 517         else if( ( nFormat == SOT_FORMATSTR_ID_SVXB ) && mpGraphic )
 518         {
 519             bOK = SetGraphic( *mpGraphic, rFlavor );
 520         }
 521         else if( ( nFormat == SOT_FORMATSTR_ID_SVIM ) && mpImageMap )
 522         {
 523             bOK = SetImageMap( *mpImageMap, rFlavor );
 524         }
 525         else if( mpBookmark )
 526         {
 527             bOK = SetINetBookmark( *mpBookmark, rFlavor );
 528         }
 529         else if( nFormat == SOT_FORMATSTR_ID_EMBED_SOURCE )
 530         {
 531             sal_uLong nOldSwapMode = 0;
 532
 533             if( mpSdDrawDocumentIntern )
 534             {
 535                 nOldSwapMode = mpSdDrawDocumentIntern->GetSwapGraphicsMode();
 536                 mpSdDrawDocumentIntern->SetSwapGraphicsMode( SDR_SWAPGRAPHICSMODE_PURGE );
 537             }
 538
 539             if( !maDocShellRef.Is() )
 540             {
 541                 maDocShellRef = new ::sd::DrawDocShell(
 542                     mpSdDrawDocumentIntern,
 543                     SFX_CREATE_MODE_EMBEDDED,
 544                     sal_True,
 545                     mpSdDrawDocumentIntern->GetDocumentType());
 546                 mbOwnDocument = sal_False;
 547                 maDocShellRef->DoInitNew( NULL );
 548             }
 549
 550             maDocShellRef->SetVisArea( maVisArea );
 551             bOK = SetObject( &maDocShellRef, SDTRANSFER_OBJECTTYPE_DRAWOLE, rFlavor );
 552
 553             if( mpSdDrawDocumentIntern )
 554                 mpSdDrawDocumentIntern->SetSwapGraphicsMode( nOldSwapMode );
 555         }
 556     }
 557
 558     return bOK;
 559 }
 560
 561 sal_Bool SdTransferable::WriteObject( SotStorageStreamRef& rxOStm, void* pObject, sal_uInt32 nObjectType, const DataFlavor& )
 562 {
 563     sal_Bool bRet = sal_False;
 564
 565     switch( nObjectType )
 566     {
 567         case( SDTRANSFER_OBJECTTYPE_DRAWMODEL ):
 568         {
 569             try
 570             {
 571                 static const sal_Bool bDontBurnInStyleSheet = ( getenv( "AVOID_BURN_IN_FOR_GALLERY_THEME" ) != NULL );
 572                 SdDrawDocument* pDoc = (SdDrawDocument*) pObject;
 573                 if ( !bDontBurnInStyleSheet )
 574                     pDoc->BurnInStyleSheetAttributes();
 575                 rxOStm->SetBufferSize( 16348 );
 576
 577                 Reference< XComponent > xComponent( new SdXImpressDocument( pDoc, sal_True ) );
 578                 pDoc->setUnoModel( Reference< XInterface >::query( xComponent ) );
 579
 580                 {
 581                     com::sun::star::uno::Reference<com::sun::star::io::XOutputStream> xDocOut( new utl::OOutputStreamWrapper( *rxOStm ) );
 582                     if( SvxDrawingLayerExport( pDoc, xDocOut, xComponent, (pDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) ? "com.sun.star.comp.Impress.XMLClipboardExporter" : "com.sun.star.comp.DrawingLayer.XMLExporter" ) )
 583                         rxOStm->Commit();
 584                 }
 585
 586                 xComponent->dispose();
 587                 bRet = ( rxOStm->GetError() == ERRCODE_NONE );
 588             }
 589             catch( Exception& )
 590             {
 591                 OSL_FAIL( "sd::SdTransferable::WriteObject(), exception catched!" );
 592                 bRet = sal_False;
 593             }
 594         }
 595         break;
 596
 597         case( SDTRANSFER_OBJECTTYPE_DRAWOLE ):
 598         {
 599             SfxObjectShell*   pEmbObj = (SfxObjectShell*) pObject;
 600             ::utl::TempFile     aTempFile;
 601             aTempFile.EnableKillingFile();
 602
 603             try
 604             {
 605                 uno::Reference< embed::XStorage > xWorkStore =
 606                     ::comphelper::OStorageHelper::GetStorageFromURL( aTempFile.GetURL(), embed::ElementModes::READWRITE );
 607
 608                 // write document storage
 609                 pEmbObj->SetupStorage( xWorkStore, SOFFICE_FILEFORMAT_CURRENT, sal_False );
 610                 // mba: no relative ULRs for clipboard!
 611                 SfxMedium aMedium( xWorkStore, String() );
 612                 bRet = pEmbObj->DoSaveObjectAs( aMedium, sal_False );
 613                 pEmbObj->DoSaveCompleted();
 614
 615                 uno::Reference< embed::XTransactedObject > xTransact( xWorkStore, uno::UNO_QUERY );
 616                 if ( xTransact.is() )
 617                     xTransact->commit();
 618
 619                 SvStream* pSrcStm = ::utl::UcbStreamHelper::CreateStream( aTempFile.GetURL(), STREAM_READ );
 620                 if( pSrcStm )
 621                 {
 622                     rxOStm->SetBufferSize( 0xff00 );
 623                     *rxOStm << *pSrcStm;
 624                     delete pSrcStm;
 625                 }
 626
 627                 bRet = sal_True;
 628                 rxOStm->Commit();
 629             }
 630             catch ( Exception& )
 631             {}
 632         }
 633
 634         break;
 635
 636         default:
 637         break;
 638     }
 639
 640     return bRet;
 641 }
 642
 643 void SdTransferable::DragFinished( sal_Int8 nDropAction )
 644 {
 645     if( mpSdView )
 646         ( (::sd::View*) mpSdView )->DragFinished( nDropAction );
 647 }
 648
 649 void SdTransferable::ObjectReleased()
 650 {
 651     if( this == SD_MOD()->pTransferClip )
 652         SD_MOD()->pTransferClip = NULL;
 653
 654     if( this == SD_MOD()->pTransferDrag )
 655         SD_MOD()->pTransferDrag = NULL;
 656
 657     if( this == SD_MOD()->pTransferSelection )
 658         SD_MOD()->pTransferSelection = NULL;
 659 }
 660
 661 void SdTransferable::SetObjectDescriptor( const TransferableObjectDescriptor& rObjDesc )
 662 {
 663     delete mpObjDesc;
 664     mpObjDesc = new TransferableObjectDescriptor( rObjDesc );
 665     PrepareOLE( rObjDesc );
 666 }
 667
 668 void SdTransferable::SetPageBookmarks( const std::vector<OUString> &rPageBookmarks, sal_Bool bPersistent )
 669 {
 670     if( mpSourceDoc )
 671     {
 672         if( mpSdViewIntern )
 673             mpSdViewIntern->HideSdrPage();
 674
 675         mpSdDrawDocument->ClearModel(sal_False);
 676
 677         mpPageDocShell = NULL;
 678
 679         maPageBookmarks.clear();
 680
 681         if( bPersistent )
 682         {
 683             mpSdDrawDocument->CreateFirstPages(mpSourceDoc);
 684             mpSdDrawDocument->InsertBookmarkAsPage( rPageBookmarks, NULL, sal_False, sal_True, 1, sal_True,
 685                                                     mpSourceDoc->GetDocSh(), sal_True, sal_True, sal_False );
 686         }
 687         else
 688         {
 689             mpPageDocShell = mpSourceDoc->GetDocSh();
 690             maPageBookmarks = rPageBookmarks;
 691         }
 692
 693         if( mpSdViewIntern && mpSdDrawDocument )
 694         {
 695             SdPage* pPage = mpSdDrawDocument->GetSdPage( 0, PK_STANDARD );
 696
 697             if( pPage )
 698             {
 699                 ( (SdrMarkView*) mpSdViewIntern )->MarkAllObj( (SdrPageView*) mpSdViewIntern->ShowSdrPage( pPage ) );
 700             }
 701         }
 702
 703         // set flags for page transferable; if ( mbPageTransferablePersistent == sal_False ),
 704         // don't offer any formats => it's just for internal puposes
 705         mbPageTransferable = sal_True;
 706         mbPageTransferablePersistent = bPersistent;
 707     }
 708 }
 709
 710 sal_Int64 SAL_CALL SdTransferable::getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& rId ) throw( ::com::sun::star::uno::RuntimeException )
 711 {
 712     sal_Int64 nRet;
 713
 714     if( ( rId.getLength() == 16 ) &&
 715         ( 0 == memcmp( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) )
 716     {
 717         nRet = sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
 718     }
 719     else
 720     {
 721         nRet = 0;
 722     }
 723
 724     return nRet;
 725 }
 726
 727
 728 SdDrawDocument* SdTransferable::GetSourceDoc (void) const
 729 {
 730     return mpSourceDoc;
 731 }
 732
 733 void SdTransferable::AddUserData (const ::boost::shared_ptr<UserData>& rpData)
 734 {
 735     maUserData.push_back(rpData);
 736 }
 737
 738 sal_Int32 SdTransferable::GetUserDataCount (void) const
 739 {
 740     return maUserData.size();
 741 }
 742
 743 ::boost::shared_ptr<SdTransferable::UserData> SdTransferable::GetUserData (const sal_Int32 nIndex) const
 744 {
 745     if (nIndex>=0 && nIndex<sal_Int32(maUserData.size()))
 746         return maUserData[nIndex];
 747     else
 748         return ::boost::shared_ptr<UserData>();
 749 }
 750
 751 namespace
 752 {
 753     class theSdTransferableUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSdTransferableUnoTunnelId > {};
 754 }
 755
 756 const ::com::sun::star::uno::Sequence< sal_Int8 >& SdTransferable::getUnoTunnelId()
 757 {
 758     return theSdTransferableUnoTunnelId::get().getSeq();
 759 }
 760
 761 SdTransferable* SdTransferable::getImplementation( const Reference< XInterface >& rxData ) throw()
 762 {
 763     try
 764     {
 765         Reference< ::com::sun::star::lang::XUnoTunnel > xUnoTunnel( rxData, UNO_QUERY_THROW );
 766         return reinterpret_cast<SdTransferable*>(sal::static_int_cast<sal_uIntPtr>(xUnoTunnel->getSomething( SdTransferable::getUnoTunnelId()) ) );
 767     }
 768     catch( const ::com::sun::star::uno::Exception& )
 769     {
 770     }
 771     return NULL;
 772 }
 773
 774 void SdTransferable::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
 775 {
 776     const SdrHint* pSdrHint = dynamic_cast< const SdrHint* >( &rHint );
 777     if( pSdrHint )
 778     {
 779         if( HINT_MODELCLEARED == pSdrHint->GetKind() )
 780         {
 781             EndListening(*mpSourceDoc);
 782             mpSourceDoc = 0;
 783         }
 784     }
 785     else
 786     {
 787         const SfxSimpleHint* pSimpleHint = dynamic_cast< const SfxSimpleHint * >(&rHint);
 788         if(pSimpleHint && (pSimpleHint->GetId() == SFX_HINT_DYING) )
 789         {
 790             if( &rBC == mpSourceDoc )
 791                 mpSourceDoc = 0;
 792             if( &rBC == mpSdViewIntern )
 793                 mpSdViewIntern = 0;
 794             if( &rBC == mpSdView )
 795                 mpSdView = 0;
 796         }
 797     }
 798 }
 799
 800 sal_Bool SdTransferable::SetTableRTF( SdDrawDocument* pModel, const DataFlavor& rFlavor)
 801 {
 802     if ( pModel )
 803     {
 804         SdrPage* pPage = pModel->GetPage(0);
 805         if (pPage && pPage->GetObjCount() == 1 )
 806         {
 807             sdr::table::SdrTableObj* pTableObj = dynamic_cast< sdr::table::SdrTableObj* >( pPage->GetObj(0) );
 808             if( pTableObj )
 809             {
 810                 SvMemoryStream aMemStm( 65535, 65535 );
 811                 sdr::table::SdrTableObj::ExportAsRTF( aMemStm, *pTableObj );
 812                 return SetAny( Any( Sequence< sal_Int8 >( reinterpret_cast< const sal_Int8* >( aMemStm.GetData() ), aMemStm.Seek( STREAM_SEEK_TO_END ) ) ), rFlavor );
 813             }
 814         }
 815     }
 816
 817     return sal_False;
 818 }
 819
 820 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */