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 <rtl/ustrbuf.hxx>
  24 #include <tools/helpers.hxx>
  25 #include <tools/stream.hxx>
  26 #include <sot/exchange.hxx>
  27 #include <sot/formats.hxx>
  28 #include <vcl/GraphicObject.hxx>
  29 #include <vcl/svapp.hxx>
  30
  31 #include <sfx2/linkmgr.hxx>
  32 #include <svx/dialmgr.hxx>
  33 #include <svx/strings.hrc>
  34 #include <svx/svdhdl.hxx>
  35 #include <svx/svdmodel.hxx>
  36 #include <svx/svdpage.hxx>
  37 #include <svx/svdograf.hxx>
  38 #include <svx/svdogrp.hxx>
  39 #include <svx/xbtmpit.hxx>
  40 #include <svx/xfillit0.hxx>
  41 #include <svx/xflbmtit.hxx>
  42 #include "svdfmtf.hxx"
  43 #include <sdgcoitm.hxx>
  44 #include <svx/sdgcpitm.hxx>
  45 #include <svx/sdggaitm.hxx>
  46 #include <sdginitm.hxx>
  47 #include <svx/sdgluitm.hxx>
  48 #include <svx/sdgmoitm.hxx>
  49 #include <sdgtritm.hxx>
  50 #include <sdr/properties/graphicproperties.hxx>
  51 #include <sdr/contact/viewcontactofgraphic.hxx>
  52 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  53 #include <drawinglayer/processor2d/objectinfoextractor2d.hxx>
  54 #include <drawinglayer/primitive2d/objectinfoprimitive2d.hxx>
  55 #include <memory>
  56
  57 using namespace ::com::sun::star;
  58
  59 class SdrGraphicLink : public sfx2::SvBaseLink
  60 {
  61     SdrGrafObj&         rGrafObj;
  62
  63 public:
  64     explicit            SdrGraphicLink(SdrGrafObj& rObj);
  65
  66     virtual void        Closed() override;
  67
  68     virtual ::sfx2::SvBaseLink::UpdateResult DataChanged(
  69         const OUString& rMimeType, const uno::Any & rValue ) override;
  70
  71     void                Connect() { GetRealObject(); }
  72 };
  73
  74 SdrGraphicLink::SdrGraphicLink(SdrGrafObj& rObj)
  75 : ::sfx2::SvBaseLink( ::SfxLinkUpdateMode::ONCALL, SotClipboardFormatId::SVXB )
  76 , rGrafObj( rObj )
  77 {
  78     SetSynchron( false );
  79 }
  80
  81 ::sfx2::SvBaseLink::UpdateResult SdrGraphicLink::DataChanged(
  82     const OUString& rMimeType, const uno::Any & rValue )
  83 {
  84     SdrModel& rModel(rGrafObj.getSdrModelFromSdrObject());
  85     sfx2::LinkManager* pLinkManager(rModel.GetLinkManager());
  86
  87     if( pLinkManager && rValue.hasValue() )
  88     {
  89         sfx2::LinkManager::GetDisplayNames( this, nullptr, &rGrafObj.aFileName, nullptr, &rGrafObj.aFilterName );
  90
  91         Graphic aGraphic;
  92         if (pLinkManager->GetGraphicFromAny(rMimeType, rValue, aGraphic, nullptr))
  93         {
  94             rGrafObj.ImpSetLinkedGraphic(aGraphic);
  95         }
  96         else if( SotExchange::GetFormatIdFromMimeType( rMimeType ) != sfx2::LinkManager::RegisterStatusInfoId() )
  97         {
  98             // broadcasting, to update slide sorter
  99             rGrafObj.BroadcastObjectChange();
 100         }
 101     }
 102     return SUCCESS;
 103 }
 104
 105 void SdrGraphicLink::Closed()
 106 {
 107     // close connection; set pLink of the object to NULL, as link instance is just about getting destructed.
 108     rGrafObj.ForceSwapIn();
 109     rGrafObj.pGraphicLink=nullptr;
 110     rGrafObj.ReleaseGraphicLink();
 111     SvBaseLink::Closed();
 112 }
 113
 114 std::unique_ptr<sdr::properties::BaseProperties> SdrGrafObj::CreateObjectSpecificProperties()
 115 {
 116     return std::make_unique<sdr::properties::GraphicProperties>(*this);
 117 }
 118
 119
 120 // DrawContact section
 121
 122 std::unique_ptr<sdr::contact::ViewContact> SdrGrafObj::CreateObjectSpecificViewContact()
 123 {
 124     return std::make_unique<sdr::contact::ViewContactOfGraphic>(*this);
 125 }
 126
 127
 128 // check if SVG and if try to get ObjectInfoPrimitive2D and extract info
 129
 130 void SdrGrafObj::onGraphicChanged()
 131 {
 132     if (!mpGraphicObject || !mpGraphicObject->GetGraphic().isAvailable())
 133         return;
 134
 135     auto const & rVectorGraphicDataPtr = mpGraphicObject->GetGraphic().getVectorGraphicData();
 136
 137     if (!rVectorGraphicDataPtr)
 138         return;
 139
 140     // Skip for PDF as it is only a bitmap primitive in a sequence and
 141     // doesn't contain metadata. However getting the primitive sequence
 142     // will also trigger a premature rendering of the PDF.
 143     if (rVectorGraphicDataPtr->getType() == VectorGraphicDataType::Pdf)
 144         return;
 145
 146     const std::deque<uno::Reference<graphic::XPrimitive2D>>& rContainer(rVectorGraphicDataPtr->getPrimitive2DSequence());
 147
 148     if (rContainer.empty())
 149         return;
 150
 151     drawinglayer::geometry::ViewInformation2D aViewInformation2D;
 152     drawinglayer::processor2d::ObjectInfoPrimitiveExtractor2D aProcessor(aViewInformation2D);
 153
 154     aProcessor.process(rContainer);
 155
 156     const drawinglayer::primitive2d::ObjectInfoPrimitive2D* pResult = aProcessor.getResult();
 157
 158     if (!pResult)
 159         return;
 160
 161     OUString aName = pResult->getName();
 162     OUString aTitle = pResult->getTitle();
 163     OUString aDesc = pResult->getDesc();
 164
 165     if(!aName.isEmpty())
 166     {
 167         SetName(aName);
 168     }
 169
 170     if(!aTitle.isEmpty())
 171     {
 172         SetTitle(aTitle);
 173     }
 174
 175     if(!aDesc.isEmpty())
 176     {
 177         SetDescription(aDesc);
 178     }
 179 }
 180
 181 SdrGrafObj::SdrGrafObj(SdrModel& rSdrModel)
 182 :   SdrRectObj(rSdrModel)
 183     ,mpGraphicObject(new GraphicObject)
 184     ,pGraphicLink(nullptr)
 185     ,bMirrored(false)
 186     ,mbIsSignatureLine(false)
 187     ,mbIsSignatureLineShowSignDate(true)
 188     ,mbIsSignatureLineCanAddComment(false)
 189     ,mbSignatureLineIsSigned(false)
 190 {
 191     onGraphicChanged();
 192
 193     // #i118485# Shear allowed and possible now
 194     mbNoShear = false;
 195
 196     mbGrafAnimationAllowed = true;
 197
 198     // #i25616#
 199     mbLineIsOutsideGeometry = true;
 200
 201     // #i25616#
 202     mbSupportTextIndentingOnLineWidthChange = false;
 203 }
 204
 205 SdrGrafObj::SdrGrafObj(SdrModel& rSdrModel, SdrGrafObj const & rSource)
 206 :   SdrRectObj(rSdrModel, rSource)
 207     ,mpGraphicObject(new GraphicObject)
 208     ,pGraphicLink(nullptr)
 209 {
 210     onGraphicChanged();
 211
 212     // #i118485# Shear allowed and possible now
 213     mbNoShear = false;
 214
 215     mbGrafAnimationAllowed = true;
 216
 217     // #i25616#
 218     mbLineIsOutsideGeometry = true;
 219
 220     // #i25616#
 221     mbSupportTextIndentingOnLineWidthChange = false;
 222
 223     aFileName = rSource.aFileName;
 224     bMirrored = rSource.bMirrored;
 225
 226     mbIsSignatureLine = rSource.mbIsSignatureLine;
 227     maSignatureLineId = rSource.maSignatureLineId;
 228     maSignatureLineSuggestedSignerName = rSource.maSignatureLineSuggestedSignerName;
 229     maSignatureLineSuggestedSignerTitle = rSource.maSignatureLineSuggestedSignerTitle;
 230     maSignatureLineSuggestedSignerEmail = rSource.maSignatureLineSuggestedSignerEmail;
 231     maSignatureLineSigningInstructions = rSource.maSignatureLineSigningInstructions;
 232     mbIsSignatureLineShowSignDate = rSource.mbIsSignatureLineShowSignDate;
 233     mbIsSignatureLineCanAddComment = rSource.mbIsSignatureLineCanAddComment;
 234     mbSignatureLineIsSigned = false;
 235     mpSignatureLineUnsignedGraphic = rSource.mpSignatureLineUnsignedGraphic;
 236
 237     if(rSource.mpBarCode)
 238     {
 239         mpBarCode = std::make_unique<drawing::BarCode>(*rSource.mpBarCode);
 240     }
 241     else
 242     {
 243         mpBarCode.reset();
 244     }
 245
 246     if (mbIsSignatureLine && rSource.mpSignatureLineUnsignedGraphic)
 247         mpGraphicObject->SetGraphic(rSource.mpSignatureLineUnsignedGraphic);
 248     else
 249         mpGraphicObject->SetGraphic( rSource.GetGraphic() );
 250
 251     if( rSource.IsLinkedGraphic() )
 252     {
 253         SetGraphicLink( aFileName );
 254     }
 255
 256     ImpSetAttrToGrafInfo();
 257 }
 258
 259 SdrGrafObj::SdrGrafObj(
 260     SdrModel& rSdrModel,
 261     const Graphic& rGraphic,
 262     const tools::Rectangle& rRect)
 263 :   SdrRectObj(rSdrModel, rRect)
 264     ,mpGraphicObject(new GraphicObject(rGraphic))
 265     ,pGraphicLink(nullptr)
 266     ,bMirrored(false)
 267     ,mbIsSignatureLine(false)
 268     ,mbIsSignatureLineShowSignDate(true)
 269     ,mbIsSignatureLineCanAddComment(false)
 270     ,mbSignatureLineIsSigned(false)
 271 {
 272     onGraphicChanged();
 273
 274     // #i118485# Shear allowed and possible now
 275     mbNoShear = false;
 276
 277     mbGrafAnimationAllowed = true;
 278
 279     // #i25616#
 280     mbLineIsOutsideGeometry = true;
 281
 282     // #i25616#
 283     mbSupportTextIndentingOnLineWidthChange = false;
 284 }
 285
 286 SdrGrafObj::SdrGrafObj(
 287     SdrModel& rSdrModel,
 288     const Graphic& rGraphic)
 289 :   SdrRectObj(rSdrModel)
 290     ,mpGraphicObject(new GraphicObject(rGraphic))
 291     ,pGraphicLink(nullptr)
 292     ,bMirrored(false)
 293     ,mbIsSignatureLine(false)
 294     ,mbIsSignatureLineShowSignDate(true)
 295     ,mbIsSignatureLineCanAddComment(false)
 296     ,mbSignatureLineIsSigned(false)
 297 {
 298     onGraphicChanged();
 299
 300     // #i118485# Shear allowed and possible now
 301     mbNoShear = false;
 302
 303     mbGrafAnimationAllowed = true;
 304
 305     // #i25616#
 306     mbLineIsOutsideGeometry = true;
 307
 308     // #i25616#
 309     mbSupportTextIndentingOnLineWidthChange = false;
 310 }
 311
 312 SdrGrafObj::~SdrGrafObj()
 313 {
 314     ImpDeregisterLink();
 315 }
 316
 317 void SdrGrafObj::SetGraphicObject(const GraphicObject& rGraphicObject)
 318 {
 319     mpGraphicObject.reset(new GraphicObject(rGraphicObject));
 320     mpReplacementGraphicObject.reset();
 321     mpGraphicObject->SetUserData();
 322     SetChanged();
 323     BroadcastObjectChange();
 324     onGraphicChanged();
 325 }
 326
 327 const GraphicObject& SdrGrafObj::GetGraphicObject(bool bForceSwapIn) const
 328 {
 329     if (bForceSwapIn)
 330         ForceSwapIn();
 331     return *mpGraphicObject;
 332 }
 333
 334 const GraphicObject* SdrGrafObj::GetReplacementGraphicObject() const
 335 {
 336     if (!mpReplacementGraphicObject && mpGraphicObject)
 337     {
 338         auto const & rVectorGraphicDataPtr = mpGraphicObject->GetGraphic().getVectorGraphicData();
 339
 340         if (rVectorGraphicDataPtr)
 341         {
 342             const_cast< SdrGrafObj* >(this)->mpReplacementGraphicObject.reset(new GraphicObject(rVectorGraphicDataPtr->getReplacement()));
 343         }
 344         else if (mpGraphicObject->GetGraphic().GetType() == GraphicType::GdiMetafile)
 345         {
 346             // Replacement graphic for PDF and metafiles is just the bitmap.
 347             const_cast<SdrGrafObj*>(this)->mpReplacementGraphicObject.reset(new GraphicObject(mpGraphicObject->GetGraphic().GetBitmapEx()));
 348         }
 349     }
 350
 351     return mpReplacementGraphicObject.get();
 352 }
 353
 354 void SdrGrafObj::NbcSetGraphic(const Graphic& rGraphic)
 355 {
 356     mpGraphicObject->SetGraphic(rGraphic);
 357     mpReplacementGraphicObject.reset();
 358     mpGraphicObject->SetUserData();
 359     onGraphicChanged();
 360 }
 361
 362 void SdrGrafObj::SetGraphic( const Graphic& rGraphic )
 363 {
 364     if (!rGraphic.getOriginURL().isEmpty())
 365     {
 366         ImpDeregisterLink();
 367         aFileName = rGraphic.getOriginURL();
 368         aFilterName = "";
 369     }
 370     NbcSetGraphic(rGraphic);
 371     if (!rGraphic.getOriginURL().isEmpty())
 372     {
 373         ImpRegisterLink();
 374         mpGraphicObject->SetUserData();
 375     }
 376     SetChanged();
 377     BroadcastObjectChange();
 378     ForceSwapIn();
 379 }
 380
 381 const Graphic& SdrGrafObj::GetGraphic() const
 382 {
 383     return mpGraphicObject->GetGraphic();
 384 }
 385
 386 Graphic SdrGrafObj::GetTransformedGraphic( SdrGrafObjTransformsAttrs nTransformFlags ) const
 387 {
 388     // Refactored most of the code to GraphicObject, where
 389     // everybody can use e.g. the cropping functionality
 390     MapMode aDestMap(getSdrModelFromSdrObject().GetScaleUnit());
 391     const Size aDestSize( GetLogicRect().GetSize() );
 392     GraphicAttr aActAttr = GetGraphicAttr(nTransformFlags);
 393
 394     // Delegate to moved code in GraphicObject
 395     return GetGraphicObject().GetTransformedGraphic( aDestSize, aDestMap, aActAttr );
 396 }
 397
 398 GraphicType SdrGrafObj::GetGraphicType() const
 399 {
 400     return mpGraphicObject->GetType();
 401 }
 402
 403 GraphicAttr SdrGrafObj::GetGraphicAttr( SdrGrafObjTransformsAttrs nTransformFlags ) const
 404 {
 405     GraphicAttr aActAttr;
 406
 407     GraphicType eType = GetGraphicType();
 408     if( SdrGrafObjTransformsAttrs::NONE != nTransformFlags &&
 409         GraphicType::NONE != eType )
 410     {
 411         const bool      bMirror = bool( nTransformFlags & SdrGrafObjTransformsAttrs::MIRROR );
 412         const bool      bRotate = bool( nTransformFlags & SdrGrafObjTransformsAttrs::ROTATE ) &&
 413             (maGeo.nRotationAngle && maGeo.nRotationAngle != 18000_deg100);
 414
 415         // Need cropping info earlier
 416         const_cast<SdrGrafObj*>(this)->ImpSetAttrToGrafInfo();
 417
 418         // Actually transform the graphic only in this case.
 419         // Cropping always happens, though.
 420         aActAttr = aGrafInfo;
 421
 422         if( bMirror )
 423         {
 424             sal_uInt16      nMirrorCase = ( maGeo.nRotationAngle == 18000_deg100 ) ? ( bMirrored ? 3 : 4 ) : ( bMirrored ? 2 : 1 );
 425             bool bHMirr = nMirrorCase == 2 || nMirrorCase == 4;
 426             bool bVMirr = nMirrorCase == 3 || nMirrorCase == 4;
 427
 428             aActAttr.SetMirrorFlags( ( bHMirr ? BmpMirrorFlags::Horizontal : BmpMirrorFlags::NONE ) | ( bVMirr ? BmpMirrorFlags::Vertical : BmpMirrorFlags::NONE ) );
 429         }
 430
 431         if( bRotate )
 432             aActAttr.SetRotation( to<Degree10>(maGeo.nRotationAngle ) );
 433     }
 434
 435     return aActAttr;
 436 }
 437
 438 bool SdrGrafObj::IsAnimated() const
 439 {
 440     return mpGraphicObject->IsAnimated();
 441 }
 442
 443 bool SdrGrafObj::IsEPS() const
 444 {
 445     return mpGraphicObject->IsEPS();
 446 }
 447
 448 MapMode SdrGrafObj::GetGrafPrefMapMode() const
 449 {
 450     return mpGraphicObject->GetPrefMapMode();
 451 }
 452
 453 Size SdrGrafObj::GetGrafPrefSize() const
 454 {
 455     return mpGraphicObject->GetPrefSize();
 456 }
 457
 458 void SdrGrafObj::SetGrafStreamURL( const OUString& rGraphicStreamURL )
 459 {
 460     if( rGraphicStreamURL.isEmpty() )
 461     {
 462         mpGraphicObject->SetUserData();
 463     }
 464     else if(getSdrModelFromSdrObject().IsSwapGraphics() )
 465     {
 466         mpGraphicObject->SetUserData( rGraphicStreamURL );
 467     }
 468 }
 469
 470 OUString const & SdrGrafObj::GetGrafStreamURL() const
 471 {
 472     return mpGraphicObject->GetUserData();
 473 }
 474
 475 Size SdrGrafObj::getOriginalSize() const
 476 {
 477     Size aSize = GetGrafPrefSize();
 478
 479     if (GetGrafPrefMapMode().GetMapUnit() == MapUnit::MapPixel)
 480         aSize = Application::GetDefaultDevice()->PixelToLogic(aSize, MapMode(getSdrModelFromSdrObject().GetScaleUnit()));
 481     else
 482         aSize = OutputDevice::LogicToLogic(aSize, GetGrafPrefMapMode(), MapMode(getSdrModelFromSdrObject().GetScaleUnit()));
 483
 484     if (aGrafInfo.IsCropped())
 485     {
 486         const tools::Long aCroppedWidth(aSize.getWidth() - aGrafInfo.GetLeftCrop()
 487                                         - aGrafInfo.GetRightCrop());
 488         const tools::Long aCroppedHeight(aSize.getHeight() - aGrafInfo.GetTopCrop()
 489                                          - aGrafInfo.GetBottomCrop());
 490
 491         aSize = Size(aCroppedWidth, aCroppedHeight);
 492     }
 493
 494     return aSize;
 495 }
 496
 497 // TODO Remove
 498 void SdrGrafObj::ForceSwapIn() const
 499 {
 500     if (pGraphicLink && (mpGraphicObject->GetType() == GraphicType::NONE  ||
 501                          mpGraphicObject->GetType() == GraphicType::Default) )
 502     {
 503         pGraphicLink->Update();
 504     }
 505 }
 506
 507 void SdrGrafObj::ImpRegisterLink()
 508 {
 509     sfx2::LinkManager* pLinkManager(getSdrModelFromSdrObject().GetLinkManager());
 510
 511     if( pLinkManager != nullptr && pGraphicLink == nullptr )
 512     {
 513         if (!aFileName.isEmpty())
 514         {
 515             pGraphicLink = new SdrGraphicLink( *this );
 516             pLinkManager->InsertFileLink(
 517                 *pGraphicLink, sfx2::SvBaseLinkObjectType::ClientGraphic, aFileName, (aFilterName.isEmpty() ? nullptr : &aFilterName));
 518             pGraphicLink->Connect();
 519         }
 520     }
 521 }
 522
 523 void SdrGrafObj::ImpDeregisterLink()
 524 {
 525     sfx2::LinkManager* pLinkManager(getSdrModelFromSdrObject().GetLinkManager());
 526
 527     if( pLinkManager != nullptr && pGraphicLink!=nullptr)
 528     {
 529         // When using Remove, the *pGraphicLink is implicitly deleted
 530         pLinkManager->Remove( pGraphicLink );
 531         pGraphicLink=nullptr;
 532     }
 533 }
 534
 535 void SdrGrafObj::SetGraphicLink(const OUString& rFileName)
 536 {
 537     Graphic aGraphic;
 538     aGraphic.setOriginURL(rFileName);
 539     SetGraphic(aGraphic);
 540 }
 541
 542 void SdrGrafObj::ReleaseGraphicLink()
 543 {
 544     ImpDeregisterLink();
 545     aFileName.clear();
 546     aFilterName.clear();
 547
 548     auto aGraphic = mpGraphicObject->GetGraphic();
 549     aGraphic.setOriginURL("");
 550     SetGraphic(aGraphic);
 551 }
 552
 553 bool SdrGrafObj::IsLinkedGraphic() const
 554 {
 555     return !mpGraphicObject->GetGraphic().getOriginURL().isEmpty();
 556 }
 557
 558 void SdrGrafObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
 559 {
 560     bool bNoPresGrf = ( mpGraphicObject->GetType() != GraphicType::NONE ) && !m_bEmptyPresObj;
 561
 562     rInfo.bResizeFreeAllowed = maGeo.nRotationAngle.get() % 9000 == 0 ||
 563                                maGeo.nRotationAngle.get() % 18000 == 0 ||
 564                                maGeo.nRotationAngle.get() % 27000 == 0;
 565
 566     rInfo.bResizePropAllowed = true;
 567     rInfo.bRotateFreeAllowed = bNoPresGrf;
 568     rInfo.bRotate90Allowed = bNoPresGrf;
 569     rInfo.bMirrorFreeAllowed = bNoPresGrf;
 570     rInfo.bMirror45Allowed = bNoPresGrf;
 571     rInfo.bMirror90Allowed = !m_bEmptyPresObj;
 572     rInfo.bTransparenceAllowed = false;
 573
 574     // #i118485# Shear allowed and possible now
 575     rInfo.bShearAllowed = true;
 576
 577     rInfo.bEdgeRadiusAllowed=false;
 578     rInfo.bCanConvToPath = !IsEPS();
 579     rInfo.bCanConvToPathLineToArea = false;
 580     rInfo.bCanConvToPolyLineToArea = false;
 581     rInfo.bCanConvToPoly = !IsEPS();
 582     rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary());
 583 }
 584
 585 SdrObjKind SdrGrafObj::GetObjIdentifier() const
 586 {
 587     return SdrObjKind::Graphic;
 588 }
 589
 590 void SdrGrafObj::ImpSetLinkedGraphic( const Graphic& rGraphic )
 591 {
 592     const bool bIsChanged(getSdrModelFromSdrObject().IsChanged());
 593     NbcSetGraphic( rGraphic );
 594     ActionChanged();
 595     BroadcastObjectChange();
 596     getSdrModelFromSdrObject().SetChanged(bIsChanged);
 597 }
 598
 599 OUString SdrGrafObj::TakeObjNameSingul() const
 600 {
 601     if (!mpGraphicObject)
 602         return OUString();
 603
 604     auto const & rVectorGraphicDataPtr = mpGraphicObject->GetGraphic().getVectorGraphicData();
 605
 606     OUStringBuffer sName;
 607
 608     if (rVectorGraphicDataPtr)
 609     {
 610         switch (rVectorGraphicDataPtr->getType())
 611         {
 612         case VectorGraphicDataType::Svg:
 613         {
 614             sName.append(SvxResId(STR_ObjNameSingulGRAFSVG));
 615             break;
 616         }
 617         case VectorGraphicDataType::Wmf:
 618         {
 619             sName.append(SvxResId(STR_ObjNameSingulGRAFWMF));
 620             break;
 621         }
 622         case VectorGraphicDataType::Emf:
 623         {
 624             sName.append(SvxResId(STR_ObjNameSingulGRAFEMF));
 625             break;
 626         }
 627         case VectorGraphicDataType::Pdf:
 628         {
 629             sName.append(SvxResId(STR_ObjNameSingulGRAFPDF));
 630             break;
 631         }
 632         } //no default, see tdf#137813
 633     }
 634     else
 635     {
 636         switch( mpGraphicObject->GetType() )
 637         {
 638             case GraphicType::Bitmap:
 639             {
 640                 TranslateId pId = ( ( mpGraphicObject->IsTransparent() || GetObjectItem( SDRATTR_GRAFTRANSPARENCE ).GetValue() ) ?
 641                                      ( IsLinkedGraphic() ? STR_ObjNameSingulGRAFBMPTRANSLNK : STR_ObjNameSingulGRAFBMPTRANS ) :
 642                                      ( IsLinkedGraphic() ? STR_ObjNameSingulGRAFBMPLNK : STR_ObjNameSingulGRAFBMP ) );
 643
 644                 sName.append(SvxResId(pId));
 645             }
 646             break;
 647
 648             case GraphicType::GdiMetafile:
 649                 sName.append(SvxResId(IsLinkedGraphic() ? STR_ObjNameSingulGRAFMTFLNK : STR_ObjNameSingulGRAFMTF));
 650             break;
 651
 652             case GraphicType::NONE:
 653                 sName.append(SvxResId(IsLinkedGraphic() ? STR_ObjNameSingulGRAFNONELNK : STR_ObjNameSingulGRAFNONE));
 654             break;
 655
 656             default:
 657                 sName.append(SvxResId(IsLinkedGraphic() ? STR_ObjNameSingulGRAFLNK : STR_ObjNameSingulGRAF));
 658             break;
 659         }
 660     }
 661
 662     const OUString aName(GetName());
 663
 664     if (!aName.isEmpty())
 665     {
 666         sName.append(" '" + aName + "\'" );
 667     }
 668
 669     return sName.makeStringAndClear();
 670 }
 671
 672 OUString SdrGrafObj::TakeObjNamePlural() const
 673 {
 674     if (!mpGraphicObject)
 675         return OUString();
 676
 677     auto const & rVectorGraphicDataPtr = mpGraphicObject->GetGraphic().getVectorGraphicData();
 678
 679     OUStringBuffer sName;
 680
 681     if (rVectorGraphicDataPtr)
 682     {
 683         switch (rVectorGraphicDataPtr->getType())
 684         {
 685         case VectorGraphicDataType::Svg:
 686         {
 687             sName.append(SvxResId(STR_ObjNamePluralGRAFSVG));
 688             break;
 689         }
 690         case VectorGraphicDataType::Wmf:
 691         {
 692             sName.append(SvxResId(STR_ObjNamePluralGRAFWMF));
 693             break;
 694         }
 695         case VectorGraphicDataType::Emf:
 696         {
 697             sName.append(SvxResId(STR_ObjNamePluralGRAFEMF));
 698             break;
 699         }
 700         case VectorGraphicDataType::Pdf:
 701         {
 702             sName.append(SvxResId(STR_ObjNamePluralGRAFPDF));
 703             break;
 704         }
 705         } //no default, see tdf#137813
 706     }
 707     else
 708     {
 709         switch(mpGraphicObject->GetType())
 710         {
 711             case GraphicType::Bitmap:
 712             {
 713                 TranslateId pId = ( ( mpGraphicObject->IsTransparent() || GetObjectItem( SDRATTR_GRAFTRANSPARENCE ).GetValue() ) ?
 714                                      ( IsLinkedGraphic() ? STR_ObjNamePluralGRAFBMPTRANSLNK : STR_ObjNamePluralGRAFBMPTRANS ) :
 715                                      ( IsLinkedGraphic() ? STR_ObjNamePluralGRAFBMPLNK : STR_ObjNamePluralGRAFBMP ) );
 716
 717                 sName.append(SvxResId(pId));
 718             }
 719             break;
 720
 721             case GraphicType::GdiMetafile:
 722                 sName.append(SvxResId(IsLinkedGraphic() ? STR_ObjNamePluralGRAFMTFLNK : STR_ObjNamePluralGRAFMTF));
 723             break;
 724
 725             case GraphicType::NONE:
 726                 sName.append(SvxResId(IsLinkedGraphic() ? STR_ObjNamePluralGRAFNONELNK : STR_ObjNamePluralGRAFNONE));
 727             break;
 728
 729             default:
 730                 sName.append(SvxResId(IsLinkedGraphic() ? STR_ObjNamePluralGRAFLNK : STR_ObjNamePluralGRAF));
 731             break;
 732         }
 733     }
 734
 735     const OUString aName(GetName());
 736
 737     if (!aName.isEmpty())
 738     {
 739         sName.append(" '" + aName + "\'");
 740     }
 741
 742     return sName.makeStringAndClear();
 743 }
 744
 745 rtl::Reference<SdrObject> SdrGrafObj::getFullDragClone() const
 746 {
 747     // call parent
 748     rtl::Reference<SdrObject> pRetval = SdrRectObj::getFullDragClone();
 749
 750     // #i103116# the full drag clone leads to problems
 751     // with linked graphics, so reset the link in this
 752     // temporary interaction object and load graphic
 753     if(pRetval && IsLinkedGraphic())
 754     {
 755         static_cast< SdrGrafObj* >(pRetval.get())->ReleaseGraphicLink();
 756     }
 757
 758     return pRetval;
 759 }
 760
 761 rtl::Reference<SdrObject> SdrGrafObj::CloneSdrObject(SdrModel& rTargetModel) const
 762 {
 763     return new SdrGrafObj(rTargetModel, *this);
 764 }
 765
 766 sal_uInt32 SdrGrafObj::GetHdlCount() const
 767 {
 768     return 8;
 769 }
 770
 771 void SdrGrafObj::AddToHdlList(SdrHdlList& rHdlList) const
 772 {
 773     SdrHdlList tempList(nullptr);
 774     SdrRectObj::AddToHdlList( tempList );
 775     tempList.RemoveHdl(0);
 776     tempList.MoveTo(rHdlList);
 777 }
 778
 779 void SdrGrafObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
 780 {
 781     SdrRectObj::NbcResize( rRef, xFact, yFact );
 782
 783     bool bMirrX = xFact.GetNumerator() < 0;
 784     bool bMirrY = yFact.GetNumerator() < 0;
 785
 786     if( bMirrX != bMirrY )
 787         bMirrored = !bMirrored;
 788 }
 789
 790 void SdrGrafObj::NbcMirror(const Point& rRef1, const Point& rRef2)
 791 {
 792     SdrRectObj::NbcMirror(rRef1,rRef2);
 793     bMirrored = !bMirrored;
 794 }
 795
 796 std::unique_ptr<SdrObjGeoData> SdrGrafObj::NewGeoData() const
 797 {
 798     return std::make_unique<SdrGrafObjGeoData>();
 799 }
 800
 801 void SdrGrafObj::SaveGeoData(SdrObjGeoData& rGeo) const
 802 {
 803     SdrRectObj::SaveGeoData(rGeo);
 804     SdrGrafObjGeoData& rGGeo=static_cast<SdrGrafObjGeoData&>(rGeo);
 805     rGGeo.bMirrored=bMirrored;
 806 }
 807
 808 void SdrGrafObj::RestoreGeoData(const SdrObjGeoData& rGeo)
 809 {
 810     SdrRectObj::RestoreGeoData(rGeo);
 811     const SdrGrafObjGeoData& rGGeo=static_cast<const SdrGrafObjGeoData&>(rGeo);
 812     bMirrored=rGGeo.bMirrored;
 813 }
 814
 815 void SdrGrafObj::handlePageChange(SdrPage* pOldPage, SdrPage* pNewPage)
 816 {
 817     const bool bRemove(pNewPage == nullptr && pOldPage != nullptr);
 818     const bool bInsert(pNewPage != nullptr && pOldPage == nullptr);
 819
 820     if( bRemove )
 821     {
 822         // No SwapIn necessary here, because if something's not loaded, it can't be animated either.
 823         if( mpGraphicObject->IsAnimated())
 824             mpGraphicObject->StopAnimation();
 825
 826         if( pGraphicLink != nullptr )
 827             ImpDeregisterLink();
 828     }
 829
 830     // call parent
 831     SdrRectObj::handlePageChange(pOldPage, pNewPage);
 832
 833     if (!aFileName.isEmpty() && bInsert)
 834     {
 835         ImpRegisterLink();
 836     }
 837 }
 838
 839 void SdrGrafObj::StartAnimation()
 840 {
 841     SetGrafAnimationAllowed(true);
 842 }
 843
 844 bool SdrGrafObj::HasGDIMetaFile() const
 845 {
 846     return( mpGraphicObject->GetType() == GraphicType::GdiMetafile );
 847 }
 848
 849 bool SdrGrafObj::isEmbeddedVectorGraphicData() const
 850 {
 851     return GraphicType::Bitmap == GetGraphicType() && GetGraphic().getVectorGraphicData();
 852 }
 853
 854 GDIMetaFile SdrGrafObj::getMetafileFromEmbeddedVectorGraphicData() const
 855 {
 856     GDIMetaFile aRetval;
 857
 858     if(isEmbeddedVectorGraphicData())
 859     {
 860         ScopedVclPtrInstance< VirtualDevice > pOut;
 861         const tools::Rectangle aBoundRect(GetCurrentBoundRect());
 862         const MapMode aMap(getSdrModelFromSdrObject().GetScaleUnit());
 863
 864         pOut->EnableOutput(false);
 865         pOut->SetMapMode(aMap);
 866         aRetval.Record(pOut);
 867         SingleObjectPainter(*pOut);
 868         aRetval.Stop();
 869         aRetval.WindStart();
 870         aRetval.Move(-aBoundRect.Left(), -aBoundRect.Top());
 871         aRetval.SetPrefMapMode(aMap);
 872         aRetval.SetPrefSize(aBoundRect.GetSize());
 873     }
 874
 875     return aRetval;
 876 }
 877
 878 GDIMetaFile SdrGrafObj::GetMetaFile(GraphicType &rGraphicType) const
 879 {
 880     if (isEmbeddedVectorGraphicData())
 881     {
 882         // Embedded Vector Graphic Data
 883         // There is currently no helper to create SdrObjects from primitives (even if I'm thinking
 884         // about writing one for some time). To get the roundtrip to SdrObjects it is necessary to
 885         // use the old converter path over the MetaFile mechanism. Create Metafile from Svg
 886         // primitives here pretty directly
 887         rGraphicType = GraphicType::GdiMetafile;
 888         return getMetafileFromEmbeddedVectorGraphicData();
 889     }
 890     else if (GraphicType::GdiMetafile == rGraphicType)
 891     {
 892         return GetTransformedGraphic(SdrGrafObjTransformsAttrs::MIRROR).GetGDIMetaFile();
 893     }
 894     return GDIMetaFile();
 895 }
 896
 897 rtl::Reference<SdrObject> SdrGrafObj::DoConvertToPolyObj(bool bBezier, bool bAddText ) const
 898 {
 899     rtl::Reference<SdrObject> pRetval;
 900     GraphicType aGraphicType(GetGraphicType());
 901     GDIMetaFile aMtf(GetMetaFile(aGraphicType));
 902     switch(aGraphicType)
 903     {
 904         case GraphicType::GdiMetafile:
 905         {
 906             // Sort into group and return ONLY those objects that can be created from the MetaFile.
 907             ImpSdrGDIMetaFileImport aFilter(
 908                 getSdrModelFromSdrObject(),
 909                 GetLayer(),
 910                 getRectangle());
 911             rtl::Reference<SdrObjGroup> pGrp = new SdrObjGroup(getSdrModelFromSdrObject());
 912
 913             if(aFilter.DoImport(aMtf, *pGrp->GetSubList(), 0))
 914             {
 915                 {
 916                         // copy transformation
 917                     GeoStat aGeoStat(GetGeoStat());
 918
 919                     if(aGeoStat.nShearAngle)
 920                     {
 921                         aGeoStat.RecalcTan();
 922                         pGrp->NbcShear(getRectangle().TopLeft(), aGeoStat.nShearAngle, aGeoStat.mfTanShearAngle, false);
 923                     }
 924
 925                     if(aGeoStat.nRotationAngle)
 926                     {
 927                         aGeoStat.RecalcSinCos();
 928                         pGrp->NbcRotate(getRectangle().TopLeft(), aGeoStat.nRotationAngle, aGeoStat.mfSinRotationAngle, aGeoStat.mfCosRotationAngle);
 929                     }
 930                 }
 931
 932                 pRetval = pGrp;
 933                 pGrp->NbcSetLayer(GetLayer());
 934
 935                 if(bAddText)
 936                 {
 937                     pRetval = ImpConvertAddText(pRetval, bBezier);
 938                 }
 939
 940                 // convert all children
 941                 if( pRetval )
 942                 {
 943                     pRetval = pRetval->DoConvertToPolyObj(bBezier, bAddText);
 944
 945                     if( pRetval )
 946                     {
 947                         // flatten subgroups. As we call
 948                         // DoConvertToPolyObj() on the resulting group
 949                         // objects, subgroups can exist (e.g. text is
 950                         // a group object for every line).
 951                         SdrObjList* pList = pRetval->GetSubList();
 952                         if( pList )
 953                             pList->FlattenGroups();
 954                     }
 955                 }
 956             }
 957             else
 958                 pGrp.clear();
 959
 960             // #i118485# convert line and fill
 961             rtl::Reference<SdrObject> pLineFill = SdrRectObj::DoConvertToPolyObj(bBezier, false);
 962
 963             if(pLineFill)
 964             {
 965                 if(pRetval)
 966                 {
 967                     pGrp = dynamic_cast< SdrObjGroup* >(pRetval.get());
 968
 969                     if(!pGrp)
 970                     {
 971                         pGrp = new SdrObjGroup(getSdrModelFromSdrObject());
 972                         pGrp->NbcSetLayer(GetLayer());
 973                         pGrp->GetSubList()->NbcInsertObject(pRetval.get());
 974                     }
 975
 976                     pGrp->GetSubList()->NbcInsertObject(pLineFill.get(), 0);
 977                 }
 978                 else
 979                 {
 980                     pRetval = pLineFill;
 981                 }
 982             }
 983
 984             break;
 985         }
 986         case GraphicType::Bitmap:
 987         {
 988             // create basic object and add fill
 989             pRetval = SdrRectObj::DoConvertToPolyObj(bBezier, bAddText);
 990
 991             // save bitmap as an attribute
 992             if(pRetval)
 993             {
 994                 // retrieve bitmap for the fill
 995                 SfxItemSet aSet(GetObjectItemSet());
 996
 997                 aSet.Put(XFillStyleItem(drawing::FillStyle_BITMAP));
 998                 const BitmapEx aBitmapEx(GetTransformedGraphic().GetBitmapEx());
 999                 aSet.Put(XFillBitmapItem(OUString(), Graphic(aBitmapEx)));
1000                 aSet.Put(XFillBmpTileItem(false));
1001
1002                 pRetval->SetMergedItemSet(aSet);
1003             }
1004             break;
1005         }
1006         case GraphicType::NONE:
1007         case GraphicType::Default:
1008         {
1009             pRetval = SdrRectObj::DoConvertToPolyObj(bBezier, bAddText);
1010             break;
1011         }
1012     }
1013
1014     return pRetval;
1015 }
1016
1017 void SdrGrafObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
1018 {
1019     SetXPolyDirty();
1020     SdrRectObj::Notify( rBC, rHint );
1021     ImpSetAttrToGrafInfo();
1022 }
1023
1024
1025 void SdrGrafObj::SetMirrored( bool _bMirrored )
1026 {
1027     bMirrored = _bMirrored;
1028 }
1029
1030 void SdrGrafObj::ImpSetAttrToGrafInfo()
1031 {
1032     const SfxItemSet& rSet = GetObjectItemSet();
1033     const sal_uInt16 nTrans = rSet.Get( SDRATTR_GRAFTRANSPARENCE ).GetValue();
1034     const SdrGrafCropItem&  rCrop = rSet.Get( SDRATTR_GRAFCROP );
1035
1036     aGrafInfo.SetLuminance( rSet.Get( SDRATTR_GRAFLUMINANCE ).GetValue() );
1037     aGrafInfo.SetContrast( rSet.Get( SDRATTR_GRAFCONTRAST ).GetValue() );
1038     aGrafInfo.SetChannelR( rSet.Get( SDRATTR_GRAFRED ).GetValue() );
1039     aGrafInfo.SetChannelG( rSet.Get( SDRATTR_GRAFGREEN ).GetValue() );
1040     aGrafInfo.SetChannelB( rSet.Get( SDRATTR_GRAFBLUE ).GetValue() );
1041     aGrafInfo.SetGamma( rSet.Get( SDRATTR_GRAFGAMMA ).GetValue() * 0.01 );
1042     aGrafInfo.SetAlpha( 255 - static_cast<sal_uInt8>(FRound( std::min( nTrans, sal_uInt16(100) )  * 2.55 )) );
1043     aGrafInfo.SetInvert( rSet.Get( SDRATTR_GRAFINVERT ).GetValue() );
1044     aGrafInfo.SetDrawMode( rSet.Get( SDRATTR_GRAFMODE ).GetValue() );
1045     aGrafInfo.SetCrop( rCrop.GetLeft(), rCrop.GetTop(), rCrop.GetRight(), rCrop.GetBottom() );
1046
1047     SetXPolyDirty();
1048     SetBoundAndSnapRectsDirty();
1049 }
1050
1051 void SdrGrafObj::AdjustToMaxRect( const tools::Rectangle& rMaxRect, bool bShrinkOnly )
1052 {
1053     Size aSize;
1054     Size aMaxSize( rMaxRect.GetSize() );
1055     if (mpGraphicObject->GetPrefMapMode().GetMapUnit() == MapUnit::MapPixel)
1056         aSize = Application::GetDefaultDevice()->PixelToLogic(mpGraphicObject->GetPrefSize(), MapMode(MapUnit::Map100thMM));
1057     else
1058         aSize = OutputDevice::LogicToLogic( mpGraphicObject->GetPrefSize(),
1059                                             mpGraphicObject->GetPrefMapMode(),
1060                                             MapMode( MapUnit::Map100thMM ) );
1061
1062     if( aSize.IsEmpty() )
1063         return;
1064
1065     Point aPos( rMaxRect.TopLeft() );
1066
1067     // if the graphic is too large, fit it to page
1068     if ( (!bShrinkOnly                          ||
1069          ( aSize.Height() > aMaxSize.Height() ) ||
1070          ( aSize.Width()  > aMaxSize.Width()  ) )&&
1071          aSize.Height() && aMaxSize.Height() )
1072     {
1073         float fGrfWH =  static_cast<float>(aSize.Width()) /
1074                         static_cast<float>(aSize.Height());
1075         float fWinWH =  static_cast<float>(aMaxSize.Width()) /
1076                         static_cast<float>(aMaxSize.Height());
1077
1078         // Scale graphic to page size
1079         if ( fGrfWH < fWinWH )
1080         {
1081             aSize.setWidth( static_cast<tools::Long>(aMaxSize.Height() * fGrfWH) );
1082             aSize.setHeight( aMaxSize.Height() );
1083         }
1084         else if ( fGrfWH > 0.F )
1085         {
1086             aSize.setWidth( aMaxSize.Width() );
1087             aSize.setHeight( static_cast<tools::Long>(aMaxSize.Width() / fGrfWH) );
1088         }
1089
1090         aPos = rMaxRect.Center();
1091     }
1092
1093     if( bShrinkOnly )
1094         aPos = getRectangle().TopLeft();
1095
1096     aPos.AdjustX( -(aSize.Width() / 2) );
1097     aPos.AdjustY( -(aSize.Height() / 2) );
1098     SetLogicRect( tools::Rectangle( aPos, aSize ) );
1099 }
1100
1101 void SdrGrafObj::SetGrafAnimationAllowed(bool bNew)
1102 {
1103     if(mbGrafAnimationAllowed != bNew)
1104     {
1105         mbGrafAnimationAllowed = bNew;
1106         ActionChanged();
1107     }
1108 }
1109
1110 uno::Reference<io::XInputStream> SdrGrafObj::getInputStream() const
1111 {
1112     uno::Reference<io::XInputStream> xStream;
1113
1114     if (mpGraphicObject && GetGraphic().IsGfxLink())
1115     {
1116         Graphic aGraphic( GetGraphic() );
1117         GfxLink aLink( aGraphic.GetGfxLink() );
1118         sal_uInt32 nSize = aLink.GetDataSize();
1119         const void* pSourceData = static_cast<const void*>(aLink.GetData());
1120         if( nSize && pSourceData )
1121         {
1122             sal_uInt8 * pBuffer = new sal_uInt8[ nSize ];
1123             memcpy( pBuffer, pSourceData, nSize );
1124
1125             SvMemoryStream* pStream = new SvMemoryStream( static_cast<void*>(pBuffer), static_cast<std::size_t>(nSize), StreamMode::READ );
1126             pStream->ObjectOwnsMemory( true );
1127             xStream.set( new utl::OInputStreamWrapper( pStream, true ) );
1128         }
1129     }
1130
1131     if (!xStream.is() && !aFileName.isEmpty())
1132     {
1133         SvFileStream* pStream = new SvFileStream( aFileName, StreamMode::READ );
1134         xStream.set( new utl::OInputStreamWrapper( pStream ) );
1135     }
1136
1137     return xStream;
1138 }
1139
1140 // moved crop handle creation here; this is the object type using them
1141 void SdrGrafObj::addCropHandles(SdrHdlList& rTarget) const
1142 {
1143     basegfx::B2DHomMatrix aMatrix;
1144     basegfx::B2DPolyPolygon aPolyPolygon;
1145
1146     // get object transformation
1147     TRGetBaseGeometry(aMatrix, aPolyPolygon);
1148
1149     // part of object transformation correction, but used later, so defined outside next scope
1150     double fShearX(0.0), fRotate(0.0);
1151
1152     {   // TTTT correct shear, it comes currently mirrored from TRGetBaseGeometry, can be removed with aw080
1153         basegfx::B2DTuple aScale;
1154         basegfx::B2DTuple aTranslate;
1155
1156         aMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
1157
1158         if(!basegfx::fTools::equalZero(fShearX))
1159         {
1160             // shearX is used, correct it
1161             fShearX = -fShearX;
1162         }
1163
1164         aMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix(
1165             aScale,
1166             fShearX,
1167             fRotate,
1168             aTranslate);
1169     }
1170
1171     // get crop values
1172     const SdrGrafCropItem& rCrop = GetMergedItem(SDRATTR_GRAFCROP);
1173
1174     if(rCrop.GetLeft() || rCrop.GetTop() || rCrop.GetRight() ||rCrop.GetBottom())
1175     {
1176         // decompose object transformation to have current translate and scale
1177         basegfx::B2DVector aScale, aTranslate;
1178         double fLclRotate, fLclShearX;
1179
1180         aMatrix.decompose(aScale, aTranslate, fLclRotate, fLclShearX);
1181
1182         if(!aScale.equalZero())
1183         {
1184             // get crop scale
1185             const basegfx::B2DVector aCropScaleFactor(
1186                 GetGraphicObject().calculateCropScaling(
1187                     aScale.getX(),
1188                     aScale.getY(),
1189                     rCrop.GetLeft(),
1190                     rCrop.GetTop(),
1191                     rCrop.GetRight(),
1192                     rCrop.GetBottom()));
1193
1194             // apply crop scale
1195             const double fCropLeft(rCrop.GetLeft() * aCropScaleFactor.getX());
1196             const double fCropTop(rCrop.GetTop() * aCropScaleFactor.getY());
1197             const double fCropRight(rCrop.GetRight() * aCropScaleFactor.getX());
1198             const double fCropBottom(rCrop.GetBottom() * aCropScaleFactor.getY());
1199             basegfx::B2DHomMatrix aMatrixForCropViewHdl(aMatrix);
1200
1201             if(IsMirrored())
1202             {
1203                 // create corrected new matrix, TTTT can be removed with aw080
1204                 // the old mirror only can mirror horizontally; the vertical mirror
1205                 // is faked by using the horizontal and 180 degree rotation. Since
1206                 // the object can be rotated differently from 180 degree, this is
1207                 // not safe to detect. Just correct horizontal mirror (which is
1208                 // in IsMirrored()) and keep the rotation angle
1209                 // caution: Do not modify aMatrix, it is used below to calculate
1210                 // the exact handle positions
1211                 basegfx::B2DHomMatrix aPreMultiply;
1212
1213                 // mirrored X, apply
1214                 aPreMultiply.translate(-0.5, 0.0);
1215                 aPreMultiply.scale(-1.0, 1.0);
1216                 aPreMultiply.translate(0.5, 0.0);
1217
1218                 aMatrixForCropViewHdl = aMatrixForCropViewHdl * aPreMultiply;
1219             }
1220
1221             rTarget.AddHdl(
1222                 std::make_unique<SdrCropViewHdl>(
1223                     aMatrixForCropViewHdl,
1224                     GetGraphicObject().GetGraphic(),
1225                     fCropLeft,
1226                     fCropTop,
1227                     fCropRight,
1228                     fCropBottom));
1229         }
1230     }
1231
1232     basegfx::B2DPoint aPos;
1233
1234     aPos = aMatrix * basegfx::B2DPoint(0.0, 0.0);
1235     rTarget.AddHdl(std::make_unique<SdrCropHdl>(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::UpperLeft, fShearX, fRotate));
1236     aPos = aMatrix * basegfx::B2DPoint(0.5, 0.0);
1237     rTarget.AddHdl(std::make_unique<SdrCropHdl>(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::Upper, fShearX, fRotate));
1238     aPos = aMatrix * basegfx::B2DPoint(1.0, 0.0);
1239     rTarget.AddHdl(std::make_unique<SdrCropHdl>(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::UpperRight, fShearX, fRotate));
1240     aPos = aMatrix * basegfx::B2DPoint(0.0, 0.5);
1241     rTarget.AddHdl(std::make_unique<SdrCropHdl>(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::Left , fShearX, fRotate));
1242     aPos = aMatrix * basegfx::B2DPoint(1.0, 0.5);
1243     rTarget.AddHdl(std::make_unique<SdrCropHdl>(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::Right, fShearX, fRotate));
1244     aPos = aMatrix * basegfx::B2DPoint(0.0, 1.0);
1245     rTarget.AddHdl(std::make_unique<SdrCropHdl>(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::LowerLeft, fShearX, fRotate));
1246     aPos = aMatrix * basegfx::B2DPoint(0.5, 1.0);
1247     rTarget.AddHdl(std::make_unique<SdrCropHdl>(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::Lower, fShearX, fRotate));
1248     aPos = aMatrix * basegfx::B2DPoint(1.0, 1.0);
1249     rTarget.AddHdl(std::make_unique<SdrCropHdl>(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::LowerRight, fShearX, fRotate));
1250 }
1251
1252 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */