svx/source/svdraw/svdograf.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 <unotools/streamwrap.hxx>
  21
  22 #include <sfx2/lnkbase.hxx>
  23 #include <math.h>
  24 #include <tools/helpers.hxx>
  25 #include <sot/formats.hxx>
  26 #include <sot/storage.hxx>
  27 #include <comphelper/storagehelper.hxx>
  28 #include <unotools/ucbstreamhelper.hxx>
  29 #include <unotools/localfilehelper.hxx>
  30 #include <svl/style.hxx>
  31 #include <vcl/graphicfilter.hxx>
  32 #include <svl/urihelper.hxx>
  33 #include <svtools/grfmgr.hxx>
  34 #include <vcl/svapp.hxx>
  35
  36 #include <sfx2/linkmgr.hxx>
  37 #include <sfx2/docfile.hxx>
  38 #include <svx/svdetc.hxx>
  39 #include "svdglob.hxx"
  40 #include "svx/svdstr.hrc"
  41 #include <svx/svdpool.hxx>
  42 #include <svx/svdmodel.hxx>
  43 #include <svx/svdpage.hxx>
  44 #include <svx/svdmrkv.hxx>
  45 #include <svx/svdpagv.hxx>
  46 #include "svx/svdviter.hxx"
  47 #include <svx/svdview.hxx>
  48 #include <svx/svdograf.hxx>
  49 #include <svx/svdogrp.hxx>
  50 #include <svx/xbtmpit.hxx>
  51 #include <svx/xflbmtit.hxx>
  52 #include <svx/svdundo.hxx>
  53 #include "svdfmtf.hxx"
  54 #include <svx/sdgcpitm.hxx>
  55 #include <editeng/eeitem.hxx>
  56 #include <sdr/properties/graphicproperties.hxx>
  57 #include <sdr/contact/viewcontactofgraphic.hxx>
  58 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  59 #include <basegfx/polygon/b2dpolygon.hxx>
  60 #include <basegfx/polygon/b2dpolygontools.hxx>
  61 #include <osl/thread.hxx>
  62 #include <drawinglayer/processor2d/objectinfoextractor2d.hxx>
  63 #include <drawinglayer/primitive2d/objectinfoprimitive2d.hxx>
  64 #include <boost/scoped_ptr.hpp>
  65
  66 using namespace ::com::sun::star;
  67 using namespace ::com::sun::star::uno;
  68 using namespace ::com::sun::star::io;
  69
  70 const Graphic ImpLoadLinkedGraphic( const OUString& aFileName, const OUString& aReferer, const OUString& aFilterName )
  71 {
  72     Graphic aGraphic;
  73
  74     SfxMedium xMed( aFileName, aReferer, STREAM_STD_READ );
  75     xMed.Download();
  76
  77     SvStream* pInStrm = xMed.GetInStream();
  78     if ( pInStrm )
  79     {
  80         pInStrm->Seek( STREAM_SEEK_TO_BEGIN );
  81         GraphicFilter& rGF = GraphicFilter::GetGraphicFilter();
  82
  83         const sal_uInt16 nFilter = !aFilterName.isEmpty() && rGF.GetImportFormatCount()
  84             ? rGF.GetImportFormatNumber( aFilterName )
  85             : GRFILTER_FORMAT_DONTKNOW;
  86
  87         css::uno::Sequence< css::beans::PropertyValue > aFilterData( 1 );
  88
  89         // TODO: Room for improvement:
  90         // As this is a linked graphic the GfxLink is not needed if saving/loading our own format.
  91         // But this link is required by some filters to access the native graphic (PDF export/MS export),
  92         // there we should create a new service to provide this data if needed
  93         aFilterData[ 0 ].Name = "CreateNativeLink";
  94         aFilterData[ 0 ].Value = Any( sal_True );
  95
  96         // #i123042# for e.g SVG the path is needed, so hand it over here. I have no real idea
  97         // what consequences this may have; maybe this is not handed over by purpose here. Not
  98         // handing it over means that any GraphicFormat that internallv needs a path as base
  99         // to interpret included links may fail.
 100         // Alternatively the path may be set at the result after this call when it is known
 101         // that it is a SVG graphic, but only because no one yet tried to interpret it.
 102         rGF.ImportGraphic( aGraphic, aFileName, *pInStrm, nFilter, NULL, GraphicFilterImportFlags::NONE, &aFilterData );
 103     }
 104     return aGraphic;
 105 }
 106
 107 class SdrGraphicUpdater;
 108 class SdrGraphicLink : public sfx2::SvBaseLink
 109 {
 110     SdrGrafObj&         rGrafObj;
 111     SdrGraphicUpdater*  pGraphicUpdater;
 112
 113 public:
 114                         SdrGraphicLink(SdrGrafObj& rObj);
 115     virtual             ~SdrGraphicLink();
 116
 117     virtual void        Closed() SAL_OVERRIDE;
 118
 119     virtual ::sfx2::SvBaseLink::UpdateResult DataChanged(
 120         const OUString& rMimeType, const ::com::sun::star::uno::Any & rValue ) SAL_OVERRIDE;
 121     void                DataChanged( const Graphic& rGraphic );
 122
 123     bool                Connect() { return 0 != GetRealObject(); }
 124     void                UpdateAsynchron();
 125     void                RemoveGraphicUpdater();
 126
 127     OUString getReferer() const { return rGrafObj.aReferer; }
 128 };
 129
 130 class SdrGraphicUpdater : public ::osl::Thread
 131 {
 132 public:
 133     SdrGraphicUpdater( const OUString& rFileName, const OUString& rFilterName, SdrGraphicLink& );
 134     virtual ~SdrGraphicUpdater();
 135
 136     void SAL_CALL Terminate();
 137
 138     bool GraphicLinkChanged( const OUString& rFileName ){ return maFileName != rFileName;    };
 139
 140 protected:
 141
 142     /** is called from the inherited create method and acts as the
 143         main function of this thread.
 144     */
 145     virtual void SAL_CALL run() SAL_OVERRIDE;
 146
 147     /** Called after the thread is terminated via the terminate
 148         method.  Used to kill the thread by calling delete on this.
 149     */
 150     virtual void SAL_CALL onTerminated() SAL_OVERRIDE;
 151
 152 private:
 153
 154     const OUString  maFileName;
 155     const OUString  maFilterName;
 156     SdrGraphicLink& mrGraphicLink;
 157
 158     volatile bool   mbIsTerminated;
 159 };
 160
 161 SdrGraphicUpdater::SdrGraphicUpdater( const OUString& rFileName, const OUString& rFilterName, SdrGraphicLink& rGraphicLink )
 162 : maFileName( rFileName )
 163 , maFilterName( rFilterName )
 164 , mrGraphicLink( rGraphicLink )
 165 , mbIsTerminated( false )
 166 {
 167     create();
 168 }
 169
 170 SdrGraphicUpdater::~SdrGraphicUpdater()
 171 {
 172 }
 173
 174 void SdrGraphicUpdater::Terminate()
 175 {
 176     mbIsTerminated = true;
 177 }
 178
 179 void SAL_CALL SdrGraphicUpdater::onTerminated()
 180 {
 181     delete this;
 182 }
 183
 184 void SAL_CALL SdrGraphicUpdater::run()
 185 {
 186     osl_setThreadName("SdrGraphicUpdater");
 187
 188     Graphic aGraphic( ImpLoadLinkedGraphic( maFileName, mrGraphicLink.getReferer(), maFilterName ) );
 189     SolarMutexGuard aSolarGuard;
 190     if ( !mbIsTerminated )
 191     {
 192         mrGraphicLink.DataChanged( aGraphic );
 193         mrGraphicLink.RemoveGraphicUpdater();
 194     }
 195 }
 196
 197 SdrGraphicLink::SdrGraphicLink(SdrGrafObj& rObj)
 198 : ::sfx2::SvBaseLink( ::SfxLinkUpdateMode::ONCALL, SotClipboardFormatId::SVXB )
 199 , rGrafObj( rObj )
 200 , pGraphicUpdater( NULL )
 201 {
 202     SetSynchron( false );
 203 }
 204
 205 SdrGraphicLink::~SdrGraphicLink()
 206 {
 207     if ( pGraphicUpdater )
 208         pGraphicUpdater->Terminate();
 209 }
 210
 211 void SdrGraphicLink::DataChanged( const Graphic& rGraphic )
 212 {
 213     rGrafObj.ImpSetLinkedGraphic( rGraphic );
 214 }
 215
 216 void SdrGraphicLink::RemoveGraphicUpdater()
 217 {
 218     pGraphicUpdater = NULL;
 219 }
 220
 221 ::sfx2::SvBaseLink::UpdateResult SdrGraphicLink::DataChanged(
 222     const OUString& rMimeType, const ::com::sun::star::uno::Any & rValue )
 223 {
 224     SdrModel*       pModel      = rGrafObj.GetModel();
 225     sfx2::LinkManager* pLinkManager= pModel  ? pModel->GetLinkManager() : 0;
 226
 227     if( pLinkManager && rValue.hasValue() )
 228     {
 229         sfx2::LinkManager::GetDisplayNames( this, 0, &rGrafObj.aFileName, 0, &rGrafObj.aFilterName );
 230
 231         Graphic aGraphic;
 232         if( sfx2::LinkManager::GetGraphicFromAny( rMimeType, rValue, aGraphic ))
 233         {
 234                rGrafObj.NbcSetGraphic( aGraphic );
 235             rGrafObj.ActionChanged();
 236         }
 237         else if( SotExchange::GetFormatIdFromMimeType( rMimeType ) != sfx2::LinkManager::RegisterStatusInfoId() )
 238         {
 239             // broadcasting, to update slide sorter
 240             rGrafObj.BroadcastObjectChange();
 241         }
 242     }
 243     return SUCCESS;
 244 }
 245
 246 void SdrGraphicLink::Closed()
 247 {
 248     // close connection; set pLink of the object to NULL, as link instance is just about getting destructed.
 249     rGrafObj.ForceSwapIn();
 250     rGrafObj.pGraphicLink=NULL;
 251     rGrafObj.ReleaseGraphicLink();
 252     SvBaseLink::Closed();
 253 }
 254
 255 void SdrGraphicLink::UpdateAsynchron()
 256 {
 257     if( GetObj() )
 258     {
 259         if ( pGraphicUpdater )
 260         {
 261             if ( pGraphicUpdater->GraphicLinkChanged( rGrafObj.GetFileName() ) )
 262             {
 263                 pGraphicUpdater->Terminate();
 264                 pGraphicUpdater = new SdrGraphicUpdater( rGrafObj.GetFileName(), rGrafObj.GetFilterName(), *this );
 265             }
 266         }
 267         else
 268             pGraphicUpdater = new SdrGraphicUpdater( rGrafObj.GetFileName(), rGrafObj.GetFilterName(), *this );
 269     }
 270 }
 271
 272 sdr::properties::BaseProperties* SdrGrafObj::CreateObjectSpecificProperties()
 273 {
 274     return new sdr::properties::GraphicProperties(*this);
 275 }
 276
 277
 278 // DrawContact section
 279
 280 sdr::contact::ViewContact* SdrGrafObj::CreateObjectSpecificViewContact()
 281 {
 282     return new sdr::contact::ViewContactOfGraphic(*this);
 283 }
 284
 285
 286 // check if SVG and if try to get ObjectInfoPrimitive2D and extract info
 287
 288 void SdrGrafObj::onGraphicChanged()
 289 {
 290     if (!pGraphic || pGraphic->IsSwappedOut()) // don't force swap-in for this
 291         return;
 292
 293     const SvgDataPtr& rSvgDataPtr = pGraphic->GetGraphic().getSvgData();
 294
 295     if (!rSvgDataPtr.get())
 296         return;
 297
 298     const drawinglayer::primitive2d::Primitive2DSequence aSequence(rSvgDataPtr->getPrimitive2DSequence());
 299
 300     if (!aSequence.hasElements())
 301         return;
 302
 303     drawinglayer::geometry::ViewInformation2D aViewInformation2D;
 304     drawinglayer::processor2d::ObjectInfoPrimitiveExtractor2D aProcessor(aViewInformation2D);
 305
 306     aProcessor.process(aSequence);
 307
 308     const drawinglayer::primitive2d::ObjectInfoPrimitive2D* pResult = aProcessor.getResult();
 309
 310     if (!pResult)
 311         return;
 312
 313     OUString aName = pResult->getName();
 314     OUString aTitle = pResult->getTitle();
 315     OUString aDesc = pResult->getDesc();
 316
 317     if(!aName.isEmpty())
 318     {
 319         SetName(aName);
 320     }
 321
 322     if(!aTitle.isEmpty())
 323     {
 324         SetTitle(aTitle);
 325     }
 326
 327     if(!aDesc.isEmpty())
 328     {
 329         SetDescription(aDesc);
 330     }
 331 }
 332
 333 TYPEINIT1(SdrGrafObj,SdrRectObj);
 334
 335 SdrGrafObj::SdrGrafObj()
 336 :   SdrRectObj(),
 337     pGraphicLink    ( NULL ),
 338     bMirrored       ( false )
 339 {
 340     pGraphic = new GraphicObject;
 341     mpReplacementGraphic = 0;
 342     pGraphic->SetSwapStreamHdl( LINK(this, SdrGrafObj, ImpSwapHdl) );
 343     onGraphicChanged();
 344
 345     // #i118485# Shear allowed and possible now
 346     bNoShear = false;
 347
 348     mbGrafAnimationAllowed = true;
 349
 350     // #i25616#
 351     mbLineIsOutsideGeometry = true;
 352     mbInsidePaint = false;
 353     mbIsPreview = false;
 354
 355     // #i25616#
 356     mbSupportTextIndentingOnLineWidthChange = false;
 357 }
 358
 359 SdrGrafObj::SdrGrafObj(const Graphic& rGrf, const Rectangle& rRect)
 360 :   SdrRectObj      ( rRect ),
 361     pGraphicLink    ( NULL ),
 362     bMirrored       ( false )
 363 {
 364     pGraphic = new GraphicObject( rGrf );
 365     mpReplacementGraphic = 0;
 366     pGraphic->SetSwapStreamHdl( LINK(this, SdrGrafObj, ImpSwapHdl) );
 367     onGraphicChanged();
 368
 369     // #i118485# Shear allowed and possible now
 370     bNoShear = false;
 371
 372     mbGrafAnimationAllowed = true;
 373
 374     // #i25616#
 375     mbLineIsOutsideGeometry = true;
 376     mbInsidePaint = false;
 377     mbIsPreview = false;
 378
 379     // #i25616#
 380     mbSupportTextIndentingOnLineWidthChange = false;
 381 }
 382
 383 SdrGrafObj::SdrGrafObj( const Graphic& rGrf )
 384 :   SdrRectObj(),
 385     pGraphicLink    ( NULL ),
 386     bMirrored       ( false )
 387 {
 388     pGraphic = new GraphicObject( rGrf );
 389     mpReplacementGraphic = 0;
 390     pGraphic->SetSwapStreamHdl( LINK(this, SdrGrafObj, ImpSwapHdl) );
 391     onGraphicChanged();
 392
 393     // #i118485# Shear allowed and possible now
 394     bNoShear = false;
 395
 396     mbGrafAnimationAllowed = true;
 397
 398     // #i25616#
 399     mbLineIsOutsideGeometry = true;
 400     mbInsidePaint = false;
 401     mbIsPreview = false;
 402
 403     // #i25616#
 404     mbSupportTextIndentingOnLineWidthChange = false;
 405 }
 406
 407 SdrGrafObj::~SdrGrafObj()
 408 {
 409     delete pGraphic;
 410     delete mpReplacementGraphic;
 411     ImpLinkAbmeldung();
 412 }
 413
 414 void SdrGrafObj::SetGraphicObject( const GraphicObject& rGrfObj )
 415 {
 416     *pGraphic = rGrfObj;
 417     delete mpReplacementGraphic;
 418     mpReplacementGraphic = 0;
 419     pGraphic->SetSwapStreamHdl( LINK(this, SdrGrafObj, ImpSwapHdl) );
 420     pGraphic->SetUserData();
 421     mbIsPreview = false;
 422     SetChanged();
 423     BroadcastObjectChange();
 424     onGraphicChanged();
 425 }
 426
 427 const GraphicObject& SdrGrafObj::GetGraphicObject(bool bForceSwapIn) const
 428 {
 429     if(bForceSwapIn)
 430     {
 431         ForceSwapIn();
 432     }
 433
 434     return *pGraphic;
 435 }
 436
 437 const GraphicObject* SdrGrafObj::GetReplacementGraphicObject() const
 438 {
 439     if(!mpReplacementGraphic && pGraphic)
 440     {
 441         const SvgDataPtr& rSvgDataPtr = pGraphic->GetGraphic().getSvgData();
 442
 443         if(rSvgDataPtr.get())
 444         {
 445             const_cast< SdrGrafObj* >(this)->mpReplacementGraphic = new GraphicObject(rSvgDataPtr->getReplacement());
 446         }
 447     }
 448
 449     return mpReplacementGraphic;
 450 }
 451
 452 void SdrGrafObj::NbcSetGraphic( const Graphic& rGrf )
 453 {
 454     pGraphic->SetGraphic( rGrf );
 455     delete mpReplacementGraphic;
 456     mpReplacementGraphic = 0;
 457     pGraphic->SetUserData();
 458     mbIsPreview = false;
 459     onGraphicChanged();
 460 }
 461
 462 void SdrGrafObj::SetGraphic( const Graphic& rGrf )
 463 {
 464     NbcSetGraphic(rGrf);
 465     SetChanged();
 466     BroadcastObjectChange();
 467 }
 468
 469 const Graphic& SdrGrafObj::GetGraphic() const
 470 {
 471     ForceSwapIn();
 472     return pGraphic->GetGraphic();
 473 }
 474
 475 Graphic SdrGrafObj::GetTransformedGraphic( SdrGrafObjTransformsAttrs nTransformFlags ) const
 476 {
 477     // Refactored most of the code to GraphicObject, where
 478     // everybody can use e.g. the cropping functionality
 479
 480     GraphicType     eType = GetGraphicType();
 481     MapMode         aDestMap( pModel->GetScaleUnit(), Point(), pModel->GetScaleFraction(), pModel->GetScaleFraction() );
 482     const Size      aDestSize( GetLogicRect().GetSize() );
 483     const bool      bMirror = bool( nTransformFlags & SdrGrafObjTransformsAttrs::MIRROR );
 484     const bool      bRotate = bool( nTransformFlags & SdrGrafObjTransformsAttrs::ROTATE ) &&
 485         ( aGeo.nRotationAngle && aGeo.nRotationAngle != 18000 ) && ( GRAPHIC_NONE != eType );
 486
 487     // Need cropping info earlier
 488     const_cast<SdrGrafObj*>(this)->ImpSetAttrToGrafInfo();
 489     GraphicAttr aActAttr;
 490
 491     if( SdrGrafObjTransformsAttrs::NONE != nTransformFlags &&
 492         GRAPHIC_NONE != eType )
 493     {
 494         // Actually transform the graphic only in this case.
 495         // Cropping always happens, though.
 496         aActAttr = aGrafInfo;
 497
 498         if( bMirror )
 499         {
 500             sal_uInt16      nMirrorCase = ( aGeo.nRotationAngle == 18000 ) ? ( bMirrored ? 3 : 4 ) : ( bMirrored ? 2 : 1 );
 501             bool bHMirr = nMirrorCase == 2 || nMirrorCase == 4;
 502             bool bVMirr = nMirrorCase == 3 || nMirrorCase == 4;
 503
 504             aActAttr.SetMirrorFlags( ( bHMirr ? BmpMirrorFlags::Horizontal : BmpMirrorFlags::NONE ) | ( bVMirr ? BmpMirrorFlags::Vertical : BmpMirrorFlags::NONE ) );
 505         }
 506
 507         if( bRotate )
 508             aActAttr.SetRotation( sal_uInt16(aGeo.nRotationAngle / 10) );
 509     }
 510
 511     // Delegate to moved code in GraphicObject
 512     return GetGraphicObject().GetTransformedGraphic( aDestSize, aDestMap, aActAttr );
 513 }
 514
 515 GraphicType SdrGrafObj::GetGraphicType() const
 516 {
 517     return pGraphic->GetType();
 518 }
 519
 520 bool SdrGrafObj::IsAnimated() const
 521 {
 522     return pGraphic->IsAnimated();
 523 }
 524
 525 bool SdrGrafObj::IsEPS() const
 526 {
 527     return pGraphic->IsEPS();
 528 }
 529
 530 bool SdrGrafObj::IsSwappedOut() const
 531 {
 532     return mbIsPreview || pGraphic->IsSwappedOut();
 533 }
 534
 535 const MapMode& SdrGrafObj::GetGrafPrefMapMode() const
 536 {
 537     return pGraphic->GetPrefMapMode();
 538 }
 539
 540 const Size& SdrGrafObj::GetGrafPrefSize() const
 541 {
 542     return pGraphic->GetPrefSize();
 543 }
 544
 545 void SdrGrafObj::SetGrafStreamURL( const OUString& rGraphicStreamURL )
 546 {
 547     mbIsPreview = false;
 548     if( rGraphicStreamURL.isEmpty() )
 549     {
 550         pGraphic->SetUserData();
 551     }
 552     else if( pModel->IsSwapGraphics() )
 553     {
 554         pGraphic->SetUserData( rGraphicStreamURL );
 555     }
 556 }
 557
 558 OUString SdrGrafObj::GetGrafStreamURL() const
 559 {
 560     return pGraphic->GetUserData();
 561 }
 562
 563 void SdrGrafObj::ForceSwapIn() const
 564 {
 565     if( mbIsPreview && pGraphic->HasUserData() )
 566     {
 567         // removing preview graphic
 568         const OUString aUserData( pGraphic->GetUserData() );
 569
 570         Graphic aEmpty;
 571         pGraphic->SetGraphic( aEmpty );
 572         pGraphic->SetUserData( aUserData );
 573
 574         const_cast< SdrGrafObj* >( this )->mbIsPreview = false;
 575     }
 576     if ( pGraphicLink && pGraphic->IsSwappedOut() )
 577         ImpUpdateGraphicLink( false );
 578     else
 579         pGraphic->FireSwapInRequest();
 580
 581     if( pGraphic->IsSwappedOut() ||
 582         ( pGraphic->GetType() == GRAPHIC_NONE ) ||
 583         ( pGraphic->GetType() == GRAPHIC_DEFAULT ) )
 584     {
 585         Graphic aDefaultGraphic;
 586         aDefaultGraphic.SetDefaultType();
 587         pGraphic->SetGraphic( aDefaultGraphic );
 588     }
 589 }
 590
 591 void SdrGrafObj::ImpLinkAnmeldung()
 592 {
 593     sfx2::LinkManager* pLinkManager = pModel != NULL ? pModel->GetLinkManager() : NULL;
 594
 595     if( pLinkManager != NULL && pGraphicLink == NULL )
 596     {
 597         if (!aFileName.isEmpty())
 598         {
 599             pGraphicLink = new SdrGraphicLink( *this );
 600             pLinkManager->InsertFileLink(
 601                 *pGraphicLink, OBJECT_CLIENT_GRF, aFileName, (aFilterName.isEmpty() ? NULL : &aFilterName), NULL);
 602             pGraphicLink->Connect();
 603         }
 604     }
 605 }
 606
 607 void SdrGrafObj::ImpLinkAbmeldung()
 608 {
 609     sfx2::LinkManager* pLinkManager = pModel != NULL ? pModel->GetLinkManager() : NULL;
 610
 611     if( pLinkManager != NULL && pGraphicLink!=NULL)
 612     {
 613         // When using Remove, the *pGraphicLink is implicitly deleted
 614         pLinkManager->Remove( pGraphicLink );
 615         pGraphicLink=NULL;
 616     }
 617 }
 618
 619 void SdrGrafObj::SetGraphicLink(const OUString& rFileName, const OUString& rReferer, const OUString& rFilterName)
 620 {
 621     ImpLinkAbmeldung();
 622     aFileName = rFileName;
 623     aReferer = rReferer;
 624     aFilterName = rFilterName;
 625     ImpLinkAnmeldung();
 626     pGraphic->SetUserData();
 627     pGraphic->SetSwapState();
 628 }
 629
 630 void SdrGrafObj::ReleaseGraphicLink()
 631 {
 632     ImpLinkAbmeldung();
 633     aFileName.clear();
 634     aReferer.clear();
 635     aFilterName.clear();
 636 }
 637
 638 bool SdrGrafObj::IsLinkedGraphic() const
 639 {
 640     return !aFileName.isEmpty();
 641 }
 642
 643
 644
 645 void SdrGrafObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
 646 {
 647     bool bNoPresGrf = ( pGraphic->GetType() != GRAPHIC_NONE ) && !bEmptyPresObj;
 648
 649     rInfo.bResizeFreeAllowed = aGeo.nRotationAngle % 9000 == 0 ||
 650                                aGeo.nRotationAngle % 18000 == 0 ||
 651                                aGeo.nRotationAngle % 27000 == 0;
 652
 653     rInfo.bResizePropAllowed = true;
 654     rInfo.bRotateFreeAllowed = bNoPresGrf;
 655     rInfo.bRotate90Allowed = bNoPresGrf;
 656     rInfo.bMirrorFreeAllowed = bNoPresGrf;
 657     rInfo.bMirror45Allowed = bNoPresGrf;
 658     rInfo.bMirror90Allowed = !bEmptyPresObj;
 659     rInfo.bTransparenceAllowed = false;
 660     rInfo.bGradientAllowed = false;
 661
 662     // #i118485# Shear allowed and possible now
 663     rInfo.bShearAllowed = true;
 664
 665     rInfo.bEdgeRadiusAllowed=false;
 666     rInfo.bCanConvToPath = !IsEPS();
 667     rInfo.bCanConvToPathLineToArea = false;
 668     rInfo.bCanConvToPolyLineToArea = false;
 669     rInfo.bCanConvToPoly = !IsEPS();
 670     rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary());
 671 }
 672
 673 sal_uInt16 SdrGrafObj::GetObjIdentifier() const
 674 {
 675     return sal_uInt16( OBJ_GRAF );
 676 }
 677
 678 /* The graphic of the GraphicLink will be loaded. If it is called with
 679    bAsynchron = true then the graphic will be set later via DataChanged
 680 */
 681 bool SdrGrafObj::ImpUpdateGraphicLink( bool bAsynchron ) const
 682 {
 683     bool bRet = false;
 684     if( pGraphicLink )
 685     {
 686         if ( bAsynchron )
 687             pGraphicLink->UpdateAsynchron();
 688         else
 689             pGraphicLink->DataChanged( ImpLoadLinkedGraphic( aFileName, aReferer, aFilterName ) );
 690         bRet = true;
 691     }
 692     return bRet;
 693 }
 694
 695 void SdrGrafObj::ImpSetLinkedGraphic( const Graphic& rGraphic )
 696 {
 697     const bool bIsChanged = GetModel()->IsChanged();
 698     NbcSetGraphic( rGraphic );
 699     ActionChanged();
 700     BroadcastObjectChange();
 701     GetModel()->SetChanged( bIsChanged );
 702 }
 703
 704 OUString SdrGrafObj::TakeObjNameSingul() const
 705 {
 706     if (!pGraphic)
 707         return OUString();
 708
 709     const SvgDataPtr& rSvgDataPtr = pGraphic->GetGraphic().getSvgData();
 710
 711     OUStringBuffer sName;
 712
 713     if(rSvgDataPtr.get())
 714     {
 715         sName.append(ImpGetResStr(STR_ObjNameSingulGRAFSVG));
 716     }
 717     else
 718     {
 719         switch( pGraphic->GetType() )
 720         {
 721             case GRAPHIC_BITMAP:
 722             {
 723                 const sal_uInt16 nId = ( ( pGraphic->IsTransparent() || static_cast<const SdrGrafTransparenceItem&>( GetObjectItem( SDRATTR_GRAFTRANSPARENCE ) ).GetValue() ) ?
 724                                      ( IsLinkedGraphic() ? STR_ObjNameSingulGRAFBMPTRANSLNK : STR_ObjNameSingulGRAFBMPTRANS ) :
 725                                      ( IsLinkedGraphic() ? STR_ObjNameSingulGRAFBMPLNK : STR_ObjNameSingulGRAFBMP ) );
 726
 727                 sName.append(ImpGetResStr(nId));
 728             }
 729             break;
 730
 731             case GRAPHIC_GDIMETAFILE:
 732                 sName.append(ImpGetResStr(IsLinkedGraphic() ? STR_ObjNameSingulGRAFMTFLNK : STR_ObjNameSingulGRAFMTF));
 733             break;
 734
 735             case GRAPHIC_NONE:
 736                 sName.append(ImpGetResStr(IsLinkedGraphic() ? STR_ObjNameSingulGRAFNONELNK : STR_ObjNameSingulGRAFNONE));
 737             break;
 738
 739             default:
 740                 sName.append(ImpGetResStr(IsLinkedGraphic() ? STR_ObjNameSingulGRAFLNK : STR_ObjNameSingulGRAF));
 741             break;
 742         }
 743     }
 744
 745     const OUString aName(GetName());
 746
 747     if (!aName.isEmpty())
 748     {
 749         sName.append(" '");
 750         sName.append(aName);
 751         sName.append('\'' );
 752     }
 753
 754     return sName.makeStringAndClear();
 755 }
 756
 757 OUString SdrGrafObj::TakeObjNamePlural() const
 758 {
 759     if(!pGraphic)
 760         return OUString();
 761
 762     const SvgDataPtr& rSvgDataPtr = pGraphic->GetGraphic().getSvgData();
 763
 764     OUStringBuffer sName;
 765
 766     if(rSvgDataPtr.get())
 767     {
 768         sName.append(ImpGetResStr(STR_ObjNamePluralGRAFSVG));
 769     }
 770     else
 771     {
 772         switch( pGraphic->GetType() )
 773         {
 774             case GRAPHIC_BITMAP:
 775             {
 776                 const sal_uInt16 nId = ( ( pGraphic->IsTransparent() || static_cast<const SdrGrafTransparenceItem&>( GetObjectItem( SDRATTR_GRAFTRANSPARENCE ) ).GetValue() ) ?
 777                                      ( IsLinkedGraphic() ? STR_ObjNamePluralGRAFBMPTRANSLNK : STR_ObjNamePluralGRAFBMPTRANS ) :
 778                                      ( IsLinkedGraphic() ? STR_ObjNamePluralGRAFBMPLNK : STR_ObjNamePluralGRAFBMP ) );
 779
 780                 sName.append(ImpGetResStr(nId));
 781             }
 782             break;
 783
 784             case GRAPHIC_GDIMETAFILE:
 785                 sName.append(ImpGetResStr(IsLinkedGraphic() ? STR_ObjNamePluralGRAFMTFLNK : STR_ObjNamePluralGRAFMTF));
 786             break;
 787
 788             case GRAPHIC_NONE:
 789                 sName.append(ImpGetResStr(IsLinkedGraphic() ? STR_ObjNamePluralGRAFNONELNK : STR_ObjNamePluralGRAFNONE));
 790             break;
 791
 792             default:
 793                 sName.append(ImpGetResStr(IsLinkedGraphic() ? STR_ObjNamePluralGRAFLNK : STR_ObjNamePluralGRAF));
 794             break;
 795         }
 796     }
 797
 798     const OUString aName(GetName());
 799
 800     if (!aName.isEmpty())
 801     {
 802         sName.append(" '");
 803         sName.append(aName);
 804         sName.append('\'');
 805     }
 806
 807     return sName.makeStringAndClear();
 808 }
 809
 810 SdrObject* SdrGrafObj::getFullDragClone() const
 811 {
 812     // call parent
 813     SdrGrafObj* pRetval = static_cast< SdrGrafObj* >(SdrRectObj::getFullDragClone());
 814
 815     // #i103116# the full drag clone leads to problems
 816     // with linked graphics, so reset the link in this
 817     // temporary interaction object and load graphic
 818     if(pRetval && IsLinkedGraphic())
 819     {
 820         pRetval->ForceSwapIn();
 821         pRetval->ReleaseGraphicLink();
 822     }
 823
 824     return pRetval;
 825 }
 826
 827 SdrGrafObj* SdrGrafObj::Clone() const
 828 {
 829     return CloneHelper< SdrGrafObj >();
 830 }
 831
 832 SdrGrafObj& SdrGrafObj::operator=( const SdrGrafObj& rObj )
 833 {
 834     if( this == &rObj )
 835         return *this;
 836     SdrRectObj::operator=( rObj );
 837
 838     pGraphic->SetGraphic( rObj.GetGraphic(), &rObj.GetGraphicObject() );
 839     aFileName = rObj.aFileName;
 840     aFilterName = rObj.aFilterName;
 841     bMirrored = rObj.bMirrored;
 842
 843     if( rObj.IsLinkedGraphic() )
 844     {
 845         SetGraphicLink( aFileName, rObj.aReferer, aFilterName );
 846     }
 847
 848     ImpSetAttrToGrafInfo();
 849     return *this;
 850 }
 851
 852 basegfx::B2DPolyPolygon SdrGrafObj::TakeXorPoly() const
 853 {
 854     if(mbInsidePaint)
 855     {
 856         basegfx::B2DPolyPolygon aRetval;
 857
 858         // take grown rectangle
 859         const sal_Int32 nHalfLineWidth(ImpGetLineWdt() / 2);
 860         const Rectangle aGrownRect(
 861             maRect.Left() - nHalfLineWidth,
 862             maRect.Top() - nHalfLineWidth,
 863             maRect.Right() + nHalfLineWidth,
 864             maRect.Bottom() + nHalfLineWidth);
 865
 866         XPolygon aXPoly(ImpCalcXPoly(aGrownRect, GetEckenradius()));
 867         aRetval.append(aXPoly.getB2DPolygon());
 868
 869         return aRetval;
 870     }
 871     else
 872     {
 873         // call parent
 874         return SdrRectObj::TakeXorPoly();
 875     }
 876 }
 877
 878 sal_uInt32 SdrGrafObj::GetHdlCount() const
 879 {
 880     return 8L;
 881 }
 882
 883 SdrHdl* SdrGrafObj::GetHdl(sal_uInt32 nHdlNum) const
 884 {
 885     return SdrRectObj::GetHdl( nHdlNum + 1L );
 886 }
 887
 888 void SdrGrafObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
 889 {
 890     SdrRectObj::NbcResize( rRef, xFact, yFact );
 891
 892     bool bMirrX = xFact.GetNumerator() < 0;
 893     bool bMirrY = yFact.GetNumerator() < 0;
 894
 895     if( bMirrX != bMirrY )
 896         bMirrored = !bMirrored;
 897 }
 898
 899 void SdrGrafObj::NbcRotate(const Point& rRef, long nAngle, double sn, double cs)
 900 {
 901     SdrRectObj::NbcRotate(rRef,nAngle,sn,cs);
 902 }
 903
 904 void SdrGrafObj::NbcMirror(const Point& rRef1, const Point& rRef2)
 905 {
 906     SdrRectObj::NbcMirror(rRef1,rRef2);
 907     bMirrored = !bMirrored;
 908 }
 909
 910 void SdrGrafObj::NbcShear(const Point& rRef, long nAngle, double tn, bool bVShear)
 911 {
 912     // #i118485# Call Shear now, old version redirected to rotate
 913     SdrRectObj::NbcShear(rRef, nAngle, tn, bVShear);
 914 }
 915
 916 void SdrGrafObj::NbcSetSnapRect(const Rectangle& rRect)
 917 {
 918     SdrRectObj::NbcSetSnapRect(rRect);
 919 }
 920
 921 void SdrGrafObj::NbcSetLogicRect( const Rectangle& rRect)
 922 {
 923     SdrRectObj::NbcSetLogicRect(rRect);
 924 }
 925
 926 SdrObjGeoData* SdrGrafObj::NewGeoData() const
 927 {
 928     return new SdrGrafObjGeoData;
 929 }
 930
 931 void SdrGrafObj::SaveGeoData(SdrObjGeoData& rGeo) const
 932 {
 933     SdrRectObj::SaveGeoData(rGeo);
 934     SdrGrafObjGeoData& rGGeo=static_cast<SdrGrafObjGeoData&>(rGeo);
 935     rGGeo.bMirrored=bMirrored;
 936 }
 937
 938 void SdrGrafObj::RestGeoData(const SdrObjGeoData& rGeo)
 939 {
 940     SdrRectObj::RestGeoData(rGeo);
 941     const SdrGrafObjGeoData& rGGeo=static_cast<const SdrGrafObjGeoData&>(rGeo);
 942     bMirrored=rGGeo.bMirrored;
 943 }
 944
 945 void SdrGrafObj::SetPage( SdrPage* pNewPage )
 946 {
 947     bool bRemove = pNewPage == NULL && pPage != NULL;
 948     bool bInsert = pNewPage != NULL && pPage == NULL;
 949
 950     if( bRemove )
 951     {
 952         // No SwapIn necessary here, because if something's not loaded, it can't be animated either.
 953         if( pGraphic->IsAnimated())
 954             pGraphic->StopAnimation();
 955
 956         if( pGraphicLink != NULL )
 957             ImpLinkAbmeldung();
 958     }
 959
 960     if(!pModel && !GetStyleSheet() && pNewPage && pNewPage->GetModel())
 961     {
 962         // #i119287# Set default StyleSheet for SdrGrafObj here, it is different from 'Default'. This
 963         // needs to be done before the style 'Default' is set from the :SetModel() call which is triggered
 964         // from the following :SetPage().
 965         // TTTT: Needs to be moved in branch aw080 due to having a SdrModel from the beginning, is at this
 966         // place for convenience currently (works in both versions, is not in the way)
 967         SfxStyleSheet* pSheet = pNewPage->GetModel()->GetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj();
 968
 969         if(pSheet)
 970         {
 971             SetStyleSheet(pSheet, false);
 972         }
 973         else
 974         {
 975             SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
 976             SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
 977         }
 978     }
 979
 980     SdrRectObj::SetPage( pNewPage );
 981
 982     if (!aFileName.isEmpty() && bInsert)
 983         ImpLinkAnmeldung();
 984 }
 985
 986 void SdrGrafObj::SetModel( SdrModel* pNewModel )
 987 {
 988     bool bChg = pNewModel != pModel;
 989
 990     if( bChg )
 991     {
 992         if( pGraphic->HasUserData() )
 993         {
 994             ForceSwapIn();
 995         }
 996
 997         if( pGraphicLink != NULL )
 998             ImpLinkAbmeldung();
 999     }
1000
1001     // realize model
1002     SdrRectObj::SetModel(pNewModel);
1003
1004     if (bChg && !aFileName.isEmpty())
1005         ImpLinkAnmeldung();
1006 }
1007
1008 void SdrGrafObj::StartAnimation( OutputDevice* /*pOutDev*/, const Point& /*rPoint*/, const Size& /*rSize*/, long /*nExtraData*/)
1009 {
1010     SetGrafAnimationAllowed(true);
1011 }
1012
1013 bool SdrGrafObj::HasGDIMetaFile() const
1014 {
1015     return( pGraphic->GetType() == GRAPHIC_GDIMETAFILE );
1016 }
1017
1018 bool SdrGrafObj::isEmbeddedSvg() const
1019 {
1020     return GRAPHIC_BITMAP == GetGraphicType() && GetGraphic().getSvgData().get();
1021 }
1022
1023 GDIMetaFile SdrGrafObj::getMetafileFromEmbeddedSvg() const
1024 {
1025     GDIMetaFile aRetval;
1026
1027     if(isEmbeddedSvg() && GetModel())
1028     {
1029         ScopedVclPtrInstance< VirtualDevice > pOut;
1030         const Rectangle aBoundRect(GetCurrentBoundRect());
1031         const MapMode aMap(GetModel()->GetScaleUnit(), Point(), GetModel()->GetScaleFraction(), GetModel()->GetScaleFraction());
1032
1033         pOut->EnableOutput(false);
1034         pOut->SetMapMode(aMap);
1035         aRetval.Record(pOut);
1036         SingleObjectPainter(*pOut.get());
1037         aRetval.Stop();
1038         aRetval.WindStart();
1039         aRetval.Move(-aBoundRect.Left(), -aBoundRect.Top());
1040         aRetval.SetPrefMapMode(aMap);
1041         aRetval.SetPrefSize(aBoundRect.GetSize());
1042     }
1043
1044     return aRetval;
1045 }
1046
1047 SdrObject* SdrGrafObj::DoConvertToPolyObj(bool bBezier, bool bAddText ) const
1048 {
1049     SdrObject* pRetval = NULL;
1050     GraphicType aGraphicType(GetGraphicType());
1051     GDIMetaFile aMtf;
1052
1053     if(isEmbeddedSvg())
1054     {
1055         // Embedded Svg
1056         // There is currently no helper to create SdrObjects from primitives (even if I'm thinking
1057         // about writing one for some time). To get the roundtrip to SdrObjects it is necessary to
1058         // use the old converter path over the MetaFile mechanism. Create Metafile from Svg
1059         // primitives here pretty directly
1060         aMtf = getMetafileFromEmbeddedSvg();
1061         aGraphicType = GRAPHIC_GDIMETAFILE;
1062     }
1063     else if(GRAPHIC_GDIMETAFILE == aGraphicType)
1064     {
1065         aMtf = GetTransformedGraphic(SdrGrafObjTransformsAttrs::COLOR|SdrGrafObjTransformsAttrs::MIRROR).GetGDIMetaFile();
1066     }
1067
1068     switch(aGraphicType)
1069     {
1070         case GRAPHIC_GDIMETAFILE:
1071         {
1072             // Sort into group and return ONLY those objects that can be created from the MetaFile.
1073             ImpSdrGDIMetaFileImport aFilter(*GetModel(), GetLayer(), maRect);
1074             SdrObjGroup* pGrp = new SdrObjGroup();
1075
1076             if(aFilter.DoImport(aMtf, *pGrp->GetSubList(), 0))
1077             {
1078                 {
1079                         // copy transformation
1080                     GeoStat aGeoStat(GetGeoStat());
1081
1082                     if(aGeoStat.nShearAngle)
1083                     {
1084                         aGeoStat.RecalcTan();
1085                         pGrp->NbcShear(maRect.TopLeft(), aGeoStat.nShearAngle, aGeoStat.nTan, false);
1086                     }
1087
1088                     if(aGeoStat.nRotationAngle)
1089                     {
1090                         aGeoStat.RecalcSinCos();
1091                         pGrp->NbcRotate(maRect.TopLeft(), aGeoStat.nRotationAngle, aGeoStat.nSin, aGeoStat.nCos);
1092                     }
1093                 }
1094
1095                 pRetval = pGrp;
1096                 pGrp->NbcSetLayer(GetLayer());
1097                 pGrp->SetModel(GetModel());
1098
1099                 if(bAddText)
1100                 {
1101                     pRetval = ImpConvertAddText(pRetval, bBezier);
1102                 }
1103
1104                 // convert all children
1105                 if( pRetval )
1106                 {
1107                     SdrObject* pHalfDone = pRetval;
1108                     pRetval = pHalfDone->DoConvertToPolyObj(bBezier, bAddText);
1109                     SdrObject::Free( pHalfDone ); // resulting object is newly created
1110
1111                     if( pRetval )
1112                     {
1113                         // flatten subgroups. As we call
1114                         // DoConvertToPolyObj() on the resulting group
1115                         // objects, subgroups can exist (e.g. text is
1116                         // a group object for every line).
1117                         SdrObjList* pList = pRetval->GetSubList();
1118                         if( pList )
1119                             pList->FlattenGroups();
1120                     }
1121                 }
1122             }
1123             else
1124             {
1125                 delete pGrp;
1126             }
1127
1128             // #i118485# convert line and fill
1129             SdrObject* pLineFill = SdrRectObj::DoConvertToPolyObj(bBezier, false);
1130
1131             if(pLineFill)
1132             {
1133                 if(pRetval)
1134                 {
1135                     pGrp = dynamic_cast< SdrObjGroup* >(pRetval);
1136
1137                     if(!pGrp)
1138                     {
1139                         pGrp = new SdrObjGroup();
1140
1141                         pGrp->NbcSetLayer(GetLayer());
1142                         pGrp->SetModel(GetModel());
1143                         pGrp->GetSubList()->NbcInsertObject(pRetval);
1144                     }
1145
1146                     pGrp->GetSubList()->NbcInsertObject(pLineFill, 0);
1147                 }
1148                 else
1149                 {
1150                     pRetval = pLineFill;
1151                 }
1152             }
1153
1154             break;
1155         }
1156         case GRAPHIC_BITMAP:
1157         {
1158             // create basic object and add fill
1159             pRetval = SdrRectObj::DoConvertToPolyObj(bBezier, bAddText);
1160
1161             // save bitmap as an attribute
1162             if(pRetval)
1163             {
1164                 // retrieve bitmap for the fill
1165                 SfxItemSet aSet(GetObjectItemSet());
1166
1167                 aSet.Put(XFillStyleItem(drawing::FillStyle_BITMAP));
1168                 const BitmapEx aBitmapEx(GetTransformedGraphic().GetBitmapEx());
1169                 aSet.Put(XFillBitmapItem(OUString(), Graphic(aBitmapEx)));
1170                 aSet.Put(XFillBmpTileItem(false));
1171
1172                 pRetval->SetMergedItemSet(aSet);
1173             }
1174             break;
1175         }
1176         case GRAPHIC_NONE:
1177         case GRAPHIC_DEFAULT:
1178         {
1179             pRetval = SdrRectObj::DoConvertToPolyObj(bBezier, bAddText);
1180             break;
1181         }
1182     }
1183
1184     return pRetval;
1185 }
1186
1187 void SdrGrafObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
1188 {
1189     SetXPolyDirty();
1190     SdrRectObj::Notify( rBC, rHint );
1191     ImpSetAttrToGrafInfo();
1192 }
1193
1194
1195 void SdrGrafObj::SetMirrored( bool _bMirrored )
1196 {
1197     bMirrored = _bMirrored;
1198 }
1199
1200 void SdrGrafObj::ImpSetAttrToGrafInfo()
1201 {
1202     const SfxItemSet& rSet = GetObjectItemSet();
1203     const sal_uInt16 nTrans = static_cast<const SdrGrafTransparenceItem&>( rSet.Get( SDRATTR_GRAFTRANSPARENCE ) ).GetValue();
1204     const SdrGrafCropItem&  rCrop = static_cast<const SdrGrafCropItem&>( rSet.Get( SDRATTR_GRAFCROP ) );
1205
1206     aGrafInfo.SetLuminance( static_cast<const SdrGrafLuminanceItem&>( rSet.Get( SDRATTR_GRAFLUMINANCE ) ).GetValue() );
1207     aGrafInfo.SetContrast( static_cast<const SdrGrafContrastItem&>( rSet.Get( SDRATTR_GRAFCONTRAST ) ).GetValue() );
1208     aGrafInfo.SetChannelR( static_cast<const SdrGrafRedItem&>( rSet.Get( SDRATTR_GRAFRED ) ).GetValue() );
1209     aGrafInfo.SetChannelG( static_cast<const SdrGrafGreenItem&>( rSet.Get( SDRATTR_GRAFGREEN ) ).GetValue() );
1210     aGrafInfo.SetChannelB( static_cast<const SdrGrafBlueItem&>( rSet.Get( SDRATTR_GRAFBLUE ) ).GetValue() );
1211     aGrafInfo.SetGamma( static_cast<const SdrGrafGamma100Item&>( rSet.Get( SDRATTR_GRAFGAMMA ) ).GetValue() * 0.01 );
1212     aGrafInfo.SetTransparency( (sal_uInt8) FRound( std::min( nTrans, (sal_uInt16) 100 )  * 2.55 ) );
1213     aGrafInfo.SetInvert( static_cast<const SdrGrafInvertItem&>( rSet.Get( SDRATTR_GRAFINVERT ) ).GetValue() );
1214     aGrafInfo.SetDrawMode( static_cast<const SdrGrafModeItem&>( rSet.Get( SDRATTR_GRAFMODE ) ).GetValue() );
1215     aGrafInfo.SetCrop( rCrop.GetLeft(), rCrop.GetTop(), rCrop.GetRight(), rCrop.GetBottom() );
1216
1217     SetXPolyDirty();
1218     SetRectsDirty();
1219 }
1220
1221 void SdrGrafObj::AdjustToMaxRect( const Rectangle& rMaxRect, bool bShrinkOnly )
1222 {
1223     Size aSize;
1224     Size aMaxSize( rMaxRect.GetSize() );
1225     if ( pGraphic->GetPrefMapMode().GetMapUnit() == MAP_PIXEL )
1226         aSize = Application::GetDefaultDevice()->PixelToLogic( pGraphic->GetPrefSize(), MAP_100TH_MM );
1227     else
1228         aSize = OutputDevice::LogicToLogic( pGraphic->GetPrefSize(),
1229                                             pGraphic->GetPrefMapMode(),
1230                                             MapMode( MAP_100TH_MM ) );
1231
1232     if( aSize.Height() != 0 && aSize.Width() != 0 )
1233     {
1234         Point aPos( rMaxRect.TopLeft() );
1235
1236         // if the graphic is too large, fit it to page
1237         if ( (!bShrinkOnly                          ||
1238              ( aSize.Height() > aMaxSize.Height() ) ||
1239              ( aSize.Width()  > aMaxSize.Width()  ) )&&
1240              aSize.Height() && aMaxSize.Height() )
1241         {
1242             float fGrfWH =  (float)aSize.Width() /
1243                             (float)aSize.Height();
1244             float fWinWH =  (float)aMaxSize.Width() /
1245                             (float)aMaxSize.Height();
1246
1247             // Scale graphic to page size
1248             if ( fGrfWH < fWinWH )
1249             {
1250                 aSize.Width() = (long)(aMaxSize.Height() * fGrfWH);
1251                 aSize.Height()= aMaxSize.Height();
1252             }
1253             else if ( fGrfWH > 0.F )
1254             {
1255                 aSize.Width() = aMaxSize.Width();
1256                 aSize.Height()= (long)(aMaxSize.Width() / fGrfWH);
1257             }
1258
1259             aPos = rMaxRect.Center();
1260         }
1261
1262         if( bShrinkOnly )
1263             aPos = maRect.TopLeft();
1264
1265         aPos.X() -= aSize.Width() / 2;
1266         aPos.Y() -= aSize.Height() / 2;
1267         SetLogicRect( Rectangle( aPos, aSize ) );
1268     }
1269 }
1270
1271 IMPL_LINK( SdrGrafObj, ImpSwapHdl, GraphicObject*, pO )
1272 {
1273     SvStream* pRet = GRFMGR_AUTOSWAPSTREAM_NONE;
1274
1275     if( pO->IsInSwapOut() )
1276     {
1277         if( pModel && !mbIsPreview && pModel->IsSwapGraphics() && pGraphic->GetSizeBytes() > 20480 )
1278         {
1279             // test if this object is visualized from someone
1280             // ## test only if there are VOCs other than the preview renderer
1281             if(!GetViewContact().HasViewObjectContacts(true))
1282             {
1283                 const SdrSwapGraphicsMode nSwapMode = pModel->GetSwapGraphicsMode();
1284
1285                 if( ( pGraphicLink ) &&
1286                     ( nSwapMode & SdrSwapGraphicsMode::PURGE ) )
1287                 {
1288                     pRet = GRFMGR_AUTOSWAPSTREAM_LINK;
1289                 }
1290                 else if( nSwapMode & SdrSwapGraphicsMode::TEMP )
1291                 {
1292                     pRet = GRFMGR_AUTOSWAPSTREAM_TEMP;
1293                     pGraphic->SetUserData();
1294                 }
1295
1296                 // #i102380#
1297                 sdr::contact::ViewContactOfGraphic* pVC = dynamic_cast< sdr::contact::ViewContactOfGraphic* >(&GetViewContact());
1298
1299                 if(pVC)
1300                 {
1301                     pVC->flushGraphicObjects();
1302                 }
1303             }
1304         }
1305     }
1306     else if( pO->IsInSwapIn() )
1307     {
1308         // can be loaded from the original document stream later
1309         if( pModel != NULL )
1310         {
1311             if( pGraphic->HasUserData() )
1312             {
1313                 ::comphelper::LifecycleProxy proxy;
1314                 OUString aUserData = pGraphic->GetUserData();
1315                 uno::Reference<io::XInputStream> const xStream(
1316                     pModel->GetDocumentStream(aUserData, proxy));
1317
1318                 ::boost::scoped_ptr<SvStream> const pStream( (xStream.is())
1319                         ? ::utl::UcbStreamHelper::CreateStream(xStream)
1320                         : 0 );
1321
1322                 if( pStream != 0 )
1323                 {
1324                     Graphic aGraphic;
1325
1326                     boost::scoped_ptr<com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue > > pFilterData;
1327
1328                     if(mbInsidePaint && !GetViewContact().HasViewObjectContacts(true))
1329                     {
1330                         pFilterData.reset(new com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue >( 3 ));
1331
1332                         const com::sun::star::awt::Size aPreviewSizeHint( 64, 64 );
1333                         const bool bAllowPartialStreamRead = true;
1334                         // create <GfxLink> instance also for previews in order to avoid that its corresponding
1335                         // data is cleared in the graphic cache entry in case that the preview data equals the complete graphic data
1336                         const bool bCreateNativeLink = true;
1337                         (*pFilterData)[ 0 ].Name = "PreviewSizeHint";
1338                         (*pFilterData)[ 0 ].Value <<= aPreviewSizeHint;
1339                         (*pFilterData)[ 1 ].Name = "AllowPartialStreamRead";
1340                         (*pFilterData)[ 1 ].Value <<= bAllowPartialStreamRead;
1341                         (*pFilterData)[ 2 ].Name = "CreateNativeLink";
1342                         (*pFilterData)[ 2 ].Value <<= bCreateNativeLink;
1343
1344                         mbIsPreview = true;
1345                     }
1346
1347                     if(!GraphicFilter::GetGraphicFilter().ImportGraphic(
1348                         aGraphic, aUserData, *pStream,
1349                         GRFILTER_FORMAT_DONTKNOW, NULL, GraphicFilterImportFlags::NONE, pFilterData.get()))
1350                     {
1351                         const OUString aNewUserData( pGraphic->GetUserData() );
1352                         pGraphic->SetGraphic( aGraphic );
1353                         if( mbIsPreview )
1354                         {
1355                             pGraphic->SetUserData(aNewUserData);
1356                         }
1357                         else
1358                         {
1359                             pGraphic->SetUserData();
1360                         }
1361
1362                         // Graphic successfully swapped in.
1363                         pRet = GRFMGR_AUTOSWAPSTREAM_LOADED;
1364                     }
1365                     pFilterData.reset();
1366
1367                     pStream->ResetError();
1368                 }
1369             }
1370             else if( !ImpUpdateGraphicLink( false ) )
1371             {
1372                 pRet = GRFMGR_AUTOSWAPSTREAM_TEMP;
1373             }
1374             else
1375             {
1376                 pRet = GRFMGR_AUTOSWAPSTREAM_LOADED;
1377             }
1378         }
1379         else
1380             pRet = GRFMGR_AUTOSWAPSTREAM_TEMP;
1381     }
1382
1383     return reinterpret_cast<sal_IntPtr>(pRet);
1384 }
1385
1386 void SdrGrafObj::SetGrafAnimationAllowed(bool bNew)
1387 {
1388     if(mbGrafAnimationAllowed != bNew)
1389     {
1390         mbGrafAnimationAllowed = bNew;
1391         ActionChanged();
1392     }
1393 }
1394
1395 Reference< XInputStream > SdrGrafObj::getInputStream()
1396 {
1397     Reference< XInputStream > xStream;
1398
1399     if( pModel )
1400     {
1401         if( pGraphic && GetGraphic().IsLink() )
1402         {
1403             Graphic aGraphic( GetGraphic() );
1404             GfxLink aLink( aGraphic.GetLink() );
1405             sal_uInt32 nSize = aLink.GetDataSize();
1406             const void* pSourceData = (const void*)aLink.GetData();
1407             if( nSize && pSourceData )
1408             {
1409                 sal_uInt8 * pBuffer = new sal_uInt8[ nSize ];
1410                 memcpy( pBuffer, pSourceData, nSize );
1411
1412                 SvMemoryStream* pStream = new SvMemoryStream( (void*)pBuffer, (sal_Size)nSize, StreamMode::READ );
1413                 pStream->ObjectOwnsMemory( true );
1414                 xStream.set( new utl::OInputStreamWrapper( pStream, true ) );
1415             }
1416         }
1417
1418         if (!xStream.is() && !aFileName.isEmpty())
1419         {
1420             SvFileStream* pStream = new SvFileStream( aFileName, StreamMode::READ );
1421             xStream.set( new utl::OInputStreamWrapper( pStream ) );
1422         }
1423     }
1424
1425     return xStream;
1426 }
1427
1428 // moved crop handle creation here; this is the object type using them
1429 void SdrGrafObj::addCropHandles(SdrHdlList& rTarget) const
1430 {
1431     basegfx::B2DHomMatrix aMatrix;
1432     basegfx::B2DPolyPolygon aPolyPolygon;
1433
1434     // get object transformation
1435     TRGetBaseGeometry(aMatrix, aPolyPolygon);
1436
1437     // part of object transformation correction, but used later, so defined outside next scope
1438     double fShearX(0.0), fRotate(0.0);
1439
1440     {   // TTTT correct shear, it comes currently mirrored from TRGetBaseGeometry, can be removed with aw080
1441         basegfx::B2DTuple aScale;
1442         basegfx::B2DTuple aTranslate;
1443
1444         aMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
1445
1446         if(!basegfx::fTools::equalZero(fShearX))
1447         {
1448             // shearX is used, correct it
1449             fShearX = -fShearX;
1450         }
1451
1452         aMatrix = basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
1453             aScale,
1454             fShearX,
1455             fRotate,
1456             aTranslate);
1457     }
1458
1459     // get crop values
1460     const SdrGrafCropItem& rCrop = static_cast< const SdrGrafCropItem& >(GetMergedItem(SDRATTR_GRAFCROP));
1461
1462     if(rCrop.GetLeft() || rCrop.GetTop() || rCrop.GetRight() ||rCrop.GetBottom())
1463     {
1464         // decompose object transformation to have current translate and scale
1465         basegfx::B2DVector aScale, aTranslate;
1466         double fLclRotate, fLclShearX;
1467
1468         aMatrix.decompose(aScale, aTranslate, fLclRotate, fLclShearX);
1469
1470         if(!aScale.equalZero())
1471         {
1472             // get crop scale
1473             const basegfx::B2DVector aCropScaleFactor(
1474                 GetGraphicObject().calculateCropScaling(
1475                     aScale.getX(),
1476                     aScale.getY(),
1477                     rCrop.GetLeft(),
1478                     rCrop.GetTop(),
1479                     rCrop.GetRight(),
1480                     rCrop.GetBottom()));
1481
1482             // apply crop scale
1483             const double fCropLeft(rCrop.GetLeft() * aCropScaleFactor.getX());
1484             const double fCropTop(rCrop.GetTop() * aCropScaleFactor.getY());
1485             const double fCropRight(rCrop.GetRight() * aCropScaleFactor.getX());
1486             const double fCropBottom(rCrop.GetBottom() * aCropScaleFactor.getY());
1487             basegfx::B2DHomMatrix aMatrixForCropViewHdl(aMatrix);
1488
1489             if(IsMirrored())
1490             {
1491                 // create corrected new matrix, TTTT can be removed with aw080
1492                 // the old mirror only can mirror horizontally; the vertical mirror
1493                 // is faked by using the horizontal and 180 degree rotation. Since
1494                 // the object can be rotated differently from 180 degree, this is
1495                 // not safe to detect. Just correct horizontal mirror (which is
1496                 // in IsMirrored()) and keep the rotation angle
1497                 // caution: Do not modify aMatrix, it is used below to calculate
1498                 // the exact handle positions
1499                 basegfx::B2DHomMatrix aPreMultiply;
1500
1501                 // mirrored X, apply
1502                 aPreMultiply.translate(-0.5, 0.0);
1503                 aPreMultiply.scale(-1.0, 1.0);
1504                 aPreMultiply.translate(0.5, 0.0);
1505
1506                 aMatrixForCropViewHdl = aMatrixForCropViewHdl * aPreMultiply;
1507             }
1508
1509             rTarget.AddHdl(
1510                 new SdrCropViewHdl(
1511                     aMatrixForCropViewHdl,
1512                     GetGraphicObject().GetGraphic(),
1513                     fCropLeft,
1514                     fCropTop,
1515                     fCropRight,
1516                     fCropBottom));
1517         }
1518     }
1519
1520     basegfx::B2DPoint aPos;
1521
1522     aPos = aMatrix * basegfx::B2DPoint(0.0, 0.0);
1523     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_UPLFT, fShearX, fRotate));
1524     aPos = aMatrix * basegfx::B2DPoint(0.5, 0.0);
1525     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_UPPER, fShearX, fRotate));
1526     aPos = aMatrix * basegfx::B2DPoint(1.0, 0.0);
1527     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_UPRGT, fShearX, fRotate));
1528     aPos = aMatrix * basegfx::B2DPoint(0.0, 0.5);
1529     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_LEFT , fShearX, fRotate));
1530     aPos = aMatrix * basegfx::B2DPoint(1.0, 0.5);
1531     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_RIGHT, fShearX, fRotate));
1532     aPos = aMatrix * basegfx::B2DPoint(0.0, 1.0);
1533     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_LWLFT, fShearX, fRotate));
1534     aPos = aMatrix * basegfx::B2DPoint(0.5, 1.0);
1535     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_LOWER, fShearX, fRotate));
1536     aPos = aMatrix * basegfx::B2DPoint(1.0, 1.0);
1537     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_LWRGT, fShearX, fRotate));
1538 }
1539
1540 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */