sc/source/ui/app/drwtrans.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/uno/Exception.hpp>
  23
  24 #include <com/sun/star/beans/XPropertySet.hpp>
  25 #include <com/sun/star/beans/XPropertySetInfo.hpp>
  26 #include <com/sun/star/form/FormButtonType.hpp>
  27 #include <toolkit/helper/vclunohelper.hxx>
  28 #include <unotools/streamwrap.hxx>
  29
  30 #include <svx/unomodel.hxx>
  31 #include <unotools/tempfile.hxx>
  32 #include <unotools/ucbstreamhelper.hxx>
  33 #include <comphelper/storagehelper.hxx>
  34 #include <comphelper/servicehelper.hxx>
  35
  36 #include <svtools/embedtransfer.hxx>
  37 #include <sot/storage.hxx>
  38 #include <vcl/virdev.hxx>
  39 #include <svx/fmglob.hxx>
  40 #include <svx/svditer.hxx>
  41 #include <svx/svdograf.hxx>
  42 #include <svx/svdoole2.hxx>
  43 #include <svx/svdouno.hxx>
  44 #include <svx/svdpage.hxx>
  45 #include <svx/svdxcgv.hxx>
  46 #include <sfx2/docfile.hxx>
  47 #include <svl/itempool.hxx>
  48 #include <svl/urlbmk.hxx>
  49 #include <tools/urlobj.hxx>
  50 #include <osl/mutex.hxx>
  51
  52 #include "drwtrans.hxx"
  53 #include "docsh.hxx"
  54 #include "drwlayer.hxx"
  55 #include "drawview.hxx"
  56 #include "viewdata.hxx"
  57 #include "scmod.hxx"
  58 #include "chartlis.hxx"
  59 #include "rangeutl.hxx"
  60 #include <formula/grammar.hxx>
  61 #include "dragdata.hxx"
  62 #include "clipdata.hxx"
  63
  64 // #108584#
  65 #include "scitems.hxx"
  66
  67 // #108584#
  68 #include <editeng/eeitem.hxx>
  69
  70 // #108584#
  71 #include <editeng/fhgtitem.hxx>
  72 #include <vcl/svapp.hxx>
  73
  74 using namespace com::sun::star;
  75
  76 #define SCDRAWTRANS_TYPE_EMBOBJ         SotClipboardFormatId::STRING
  77 #define SCDRAWTRANS_TYPE_DRAWMODEL      SotClipboardFormatId::BITMAP
  78 #define SCDRAWTRANS_TYPE_DOCUMENT       SotClipboardFormatId::GDIMETAFILE
  79
  80 ScDrawTransferObj::ScDrawTransferObj( SdrModel* pClipModel, ScDocShell* pContainerShell,
  81                                         const TransferableObjectDescriptor& rDesc ) :
  82     pModel( pClipModel ),
  83     aObjDesc( rDesc ),
  84     pBookmark( NULL ),
  85     bGraphic( false ),
  86     bGrIsBit( false ),
  87     bOleObj( false ),
  88     pDragSourceView( NULL ),
  89     nDragSourceFlags( 0 ),
  90     bDragWasInternal( false ),
  91     nSourceDocID( 0 ),
  92     maShellID(SfxObjectShell::CreateShellID(pContainerShell))
  93 {
  94
  95     //  check what kind of objects are contained
  96
  97     SdrPage* pPage = pModel->GetPage(0);
  98     if (pPage)
  99     {
 100         SdrObjListIter aIter( *pPage, IM_FLAT );
 101         SdrObject* pObject = aIter.Next();
 102         if (pObject && !aIter.Next())               // exactly one object?
 103         {
 104
 105             //  OLE object
 106
 107             sal_uInt16 nSdrObjKind = pObject->GetObjIdentifier();
 108             if (nSdrObjKind == OBJ_OLE2)
 109             {
 110                 // if object has no persistence it must be copied as a part of document
 111                 try
 112                 {
 113                     uno::Reference< embed::XEmbedPersist > xPersObj( static_cast<SdrOle2Obj*>(pObject)->GetObjRef(), uno::UNO_QUERY );
 114                     if ( xPersObj.is() && xPersObj->hasEntry() )
 115                         bOleObj = true;
 116                 }
 117                 catch( uno::Exception& )
 118                 {}
 119                 // aOleData is initialized later
 120             }
 121
 122             //  Graphic object
 123
 124             if (nSdrObjKind == OBJ_GRAF)
 125             {
 126                 bGraphic = true;
 127                 if ( static_cast<SdrGrafObj*>(pObject)->GetGraphic().GetType() == GRAPHIC_BITMAP )
 128                     bGrIsBit = true;
 129             }
 130
 131             //  URL button
 132
 133             SdrUnoObj* pUnoCtrl = PTR_CAST(SdrUnoObj, pObject);
 134             if (pUnoCtrl && FmFormInventor == pUnoCtrl->GetObjInventor())
 135             {
 136                 uno::Reference<awt::XControlModel> xControlModel = pUnoCtrl->GetUnoControlModel();
 137                 OSL_ENSURE( xControlModel.is(), "uno control without model" );
 138                 if ( xControlModel.is() )
 139                 {
 140                     uno::Reference< beans::XPropertySet > xPropSet( xControlModel, uno::UNO_QUERY );
 141                     uno::Reference< beans::XPropertySetInfo > xInfo = xPropSet->getPropertySetInfo();
 142
 143                     OUString sPropButtonType( "ButtonType" );
 144                     OUString sPropTargetURL( "TargetURL" );
 145                     OUString sPropLabel( "Label" );
 146
 147                     if(xInfo->hasPropertyByName( sPropButtonType ))
 148                     {
 149                         uno::Any aAny = xPropSet->getPropertyValue( sPropButtonType );
 150                         form::FormButtonType eTmp;
 151                         if ( (aAny >>= eTmp) && eTmp == form::FormButtonType_URL )
 152                         {
 153                             // URL
 154                             if(xInfo->hasPropertyByName( sPropTargetURL ))
 155                             {
 156                                 aAny = xPropSet->getPropertyValue( sPropTargetURL );
 157                                 OUString sTmp;
 158                                 if ( (aAny >>= sTmp) && !sTmp.isEmpty() )
 159                                 {
 160                                     OUString aUrl = sTmp;
 161                                     OUString aAbs;
 162                                     const SfxMedium* pMedium;
 163                                     if (pContainerShell && (pMedium = pContainerShell->GetMedium()) != NULL)
 164                                     {
 165                                         bool bWasAbs = true;
 166                                         aAbs = pMedium->GetURLObject().smartRel2Abs( aUrl, bWasAbs ).
 167                                                     GetMainURL(INetURLObject::NO_DECODE);
 168                                         // full path as stored INetBookmark must be encoded
 169                                     }
 170                                     else
 171                                         aAbs = aUrl;
 172
 173                                     // Label
 174                                     OUString aLabel;
 175                                     if(xInfo->hasPropertyByName( sPropLabel ))
 176                                     {
 177                                         aAny = xPropSet->getPropertyValue( sPropLabel );
 178                                         if ( (aAny >>= sTmp) && !sTmp.isEmpty() )
 179                                         {
 180                                             aLabel = sTmp;
 181                                         }
 182                                     }
 183                                     pBookmark = new INetBookmark( aAbs, aLabel );
 184                                 }
 185                             }
 186                         }
 187                     }
 188                 }
 189             }
 190         }
 191     }
 192
 193     //  get size for object descriptor
 194
 195     // #i71538# use complete SdrViews
 196     // SdrExchangeView aView(pModel);
 197     SdrView aView(pModel);
 198     SdrPageView* pPv = aView.ShowSdrPage(aView.GetModel()->GetPage(0));
 199     aView.MarkAllObj(pPv);
 200     aSrcSize = aView.GetAllMarkedRect().GetSize();
 201
 202     if ( bOleObj )              // single OLE object
 203     {
 204         SdrOle2Obj* pObj = GetSingleObject();
 205         if ( pObj && pObj->GetObjRef().is() )
 206             SvEmbedTransferHelper::FillTransferableObjectDescriptor( aObjDesc, pObj->GetObjRef(), pObj->GetGraphic(), pObj->GetAspect() );
 207     }
 208
 209     aObjDesc.maSize = aSrcSize;
 210     PrepareOLE( aObjDesc );
 211
 212     // remember a unique ID of the source document
 213
 214     if ( pContainerShell )
 215     {
 216         ScDocument& rDoc = pContainerShell->GetDocument();
 217         nSourceDocID = rDoc.GetDocumentID();
 218         if ( pPage )
 219         {
 220             ScChartHelper::FillProtectedChartRangesVector( m_aProtectedChartRangesVector, &rDoc, pPage );
 221         }
 222     }
 223 }
 224
 225 ScDrawTransferObj::~ScDrawTransferObj()
 226 {
 227     SolarMutexGuard aSolarGuard;
 228
 229     ScModule* pScMod = SC_MOD();
 230     if ( pScMod->GetClipData().pDrawClipboard == this )
 231     {
 232         OSL_FAIL("ScDrawTransferObj wasn't released");
 233         pScMod->SetClipObject( NULL, NULL );
 234     }
 235     if ( pScMod->GetDragData().pDrawTransfer == this )
 236     {
 237         OSL_FAIL("ScDrawTransferObj wasn't released");
 238         pScMod->ResetDragObject();
 239     }
 240
 241     aOleData = TransferableDataHelper();        // clear before releasing the mutex
 242     aDocShellRef.Clear();
 243
 244     delete pModel;
 245     aDrawPersistRef.Clear();                    // after the model
 246
 247     delete pBookmark;
 248     delete pDragSourceView;
 249 }
 250
 251 ScDrawTransferObj* ScDrawTransferObj::GetOwnClipboard( vcl::Window* )
 252 {
 253     ScDrawTransferObj* pObj = SC_MOD()->GetClipData().pDrawClipboard;
 254     return pObj;
 255 }
 256
 257 static bool lcl_HasOnlyControls( SdrModel* pModel )
 258 {
 259     bool bOnlyControls = false;         // default if there are no objects
 260
 261     if ( pModel )
 262     {
 263         SdrPage* pPage = pModel->GetPage(0);
 264         if (pPage)
 265         {
 266             SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
 267             SdrObject* pObj = aIter.Next();
 268             if ( pObj )
 269             {
 270                 bOnlyControls = true;   // only set if there are any objects at all
 271                 while ( pObj )
 272                 {
 273                     if (!pObj->ISA(SdrUnoObj))
 274                     {
 275                         bOnlyControls = false;
 276                         break;
 277                     }
 278                     pObj = aIter.Next();
 279                 }
 280             }
 281         }
 282     }
 283
 284     return bOnlyControls;
 285 }
 286
 287 void ScDrawTransferObj::AddSupportedFormats()
 288 {
 289     if ( bGrIsBit )             // single bitmap graphic
 290     {
 291         AddFormat( SotClipboardFormatId::OBJECTDESCRIPTOR );
 292         AddFormat( SotClipboardFormatId::SVXB );
 293         AddFormat( SotClipboardFormatId::PNG );
 294         AddFormat( SotClipboardFormatId::BITMAP );
 295         AddFormat( SotClipboardFormatId::GDIMETAFILE );
 296     }
 297     else if ( bGraphic )        // other graphic
 298     {
 299         // #i25616#
 300         AddFormat( SotClipboardFormatId::DRAWING );
 301
 302         AddFormat( SotClipboardFormatId::OBJECTDESCRIPTOR );
 303         AddFormat( SotClipboardFormatId::SVXB );
 304         AddFormat( SotClipboardFormatId::GDIMETAFILE );
 305         AddFormat( SotClipboardFormatId::PNG );
 306         AddFormat( SotClipboardFormatId::BITMAP );
 307     }
 308     else if ( pBookmark )       // url button
 309     {
 310 //      AddFormat( SotClipboardFormatId::EMBED_SOURCE );
 311         AddFormat( SotClipboardFormatId::OBJECTDESCRIPTOR );
 312         AddFormat( SotClipboardFormatId::SOLK );
 313         AddFormat( SotClipboardFormatId::STRING );
 314         AddFormat( SotClipboardFormatId::UNIFORMRESOURCELOCATOR );
 315         AddFormat( SotClipboardFormatId::NETSCAPE_BOOKMARK );
 316         AddFormat( SotClipboardFormatId::DRAWING );
 317     }
 318     else if ( bOleObj )         // single OLE object
 319     {
 320         AddFormat( SotClipboardFormatId::EMBED_SOURCE );
 321         AddFormat( SotClipboardFormatId::OBJECTDESCRIPTOR );
 322         AddFormat( SotClipboardFormatId::GDIMETAFILE );
 323
 324         CreateOLEData();
 325
 326         if ( aOleData.GetTransferable().is() )
 327         {
 328             //  get format list from object snapshot
 329             //  (this must be after inserting the default formats!)
 330
 331             DataFlavorExVector              aVector( aOleData.GetDataFlavorExVector() );
 332             DataFlavorExVector::iterator    aIter( aVector.begin() ), aEnd( aVector.end() );
 333
 334             while( aIter != aEnd )
 335                 AddFormat( *aIter++ );
 336         }
 337     }
 338     else                        // any drawing objects
 339     {
 340         AddFormat( SotClipboardFormatId::EMBED_SOURCE );
 341         AddFormat( SotClipboardFormatId::OBJECTDESCRIPTOR );
 342         AddFormat( SotClipboardFormatId::DRAWING );
 343
 344         // leave out bitmap and metafile if there are only controls
 345         if ( !lcl_HasOnlyControls( pModel ) )
 346         {
 347             AddFormat( SotClipboardFormatId::PNG );
 348             AddFormat( SotClipboardFormatId::BITMAP );
 349             AddFormat( SotClipboardFormatId::GDIMETAFILE );
 350         }
 351     }
 352
 353 //  if( pImageMap )
 354 //      AddFormat( SotClipboardFormatId::SVIM );
 355 }
 356
 357 bool ScDrawTransferObj::GetData( const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc )
 358 {
 359     bool bOK = false;
 360     SotClipboardFormatId nFormat = SotExchange::GetFormat( rFlavor );
 361
 362     if ( bOleObj && nFormat != SotClipboardFormatId::GDIMETAFILE )
 363     {
 364         CreateOLEData();
 365
 366         if( aOleData.GetTransferable().is() && aOleData.HasFormat( rFlavor ) )
 367         {
 368             SdrSwapGraphicsMode nOldSwapMode(SdrSwapGraphicsMode::DEFAULT);
 369
 370             if( pModel )
 371             {
 372                 nOldSwapMode = pModel->GetSwapGraphicsMode();
 373                 pModel->SetSwapGraphicsMode( SdrSwapGraphicsMode::PURGE );
 374             }
 375
 376             bOK = SetAny( aOleData.GetAny(rFlavor, rDestDoc), rFlavor );
 377
 378             if( pModel )
 379                 pModel->SetSwapGraphicsMode( nOldSwapMode );
 380
 381             return bOK;
 382         }
 383     }
 384
 385     if( HasFormat( nFormat ) )
 386     {
 387         if ( nFormat == SotClipboardFormatId::LINKSRCDESCRIPTOR || nFormat == SotClipboardFormatId::OBJECTDESCRIPTOR )
 388         {
 389             bOK = SetTransferableObjectDescriptor( aObjDesc, rFlavor );
 390         }
 391         else if ( nFormat == SotClipboardFormatId::DRAWING )
 392         {
 393             bOK = SetObject( pModel, SCDRAWTRANS_TYPE_DRAWMODEL, rFlavor );
 394         }
 395         else if ( nFormat == SotClipboardFormatId::BITMAP
 396             || nFormat == SotClipboardFormatId::PNG
 397             || nFormat == SotClipboardFormatId::GDIMETAFILE )
 398         {
 399             // #i71538# use complete SdrViews
 400             // SdrExchangeView aView( pModel );
 401             SdrView aView( pModel );
 402             SdrPageView* pPv = aView.ShowSdrPage(aView.GetModel()->GetPage(0));
 403             OSL_ENSURE( pPv, "pPv not there..." );
 404             aView.MarkAllObj( pPv );
 405             if ( nFormat == SotClipboardFormatId::GDIMETAFILE )
 406                 bOK = SetGDIMetaFile( aView.GetMarkedObjMetaFile(true), rFlavor );
 407             else
 408                 bOK = SetBitmapEx( aView.GetMarkedObjBitmapEx(true), rFlavor );
 409         }
 410         else if ( nFormat == SotClipboardFormatId::SVXB )
 411         {
 412             // only enabled for single graphics object
 413
 414             SdrPage* pPage = pModel->GetPage(0);
 415             if (pPage)
 416             {
 417                 SdrObjListIter aIter( *pPage, IM_FLAT );
 418                 SdrObject* pObject = aIter.Next();
 419                 if (pObject && pObject->GetObjIdentifier() == OBJ_GRAF)
 420                 {
 421                     SdrGrafObj* pGraphObj = static_cast<SdrGrafObj*>(pObject);
 422                     bOK = SetGraphic( pGraphObj->GetGraphic(), rFlavor );
 423                 }
 424             }
 425         }
 426         else if ( nFormat == SotClipboardFormatId::EMBED_SOURCE )
 427         {
 428             if ( bOleObj )              // single OLE object
 429             {
 430                 SdrOle2Obj* pObj = GetSingleObject();
 431                 if ( pObj && pObj->GetObjRef().is() )
 432                 {
 433                     bOK = SetObject( pObj->GetObjRef().get(), SCDRAWTRANS_TYPE_EMBOBJ, rFlavor );
 434                 }
 435             }
 436             else                        // create object from contents
 437             {
 438                 //TODO/LATER: needs new Format, because now single OLE and "this" are different
 439                 InitDocShell();         // set aDocShellRef
 440
 441                 SfxObjectShell* pEmbObj = aDocShellRef;
 442                 bOK = SetObject( pEmbObj, SCDRAWTRANS_TYPE_DOCUMENT, rFlavor );
 443             }
 444         }
 445         else if( pBookmark )
 446         {
 447             bOK = SetINetBookmark( *pBookmark, rFlavor );
 448         }
 449     }
 450     return bOK;
 451 }
 452
 453 bool ScDrawTransferObj::WriteObject( tools::SvRef<SotStorageStream>& rxOStm, void* pUserObject, SotClipboardFormatId nUserObjectId,
 454                                         const ::com::sun::star::datatransfer::DataFlavor& /* rFlavor */ )
 455 {
 456     // called from SetObject, put data into stream
 457
 458     bool bRet = false;
 459     switch (nUserObjectId)
 460     {
 461         case SCDRAWTRANS_TYPE_DRAWMODEL:
 462             {
 463                 SdrModel* pDrawModel = static_cast<SdrModel*>(pUserObject);
 464                 rxOStm->SetBufferSize( 0xff00 );
 465
 466                 // #108584#
 467                 // for the changed pool defaults from drawing layer pool set those
 468                 // attributes as hard attributes to preserve them for saving
 469                 const SfxItemPool& rItemPool = pModel->GetItemPool();
 470                 const SvxFontHeightItem& rDefaultFontHeight = static_cast<const SvxFontHeightItem&>(rItemPool.GetDefaultItem(EE_CHAR_FONTHEIGHT));
 471
 472                 // SW should have no MasterPages
 473                 OSL_ENSURE(0L == pModel->GetMasterPageCount(), "SW with MasterPages (!)");
 474
 475                 for(sal_uInt16 a(0); a < pModel->GetPageCount(); a++)
 476                 {
 477                     const SdrPage* pPage = pModel->GetPage(a);
 478                     SdrObjListIter aIter(*pPage, IM_DEEPNOGROUPS);
 479
 480                     while(aIter.IsMore())
 481                     {
 482                         SdrObject* pObj = aIter.Next();
 483                         const SvxFontHeightItem& rItem = static_cast<const SvxFontHeightItem&>(pObj->GetMergedItem(EE_CHAR_FONTHEIGHT));
 484
 485                         if(rItem.GetHeight() == rDefaultFontHeight.GetHeight())
 486                         {
 487                             pObj->SetMergedItem(rDefaultFontHeight);
 488                         }
 489                     }
 490                 }
 491
 492                 {
 493                     com::sun::star::uno::Reference<com::sun::star::io::XOutputStream> xDocOut( new utl::OOutputStreamWrapper( *rxOStm ) );
 494                     if( SvxDrawingLayerExport( pDrawModel, xDocOut ) )
 495                         rxOStm->Commit();
 496                 }
 497
 498                 bRet = ( rxOStm->GetError() == ERRCODE_NONE );
 499             }
 500             break;
 501
 502         case SCDRAWTRANS_TYPE_EMBOBJ:
 503             {
 504                 // impl. for "single OLE"
 505                 embed::XEmbeddedObject* pEmbObj = static_cast<embed::XEmbeddedObject*>(pUserObject);
 506
 507                 ::utl::TempFile     aTempFile;
 508                 aTempFile.EnableKillingFile();
 509                 uno::Reference< embed::XStorage > xWorkStore =
 510                     ::comphelper::OStorageHelper::GetStorageFromURL( aTempFile.GetURL(), embed::ElementModes::READWRITE );
 511
 512                 uno::Reference < embed::XEmbedPersist > xPers( (embed::XVisualObject*)pEmbObj, uno::UNO_QUERY );
 513                 if ( xPers.is() )
 514                 {
 515                     try
 516                     {
 517                         uno::Sequence < beans::PropertyValue > aSeq;
 518                         OUString aDummyName("Dummy");
 519                         xPers->storeToEntry( xWorkStore, aDummyName, aSeq, aSeq );
 520                         if ( xWorkStore->isStreamElement( aDummyName ) )
 521                         {
 522                             uno::Reference < io::XOutputStream > xDocOut( new utl::OOutputStreamWrapper( *rxOStm ) );
 523                             uno::Reference < io::XStream > xNewStream = xWorkStore->openStreamElement( aDummyName, embed::ElementModes::READ );
 524                             ::comphelper::OStorageHelper::CopyInputToOutput( xNewStream->getInputStream(), xDocOut );
 525                         }
 526                         else
 527                         {
 528                             uno::Reference < io::XStream > xDocStr( new utl::OStreamWrapper( *rxOStm ) );
 529                             uno::Reference< embed::XStorage > xDocStg = ::comphelper::OStorageHelper::GetStorageFromStream( xDocStr );
 530                             uno::Reference < embed::XStorage > xNewStg = xWorkStore->openStorageElement( aDummyName, embed::ElementModes::READ );
 531                             xNewStg->copyToStorage( xDocStg );
 532                             uno::Reference < embed::XTransactedObject > xTrans( xDocStg, uno::UNO_QUERY );
 533                             if ( xTrans.is() )
 534                                 xTrans->commit();
 535                         }
 536
 537                         rxOStm->Commit();
 538                     }
 539                     catch ( uno::Exception& )
 540                     {
 541                     }
 542                 }
 543
 544                 break;
 545             }
 546         case SCDRAWTRANS_TYPE_DOCUMENT:
 547             {
 548                 // impl. for "DocShell"
 549                 SfxObjectShell*   pEmbObj = static_cast<SfxObjectShell*>(pUserObject);
 550
 551                 try
 552                 {
 553                     ::utl::TempFile     aTempFile;
 554                     aTempFile.EnableKillingFile();
 555                     uno::Reference< embed::XStorage > xWorkStore =
 556                         ::comphelper::OStorageHelper::GetStorageFromURL( aTempFile.GetURL(), embed::ElementModes::READWRITE );
 557
 558                     // write document storage
 559                     pEmbObj->SetupStorage( xWorkStore, SOFFICE_FILEFORMAT_CURRENT, false, false );
 560
 561                     // mba: no relative URLs for clipboard!
 562                     SfxMedium aMedium( xWorkStore, OUString() );
 563                     bRet = pEmbObj->DoSaveObjectAs( aMedium, false );
 564                     pEmbObj->DoSaveCompleted();
 565
 566                     uno::Reference< embed::XTransactedObject > xTransact( xWorkStore, uno::UNO_QUERY );
 567                     if ( xTransact.is() )
 568                         xTransact->commit();
 569
 570                     SvStream* pSrcStm = ::utl::UcbStreamHelper::CreateStream( aTempFile.GetURL(), StreamMode::READ );
 571                     if( pSrcStm )
 572                     {
 573                         rxOStm->SetBufferSize( 0xff00 );
 574                         rxOStm->WriteStream( *pSrcStm );
 575                         delete pSrcStm;
 576                     }
 577
 578                     bRet = true;
 579
 580                     xWorkStore->dispose();
 581                     xWorkStore = uno::Reference < embed::XStorage >();
 582                     rxOStm->Commit();
 583                 }
 584                 catch ( uno::Exception& )
 585                 {}
 586
 587                 bRet = ( rxOStm->GetError() == ERRCODE_NONE );
 588             }
 589             break;
 590
 591         default:
 592             OSL_FAIL("unknown object id");
 593     }
 594     return bRet;
 595 }
 596
 597 void ScDrawTransferObj::ObjectReleased()
 598 {
 599     ScModule* pScMod = SC_MOD();
 600     if ( pScMod->GetClipData().pDrawClipboard == this )
 601         pScMod->SetClipObject( NULL, NULL );
 602
 603     TransferableHelper::ObjectReleased();
 604 }
 605
 606 void ScDrawTransferObj::DragFinished( sal_Int8 nDropAction )
 607 {
 608     if ( nDropAction == DND_ACTION_MOVE && !bDragWasInternal && !(nDragSourceFlags & SC_DROP_NAVIGATOR) )
 609     {
 610         //  move: delete source objects
 611
 612         if ( pDragSourceView )
 613             pDragSourceView->DeleteMarked();
 614     }
 615
 616     ScModule* pScMod = SC_MOD();
 617     if ( pScMod->GetDragData().pDrawTransfer == this )
 618         pScMod->ResetDragObject();
 619
 620     DELETEZ( pDragSourceView );
 621
 622     TransferableHelper::DragFinished( nDropAction );
 623 }
 624
 625 void ScDrawTransferObj::SetDrawPersist( const SfxObjectShellRef& rRef )
 626 {
 627     aDrawPersistRef = rRef;
 628 }
 629
 630 static void lcl_InitMarks( SdrMarkView& rDest, const SdrMarkView& rSource, SCTAB nTab )
 631 {
 632     rDest.ShowSdrPage(rDest.GetModel()->GetPage(nTab));
 633     SdrPageView* pDestPV = rDest.GetSdrPageView();
 634     OSL_ENSURE(pDestPV,"PageView ?");
 635
 636     const SdrMarkList& rMarkList = rSource.GetMarkedObjectList();
 637     const size_t nCount = rMarkList.GetMarkCount();
 638     for (size_t i=0; i<nCount; ++i)
 639     {
 640         SdrMark* pMark = rMarkList.GetMark(i);
 641         SdrObject* pObj = pMark->GetMarkedSdrObj();
 642
 643         rDest.MarkObj(pObj, pDestPV);
 644     }
 645 }
 646
 647 void ScDrawTransferObj::SetDragSource( ScDrawView* pView )
 648 {
 649     DELETEZ( pDragSourceView );
 650     pDragSourceView = new SdrView( pView->GetModel() );
 651     lcl_InitMarks( *pDragSourceView, *pView, pView->GetTab() );
 652
 653     //! add as listener with document, delete pDragSourceView if document gone
 654 }
 655
 656 void ScDrawTransferObj::SetDragSourceObj( SdrObject* pObj, SCTAB nTab )
 657 {
 658     DELETEZ( pDragSourceView );
 659     pDragSourceView = new SdrView( pObj->GetModel() );
 660     pDragSourceView->ShowSdrPage(pDragSourceView->GetModel()->GetPage(nTab));
 661     SdrPageView* pPV = pDragSourceView->GetSdrPageView();
 662     pDragSourceView->MarkObj(pObj, pPV);
 663
 664     //! add as listener with document, delete pDragSourceView if document gone
 665 }
 666
 667 void ScDrawTransferObj::SetDragSourceFlags( sal_uInt16 nFlags )
 668 {
 669     nDragSourceFlags = nFlags;
 670 }
 671
 672 void ScDrawTransferObj::SetDragWasInternal()
 673 {
 674     bDragWasInternal = true;
 675 }
 676
 677 OUString ScDrawTransferObj::GetShellID() const
 678 {
 679     return maShellID;
 680 }
 681
 682 SdrOle2Obj* ScDrawTransferObj::GetSingleObject()
 683 {
 684     //  if single OLE object was copied, get its object
 685
 686     SdrPage* pPage = pModel->GetPage(0);
 687     if (pPage)
 688     {
 689         SdrObjListIter aIter( *pPage, IM_FLAT );
 690         SdrObject* pObject = aIter.Next();
 691         if (pObject && pObject->GetObjIdentifier() == OBJ_OLE2)
 692         {
 693             return static_cast<SdrOle2Obj*>(pObject);
 694         }
 695     }
 696
 697     return NULL;
 698 }
 699
 700 void ScDrawTransferObj::CreateOLEData()
 701 {
 702     if (aOleData.GetTransferable().is())
 703         // Already created.
 704         return;
 705
 706     SdrOle2Obj* pObj = GetSingleObject();
 707     if (!pObj || !pObj->GetObjRef().is())
 708         // No OLE object present.
 709         return;
 710
 711     SvEmbedTransferHelper* pEmbedTransfer =
 712         new SvEmbedTransferHelper(
 713             pObj->GetObjRef(), pObj->GetGraphic(), pObj->GetAspect());
 714
 715     pEmbedTransfer->SetParentShellID(maShellID);
 716
 717     aOleData = TransferableDataHelper(pEmbedTransfer);
 718 }
 719
 720 //  initialize aDocShellRef with a live document from the ClipDoc
 721
 722 void ScDrawTransferObj::InitDocShell()
 723 {
 724     if ( !aDocShellRef.Is() )
 725     {
 726         ScDocShell* pDocSh = new ScDocShell;
 727         aDocShellRef = pDocSh;      // ref must be there before InitNew
 728
 729         pDocSh->DoInitNew(NULL);
 730
 731         ScDocument& rDestDoc = pDocSh->GetDocument();
 732         rDestDoc.InitDrawLayer( pDocSh );
 733
 734         SdrModel* pDestModel = rDestDoc.GetDrawLayer();
 735         // #i71538# use complete SdrViews
 736         // SdrExchangeView aDestView( pDestModel );
 737         SdrView aDestView( pDestModel );
 738         aDestView.ShowSdrPage(aDestView.GetModel()->GetPage(0));
 739         aDestView.Paste(
 740             *pModel,
 741             Point(aSrcSize.Width()/2, aSrcSize.Height()/2),
 742             NULL, SdrInsertFlags::NONE, OUString(), OUString());
 743
 744         // put objects to right layer (see ScViewFunc::PasteDataFormat for SotClipboardFormatId::DRAWING)
 745
 746         SdrPage* pPage = pDestModel->GetPage(0);
 747         if (pPage)
 748         {
 749             SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS );
 750             SdrObject* pObject = aIter.Next();
 751             while (pObject)
 752             {
 753                 if ( pObject->ISA(SdrUnoObj) )
 754                     pObject->NbcSetLayer(SC_LAYER_CONTROLS);
 755                 else
 756                     pObject->NbcSetLayer(SC_LAYER_FRONT);
 757                 pObject = aIter.Next();
 758             }
 759         }
 760
 761         Point aTmpPoint;
 762         Rectangle aDestArea( aTmpPoint, aSrcSize );
 763         pDocSh->SetVisArea( aDestArea );
 764
 765         ScViewOptions aViewOpt( rDestDoc.GetViewOptions() );
 766         aViewOpt.SetOption( VOPT_GRID, false );
 767         rDestDoc.SetViewOptions( aViewOpt );
 768
 769         ScViewData aViewData( pDocSh, NULL );
 770         aViewData.SetTabNo( 0 );
 771         aViewData.SetScreen( aDestArea );
 772         aViewData.SetCurX( 0 );
 773         aViewData.SetCurY( 0 );
 774         pDocSh->UpdateOle(&aViewData, true);
 775     }
 776 }
 777
 778 namespace
 779 {
 780     class theScDrawTransferObjUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScDrawTransferObjUnoTunnelId > {};
 781 }
 782
 783 const com::sun::star::uno::Sequence< sal_Int8 >& ScDrawTransferObj::getUnoTunnelId()
 784 {
 785     return theScDrawTransferObjUnoTunnelId::get().getSeq();
 786 }
 787
 788 sal_Int64 SAL_CALL ScDrawTransferObj::getSomething( const com::sun::star::uno::Sequence< sal_Int8 >& rId ) throw( com::sun::star::uno::RuntimeException, std::exception )
 789 {
 790     sal_Int64 nRet;
 791     if( ( rId.getLength() == 16 ) &&
 792         ( 0 == memcmp( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) )
 793     {
 794         nRet = reinterpret_cast< sal_Int64 >( this );
 795     }
 796     else
 797         nRet = TransferableHelper::getSomething(rId);
 798     return nRet;
 799 }
 800
 801 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */