LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdocapt.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 178 413 43.1 %
Date: 2014-11-03 Functions: 31 65 47.7 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10