svx/source/svdraw/svdocapt.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 <sal/config.h>
  21
  22 #include <cassert>
  23
  24 #include <basegfx/matrix/b2dhommatrix.hxx>
  25 #include <basegfx/polygon/b2dpolygon.hxx>
  26 #include <basegfx/polygon/b2dpolygontools.hxx>
  27 #include <basegfx/range/b2drange.hxx>
  28 #include <basegfx/tuple/b2dtuple.hxx>
  29 #include <tools/bigint.hxx>
  30 #include <tools/helpers.hxx>
  31 #include <rtl/ustrbuf.hxx>
  32
  33 #include <svx/dialmgr.hxx>
  34 #include <svx/strings.hrc>
  35
  36 #include <sdr/contact/viewcontactofsdrcaptionobj.hxx>
  37 #include <sdr/properties/captionproperties.hxx>
  38 #include <svx/sdrhittesthelper.hxx>
  39 #include <svx/sdooitm.hxx>
  40 #include <svx/svddrag.hxx>
  41 #include <svx/svdhdl.hxx>
  42 #include <svx/svdmodel.hxx>
  43 #include <svx/svdocapt.hxx>
  44 #include <svx/svdopath.hxx>
  45 #include <svx/svdogrp.hxx>
  46 #include <svx/svdpage.hxx>
  47 #include <svx/svdtrans.hxx>
  48 #include <svx/svdview.hxx>
  49 #include <svx/sxcecitm.hxx>
  50 #include <svx/sxcgitm.hxx>
  51 #include <svx/sxcllitm.hxx>
  52 #include <svx/sxctitm.hxx>
  53 #include <vcl/canvastools.hxx>
  54 #include <vcl/ptrstyle.hxx>
  55
  56 namespace {
  57
  58 enum EscDir {LKS,RTS,OBN,UNT};
  59
  60 }
  61
  62 class ImpCaptParams
  63 {
  64 public:
  65     SdrCaptionType              eType;
  66     tools::Long                        nGap;
  67     tools::Long                        nEscRel;
  68     tools::Long                        nEscAbs;
  69     tools::Long                        nLineLen;
  70     SdrCaptionEscDir            eEscDir;
  71     bool                        bFitLineLen;
  72     bool                        bEscRel;
  73     bool                        bFixedAngle;
  74
  75 public:
  76     ImpCaptParams()
  77       : eType(SdrCaptionType::Type3),
  78         nGap(0), nEscRel(5000), nEscAbs(0),
  79         nLineLen(0), eEscDir(SdrCaptionEscDir::Horizontal),
  80         bFitLineLen(true), bEscRel(true), bFixedAngle(false)
  81     {
  82     }
  83     void CalcEscPos(const Point& rTail, const tools::Rectangle& rRect, Point& rPt, EscDir& rDir) const;
  84 };
  85
  86 void ImpCaptParams::CalcEscPos(const Point& rTailPt, const tools::Rectangle& rRect, Point& rPt, EscDir& rDir) const
  87 {
  88     Point aTl(rTailPt); // copy locally for performance reasons
  89     tools::Long nX,nY;
  90     if (bEscRel) {
  91         nX=rRect.Right()-rRect.Left();
  92         nX=BigMulDiv(nX,nEscRel,10000);
  93         nY=rRect.Bottom()-rRect.Top();
  94         nY=BigMulDiv(nY,nEscRel,10000);
  95     } else {
  96         nX=nEscAbs;
  97         nY=nEscAbs;
  98     }
  99     nX+=rRect.Left();
 100     nY+=rRect.Top();
 101     Point  aBestPt;
 102     EscDir eBestDir=LKS;
 103     bool bTryH=eEscDir==SdrCaptionEscDir::BestFit;
 104     if (!bTryH) {
 105         if (eType!=SdrCaptionType::Type1) {
 106             bTryH=eEscDir==SdrCaptionEscDir::Horizontal;
 107         } else {
 108             bTryH=eEscDir==SdrCaptionEscDir::Vertical;
 109         }
 110     }
 111     bool bTryV=eEscDir==SdrCaptionEscDir::BestFit;
 112     if (!bTryV) {
 113         if (eType!=SdrCaptionType::Type1) {
 114             bTryV=eEscDir==SdrCaptionEscDir::Vertical;
 115         } else {
 116             bTryV=eEscDir==SdrCaptionEscDir::Horizontal;
 117         }
 118     }
 119
 120     if (bTryH) {
 121         Point aLft(rRect.Left()-nGap,nY);
 122         Point aRgt(rRect.Right()+nGap,nY);
 123         bool bLft=(aTl.X()-aLft.X()<aRgt.X()-aTl.X());
 124         if (bLft) {
 125             eBestDir=LKS;
 126             aBestPt=aLft;
 127         } else {
 128             eBestDir=RTS;
 129             aBestPt=aRgt;
 130         }
 131     }
 132     if (bTryV) {
 133         Point aTop(nX,rRect.Top()-nGap);
 134         Point aBtm(nX,rRect.Bottom()+nGap);
 135         bool bTop=(aTl.Y()-aTop.Y()<aBtm.Y()-aTl.Y());
 136         Point aBest2;
 137         EscDir eBest2;
 138         if (bTop) {
 139             eBest2=OBN;
 140             aBest2=aTop;
 141         } else {
 142             eBest2=UNT;
 143             aBest2=aBtm;
 144         }
 145         bool bTakeIt=eEscDir!=SdrCaptionEscDir::BestFit;
 146         if (!bTakeIt) {
 147             BigInt aHorX(aBestPt.X()-aTl.X()); aHorX*=aHorX;
 148             BigInt aHorY(aBestPt.Y()-aTl.Y()); aHorY*=aHorY;
 149             BigInt aVerX(aBest2.X()-aTl.X());  aVerX*=aVerX;
 150             BigInt aVerY(aBest2.Y()-aTl.Y());  aVerY*=aVerY;
 151             if (eType!=SdrCaptionType::Type1) {
 152                 bTakeIt=aVerX+aVerY<aHorX+aHorY;
 153             } else {
 154                 bTakeIt=aVerX+aVerY>=aHorX+aHorY;
 155             }
 156         }
 157         if (bTakeIt) {
 158             aBestPt=aBest2;
 159             eBestDir=eBest2;
 160         }
 161     }
 162     rPt=aBestPt;
 163     rDir=eBestDir;
 164 }
 165
 166
 167 // BaseProperties section
 168
 169 std::unique_ptr<sdr::properties::BaseProperties> SdrCaptionObj::CreateObjectSpecificProperties()
 170 {
 171     return std::make_unique<sdr::properties::CaptionProperties>(*this);
 172 }
 173
 174
 175 // DrawContact section
 176
 177 std::unique_ptr<sdr::contact::ViewContact> SdrCaptionObj::CreateObjectSpecificViewContact()
 178 {
 179     return std::make_unique<sdr::contact::ViewContactOfSdrCaptionObj>(*this);
 180 }
 181
 182
 183 SdrCaptionObj::SdrCaptionObj(SdrModel& rSdrModel)
 184 :   SdrRectObj(rSdrModel, OBJ_TEXT),
 185     aTailPoly(3),  // default size: 3 points = 2 lines
 186     mbSpecialTextBoxShadow(false),
 187     mbFixedTail(false),
 188     mbSuppressGetBitmap(false),
 189     maFixedTailPos()
 190 {
 191 }
 192
 193 SdrCaptionObj::SdrCaptionObj(
 194     SdrModel& rSdrModel,
 195     const tools::Rectangle& rRect,
 196     const Point& rTail)
 197 :   SdrRectObj(rSdrModel, OBJ_TEXT,rRect),
 198     aTailPoly(3),  // default size: 3 points = 2 lines
 199     mbSpecialTextBoxShadow(false),
 200     mbFixedTail(false),
 201     mbSuppressGetBitmap(false),
 202     maFixedTailPos()
 203 {
 204     aTailPoly[0]=maFixedTailPos=rTail;
 205 }
 206
 207 SdrCaptionObj::~SdrCaptionObj()
 208 {
 209 }
 210
 211 void SdrCaptionObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
 212 {
 213     rInfo.bRotateFreeAllowed=false;
 214     rInfo.bRotate90Allowed  =false;
 215     rInfo.bMirrorFreeAllowed=false;
 216     rInfo.bMirror45Allowed  =false;
 217     rInfo.bMirror90Allowed  =false;
 218     rInfo.bTransparenceAllowed = false;
 219     rInfo.bShearAllowed     =false;
 220     rInfo.bEdgeRadiusAllowed=false;
 221     rInfo.bCanConvToPath    =true;
 222     rInfo.bCanConvToPoly    =true;
 223     rInfo.bCanConvToPathLineToArea=false;
 224     rInfo.bCanConvToPolyLineToArea=false;
 225     rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary());
 226 }
 227
 228 SdrObjKind SdrCaptionObj::GetObjIdentifier() const
 229 {
 230     return OBJ_CAPTION;
 231 }
 232
 233 SdrCaptionObj* SdrCaptionObj::CloneSdrObject(SdrModel& rTargetModel) const
 234 {
 235     return CloneHelper< SdrCaptionObj >(rTargetModel);
 236 }
 237
 238 SdrCaptionObj& SdrCaptionObj::operator=(const SdrCaptionObj& rObj)
 239 {
 240     if( this == &rObj )
 241         return *this;
 242     SdrRectObj::operator=(rObj);
 243
 244     aTailPoly = rObj.aTailPoly;
 245     mbSpecialTextBoxShadow = rObj.mbSpecialTextBoxShadow;
 246     mbFixedTail = rObj.mbFixedTail;
 247     maFixedTailPos = rObj.maFixedTailPos;
 248
 249     return *this;
 250 }
 251
 252 OUString SdrCaptionObj::TakeObjNameSingul() const
 253 {
 254     OUStringBuffer sName(SvxResId(STR_ObjNameSingulCAPTION));
 255
 256     OUString aName(GetName());
 257     if (!aName.isEmpty())
 258     {
 259         sName.append(' ');
 260         sName.append('\'');
 261         sName.append(aName);
 262         sName.append('\'');
 263     }
 264
 265     return sName.makeStringAndClear();
 266 }
 267
 268 OUString SdrCaptionObj::TakeObjNamePlural() const
 269 {
 270     return SvxResId(STR_ObjNamePluralCAPTION);
 271 }
 272
 273 basegfx::B2DPolyPolygon SdrCaptionObj::TakeXorPoly() const
 274 {
 275     basegfx::B2DPolyPolygon aPolyPoly(SdrRectObj::TakeXorPoly());
 276     aPolyPoly.append(aTailPoly.getB2DPolygon());
 277
 278     return aPolyPoly;
 279 }
 280
 281 sal_uInt32 SdrCaptionObj::GetHdlCount() const
 282 {
 283     sal_uInt32 nCount1(SdrRectObj::GetHdlCount());
 284     // Currently only dragging the tail's end is implemented.
 285     return nCount1 + 1;
 286 }
 287
 288 void SdrCaptionObj::AddToHdlList(SdrHdlList& rHdlList) const
 289 {
 290     SdrRectObj::AddToHdlList(rHdlList);
 291     // Currently only dragging the tail's end is implemented.
 292     std::unique_ptr<SdrHdl> pHdl(new SdrHdl(aTailPoly.GetPoint(0), SdrHdlKind::Poly));
 293     pHdl->SetPolyNum(1);
 294     pHdl->SetPointNum(0);
 295     rHdlList.AddHdl(std::move(pHdl));
 296 }
 297
 298 bool SdrCaptionObj::hasSpecialDrag() const
 299 {
 300     return true;
 301 }
 302
 303 bool SdrCaptionObj::beginSpecialDrag(SdrDragStat& rDrag) const
 304 {
 305     const SdrHdl* pHdl = rDrag.GetHdl();
 306     rDrag.SetEndDragChangesAttributes(true);
 307     rDrag.SetEndDragChangesGeoAndAttributes(true);
 308
 309     if(pHdl && 0 == pHdl->GetPolyNum())
 310     {
 311         return SdrRectObj::beginSpecialDrag(rDrag);
 312     }
 313     else
 314     {
 315         rDrag.SetOrtho8Possible();
 316
 317         if(!pHdl)
 318         {
 319             if (bMovProt)
 320                 return false;
 321
 322             rDrag.SetNoSnap();
 323             rDrag.SetActionRect(maRect);
 324
 325             Point aHit(rDrag.GetStart());
 326
 327             if(rDrag.GetPageView() && SdrObjectPrimitiveHit(*this, aHit, 0, *rDrag.GetPageView(), nullptr, false))
 328             {
 329                 return true;
 330             }
 331         }
 332         else
 333         {
 334             if((1 == pHdl->GetPolyNum()) && (0 == pHdl->GetPointNum()))
 335                 return true;
 336         }
 337     }
 338
 339     return false;
 340 }
 341
 342 bool SdrCaptionObj::applySpecialDrag(SdrDragStat& rDrag)
 343 {
 344     const SdrHdl* pHdl = rDrag.GetHdl();
 345
 346     if(pHdl && 0 == pHdl->GetPolyNum())
 347     {
 348         const bool bRet(SdrRectObj::applySpecialDrag(rDrag));
 349         ImpRecalcTail();
 350         ActionChanged();
 351
 352         return bRet;
 353     }
 354     else
 355     {
 356         Point aDelt(rDrag.GetNow()-rDrag.GetStart());
 357
 358         if(!pHdl)
 359         {
 360             maRect.Move(aDelt.X(),aDelt.Y());
 361         }
 362         else
 363         {
 364             aTailPoly[0] += aDelt;
 365         }
 366
 367         ImpRecalcTail();
 368         ActionChanged();
 369
 370         return true;
 371     }
 372 }
 373
 374 OUString SdrCaptionObj::getSpecialDragComment(const SdrDragStat& rDrag) const
 375 {
 376     const bool bCreateComment(rDrag.GetView() && this == rDrag.GetView()->GetCreateObj());
 377
 378     if(bCreateComment)
 379     {
 380         return OUString();
 381     }
 382     else
 383     {
 384         const SdrHdl* pHdl = rDrag.GetHdl();
 385
 386         if(pHdl && 0 == pHdl->GetPolyNum())
 387         {
 388             return SdrRectObj::getSpecialDragComment(rDrag);
 389         }
 390         else
 391         {
 392             if(!pHdl)
 393             {
 394                 return ImpGetDescriptionStr(STR_DragCaptFram);
 395             }
 396             else
 397             {
 398                 return ImpGetDescriptionStr(STR_DragCaptTail);
 399             }
 400         }
 401     }
 402 }
 403
 404
 405 void SdrCaptionObj::ImpGetCaptParams(ImpCaptParams& rPara) const
 406 {
 407     const SfxItemSet& rSet = GetObjectItemSet();
 408     rPara.eType      =rSet.Get(SDRATTR_CAPTIONTYPE      ).GetValue();
 409     rPara.bFixedAngle=rSet.Get(SDRATTR_CAPTIONFIXEDANGLE).GetValue();
 410     rPara.nGap       =static_cast<const SdrCaptionGapItem&>       (rSet.Get(SDRATTR_CAPTIONGAP       )).GetValue();
 411     rPara.eEscDir    =rSet.Get(SDRATTR_CAPTIONESCDIR    ).GetValue();
 412     rPara.bEscRel    =rSet.Get(SDRATTR_CAPTIONESCISREL  ).GetValue();
 413     rPara.nEscRel    =rSet.Get(SDRATTR_CAPTIONESCREL    ).GetValue();
 414     rPara.nEscAbs    =rSet.Get(SDRATTR_CAPTIONESCABS    ).GetValue();
 415     rPara.nLineLen   =rSet.Get(SDRATTR_CAPTIONLINELEN   ).GetValue();
 416     rPara.bFitLineLen=rSet.Get(SDRATTR_CAPTIONFITLINELEN).GetValue();
 417 }
 418
 419 void SdrCaptionObj::ImpRecalcTail()
 420 {
 421     ImpCaptParams aPara;
 422     ImpGetCaptParams(aPara);
 423     ImpCalcTail(aPara, aTailPoly, maRect);
 424     SetRectsDirty();
 425     SetXPolyDirty();
 426 }
 427
 428 // #i35971#
 429 // SdrCaptionObj::ImpCalcTail1 does move the object(!). What a hack.
 430 // I really wonder why this had not triggered problems before. I am
 431 // sure there are some places where SetTailPos() is called at least
 432 // twice or SetSnapRect after it again just to work around this.
 433 // Changed this method to not do that.
 434 // Also found why this has been done: For interactive dragging of the
 435 // tail end pos for SdrCaptionType::Type1. This sure was the simplest method
 436 // to achieve this, at the cost of making a whole group of const methods
 437 // of this object implicitly change the object's position.
 438 void SdrCaptionObj::ImpCalcTail1(const ImpCaptParams& rPara, tools::Polygon& rPoly, tools::Rectangle const & rRect)
 439 {
 440     tools::Polygon aPol(2);
 441     Point aTl(rPoly[0]);
 442
 443     aPol[0] = aTl;
 444     aPol[1] = aTl;
 445
 446     EscDir eEscDir;
 447     Point aEscPos;
 448
 449     rPara.CalcEscPos(aTl, rRect, aEscPos, eEscDir);
 450     aPol[1] = aEscPos;
 451
 452     if(eEscDir==LKS || eEscDir==RTS)
 453     {
 454         aPol[0].setX( aEscPos.X() );
 455     }
 456     else
 457     {
 458         aPol[0].setY( aEscPos.Y() );
 459     }
 460
 461     rPoly = aPol;
 462 }
 463
 464 void SdrCaptionObj::ImpCalcTail2(const ImpCaptParams& rPara, tools::Polygon& rPoly, tools::Rectangle const & rRect)
 465 { // Gap/EscDir/EscPos/Angle
 466     tools::Polygon aPol(2);
 467     Point aTl(rPoly[0]);
 468     aPol[0]=aTl;
 469
 470     EscDir eEscDir;
 471     Point aEscPos;
 472     rPara.CalcEscPos(aTl,rRect,aEscPos,eEscDir);
 473     aPol[1]=aEscPos;
 474
 475     if (!rPara.bFixedAngle) {
 476         // TODO: Implementation missing.
 477     }
 478     rPoly=aPol;
 479 }
 480
 481 void SdrCaptionObj::ImpCalcTail3(const ImpCaptParams& rPara, tools::Polygon& rPoly, tools::Rectangle const & rRect)
 482 { // Gap/EscDir/EscPos/Angle/LineLen
 483     tools::Polygon aPol(3);
 484     Point aTl(rPoly[0]);
 485     aPol[0]=aTl;
 486
 487     EscDir eEscDir;
 488     Point aEscPos;
 489     rPara.CalcEscPos(aTl,rRect,aEscPos,eEscDir);
 490     aPol[1]=aEscPos;
 491     aPol[2]=aEscPos;
 492
 493     if (eEscDir==LKS || eEscDir==RTS) {
 494         if (rPara.bFitLineLen) {
 495             aPol[1].setX((aTl.X()+aEscPos.X())/2 );
 496         } else {
 497             if (eEscDir==LKS) aPol[1].AdjustX( -(rPara.nLineLen) );
 498             else aPol[1].AdjustX(rPara.nLineLen );
 499         }
 500     } else {
 501         if (rPara.bFitLineLen) {
 502             aPol[1].setY((aTl.Y()+aEscPos.Y())/2 );
 503         } else {
 504             if (eEscDir==OBN) aPol[1].AdjustY( -(rPara.nLineLen) );
 505             else aPol[1].AdjustY(rPara.nLineLen );
 506         }
 507     }
 508     if (!rPara.bFixedAngle) {
 509         // TODO: Implementation missing.
 510     }
 511     rPoly=aPol;
 512 }
 513
 514 void SdrCaptionObj::ImpCalcTail(const ImpCaptParams& rPara, tools::Polygon& rPoly, tools::Rectangle const & rRect)
 515 {
 516     switch (rPara.eType) {
 517         case SdrCaptionType::Type1: ImpCalcTail1(rPara,rPoly,rRect); break;
 518         case SdrCaptionType::Type2: ImpCalcTail2(rPara,rPoly,rRect); break;
 519         case SdrCaptionType::Type3: ImpCalcTail3(rPara,rPoly,rRect); break;
 520         case SdrCaptionType::Type4: ImpCalcTail3(rPara,rPoly,rRect); break;
 521     }
 522 }
 523
 524 bool SdrCaptionObj::BegCreate(SdrDragStat& rStat)
 525 {
 526     if (maRect.IsEmpty()) return false; // Create currently only works with the given Rect
 527
 528     ImpCaptParams aPara;
 529     ImpGetCaptParams(aPara);
 530     maRect.SetPos(rStat.GetNow());
 531     aTailPoly[0]=rStat.GetStart();
 532     ImpCalcTail(aPara,aTailPoly,maRect);
 533     rStat.SetActionRect(maRect);
 534     return true;
 535 }
 536
 537 bool SdrCaptionObj::MovCreate(SdrDragStat& rStat)
 538 {
 539     ImpCaptParams aPara;
 540     ImpGetCaptParams(aPara);
 541     maRect.SetPos(rStat.GetNow());
 542     ImpCalcTail(aPara,aTailPoly,maRect);
 543     rStat.SetActionRect(maRect);
 544     SetBoundRectDirty();
 545     bSnapRectDirty=true;
 546     return true;
 547 }
 548
 549 bool SdrCaptionObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
 550 {
 551     ImpCaptParams aPara;
 552     ImpGetCaptParams(aPara);
 553     maRect.SetPos(rStat.GetNow());
 554     ImpCalcTail(aPara,aTailPoly,maRect);
 555     SetRectsDirty();
 556     return (eCmd==SdrCreateCmd::ForceEnd || rStat.GetPointCount()>=2);
 557 }
 558
 559 bool SdrCaptionObj::BckCreate(SdrDragStat& /*rStat*/)
 560 {
 561     return false;
 562 }
 563
 564 void SdrCaptionObj::BrkCreate(SdrDragStat& /*rStat*/)
 565 {
 566 }
 567
 568 basegfx::B2DPolyPolygon SdrCaptionObj::TakeCreatePoly(const SdrDragStat& /*rDrag*/) const
 569 {
 570     basegfx::B2DPolyPolygon aRetval;
 571     const basegfx::B2DRange aRange =vcl::unotools::b2DRectangleFromRectangle(maRect);
 572     aRetval.append(basegfx::utils::createPolygonFromRect(aRange));
 573     aRetval.append(aTailPoly.getB2DPolygon());
 574     return aRetval;
 575 }
 576
 577 PointerStyle SdrCaptionObj::GetCreatePointer() const
 578 {
 579     return PointerStyle::DrawCaption;
 580 }
 581
 582 void SdrCaptionObj::NbcMove(const Size& rSiz)
 583 {
 584     SdrRectObj::NbcMove(rSiz);
 585     MovePoly(aTailPoly,rSiz);
 586     if(mbFixedTail)
 587         SetTailPos(GetFixedTailPos());
 588 }
 589
 590 void SdrCaptionObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
 591 {
 592     SdrRectObj::NbcResize(rRef,xFact,yFact);
 593     ResizePoly(aTailPoly,rRef,xFact,yFact);
 594     ImpRecalcTail();
 595     if(mbFixedTail)
 596         SetTailPos(GetFixedTailPos());
 597 }
 598
 599 void SdrCaptionObj::NbcSetRelativePos(const Point& rPnt)
 600 {
 601     Point aRelPos0(aTailPoly.GetPoint(0)-aAnchor);
 602     Size aSiz(rPnt.X()-aRelPos0.X(),rPnt.Y()-aRelPos0.Y());
 603     NbcMove(aSiz); // This also calls SetRectsDirty()
 604 }
 605
 606 Point SdrCaptionObj::GetRelativePos() const
 607 {
 608     return aTailPoly.GetPoint(0)-aAnchor;
 609 }
 610
 611 const tools::Rectangle& SdrCaptionObj::GetLogicRect() const
 612 {
 613     return maRect;
 614 }
 615
 616 void SdrCaptionObj::NbcSetLogicRect(const tools::Rectangle& rRect)
 617 {
 618     SdrRectObj::NbcSetLogicRect(rRect);
 619     ImpRecalcTail();
 620 }
 621
 622 const Point& SdrCaptionObj::GetTailPos() const
 623 {
 624     return aTailPoly[0];
 625 }
 626
 627 void SdrCaptionObj::SetTailPos(const Point& rPos)
 628 {
 629     if (aTailPoly.GetSize()==0 || aTailPoly[0]!=rPos) {
 630         tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
 631         NbcSetTailPos(rPos);
 632         SetChanged();
 633         BroadcastObjectChange();
 634         SendUserCall(SdrUserCallType::Resize,aBoundRect0);
 635     }
 636 }
 637
 638 void SdrCaptionObj::NbcSetTailPos(const Point& rPos)
 639 {
 640     aTailPoly[0]=rPos;
 641     ImpRecalcTail();
 642 }
 643
 644 sal_uInt32 SdrCaptionObj::GetSnapPointCount() const
 645 {
 646     // TODO: Implementation missing.
 647     return 0;
 648 }
 649
 650 Point SdrCaptionObj::GetSnapPoint(sal_uInt32 /*i*/) const
 651 {
 652     // TODO: Implementation missing.
 653     return Point(0,0);
 654 }
 655
 656 void SdrCaptionObj::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
 657 {
 658     SdrRectObj::Notify(rBC,rHint);
 659     ImpRecalcTail();
 660 }
 661
 662 SdrObjGeoData* SdrCaptionObj::NewGeoData() const
 663 {
 664     return new SdrCaptObjGeoData;
 665 }
 666
 667 void SdrCaptionObj::SaveGeoData(SdrObjGeoData& rGeo) const
 668 {
 669     SdrRectObj::SaveGeoData(rGeo);
 670     SdrCaptObjGeoData& rCGeo=static_cast<SdrCaptObjGeoData&>(rGeo);
 671     rCGeo.aTailPoly=aTailPoly;
 672 }
 673
 674 void SdrCaptionObj::RestGeoData(const SdrObjGeoData& rGeo)
 675 {
 676     SdrRectObj::RestGeoData(rGeo);
 677     const SdrCaptObjGeoData& rCGeo=static_cast<const SdrCaptObjGeoData&>(rGeo);
 678     aTailPoly=rCGeo.aTailPoly;
 679 }
 680
 681 SdrObjectUniquePtr SdrCaptionObj::DoConvertToPolyObj(bool bBezier, bool bAddText) const
 682 {
 683     SdrObjectUniquePtr pRect = SdrRectObj::DoConvertToPolyObj(bBezier, bAddText);
 684     SdrObjectUniquePtr pTail = ImpConvertMakeObj(basegfx::B2DPolyPolygon(aTailPoly.getB2DPolygon()), false, bBezier);
 685     SdrObjectUniquePtr pRet;
 686     if (pTail && !pRect)
 687         pRet = std::move(pTail);
 688     else if (pRect && !pTail)
 689         pRet = std::move(pRect);
 690     else if (pTail && pRect)
 691     {
 692         if (pTail->GetSubList())
 693         {
 694             pTail->GetSubList()->NbcInsertObject(pRect.release());
 695             pRet = std::move(pTail);
 696         }
 697         else if (pRect->GetSubList())
 698         {
 699             pRect->GetSubList()->NbcInsertObject(pTail.release(),0);
 700             pRet = std::move(pRect);
 701         }
 702         else
 703         {
 704             SdrObjGroup* pGrp = new SdrObjGroup(getSdrModelFromSdrObject());
 705             pGrp->GetSubList()->NbcInsertObject(pRect.release());
 706             pGrp->GetSubList()->NbcInsertObject(pTail.release(),0);
 707             pRet.reset(pGrp);
 708         }
 709     }
 710     return pRet;
 711 }
 712
 713 namespace {
 714
 715 void handleNegativeScale(basegfx::B2DTuple & scale, double * rotate) {
 716     assert(rotate != nullptr);
 717
 718     // #i75086# Old DrawingLayer (GeoStat and geometry) does not support holding negative scalings
 719     // in X and Y which equal a 180 degree rotation. Recognize it and react accordingly
 720     if(basegfx::fTools::less(scale.getX(), 0.0) && basegfx::fTools::less(scale.getY(), 0.0))
 721     {
 722         scale.setX(fabs(scale.getX()));
 723         scale.setY(fabs(scale.getY()));
 724         *rotate = fmod(*rotate + F_PI, F_2PI);
 725     }
 726 }
 727
 728 }
 729
 730 // #i32599#
 731 // Add own implementation for TRSetBaseGeometry to handle TailPos over changes.
 732 void SdrCaptionObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& /*rPolyPolygon*/)
 733 {
 734     // break up matrix
 735     basegfx::B2DTuple aScale;
 736     basegfx::B2DTuple aTranslate;
 737     double fRotate, fShearX;
 738     rMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
 739
 740     handleNegativeScale(aScale, &fRotate);
 741
 742     // if anchor is used, make position relative to it
 743     if(getSdrModelFromSdrObject().IsWriter())
 744     {
 745         if(GetAnchorPos().X() || GetAnchorPos().Y())
 746         {
 747             aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
 748         }
 749     }
 750
 751     // build BaseRect
 752     Point aPoint(FRound(aTranslate.getX()), FRound(aTranslate.getY()));
 753     tools::Rectangle aBaseRect(aPoint, Size(FRound(aScale.getX()), FRound(aScale.getY())));
 754
 755     // set BaseRect, but rescue TailPos over this call
 756     const Point aTailPoint = GetTailPos();
 757     SetSnapRect(aBaseRect);
 758     SetTailPos(aTailPoint);
 759     ImpRecalcTail();
 760 }
 761
 762 // geometry access
 763 basegfx::B2DPolygon SdrCaptionObj::getTailPolygon() const
 764 {
 765     return aTailPoly.getB2DPolygon();
 766 }
 767
 768 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */