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