LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdocirc.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 226 657 34.4 %
Date: 2014-11-03 Functions: 31 57 54.4 %
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/matrix/b2dhommatrixtools.hxx>
      22             : #include <basegfx/point/b2dpoint.hxx>
      23             : #include <basegfx/polygon/b2dpolygon.hxx>
      24             : #include <basegfx/polygon/b2dpolygontools.hxx>
      25             : #include <editeng/eeitem.hxx>
      26             : #include <math.h>
      27             : #include <svl/style.hxx>
      28             : 
      29             : #include "svdglob.hxx"
      30             : #include "svx/svdstr.hrc"
      31             : 
      32             : #include <sdr/contact/viewcontactofsdrcircobj.hxx>
      33             : #include <sdr/properties/circleproperties.hxx>
      34             : #include <svx/svdattr.hxx>
      35             : #include <svx/svddrag.hxx>
      36             : #include <svx/svdetc.hxx>
      37             : #include <svx/svdmodel.hxx>
      38             : #include <svx/svdocirc.hxx>
      39             : #include <svx/svdopath.hxx>
      40             : #include <svx/svdpage.hxx>
      41             : #include <svx/svdpool.hxx>
      42             : #include <svx/svdtrans.hxx>
      43             : #include <svx/svdview.hxx>
      44             : #include <svx/sxciaitm.hxx>
      45             : #include <sxcikitm.hxx>
      46             : #include <svx/xlnedit.hxx>
      47             : #include <svx/xlnedwit.hxx>
      48             : #include <svx/xlnstit.hxx>
      49             : #include <svx/xlnstwit.hxx>
      50             : #include <svx/xlnwtit.hxx>
      51             : #include <svx/xpool.hxx>
      52             : 
      53             : using namespace com::sun::star;
      54             : 
      55           0 : Point GetWinkPnt(const Rectangle& rR, long nWink)
      56             : {
      57           0 :     Point aCenter(rR.Center());
      58           0 :     long nWdt=rR.Right()-rR.Left();
      59           0 :     long nHgt=rR.Bottom()-rR.Top();
      60           0 :     long nMaxRad=((nWdt>nHgt ? nWdt : nHgt)+1) /2;
      61             :     double a;
      62           0 :     a=nWink*nPi180;
      63           0 :     Point aRetval(Round(cos(a)*nMaxRad),-Round(sin(a)*nMaxRad));
      64           0 :     if (nWdt==0) aRetval.X()=0;
      65           0 :     if (nHgt==0) aRetval.Y()=0;
      66           0 :     if (nWdt!=nHgt) {
      67           0 :         if (nWdt>nHgt) {
      68           0 :             if (nWdt!=0) {
      69             :                 // stop possible overruns for very large objects
      70           0 :                 if (std::abs(nHgt)>32767 || std::abs(aRetval.Y())>32767) {
      71           0 :                     aRetval.Y()=BigMulDiv(aRetval.Y(),nHgt,nWdt);
      72             :                 } else {
      73           0 :                     aRetval.Y()=aRetval.Y()*nHgt/nWdt;
      74             :                 }
      75             :             }
      76             :         } else {
      77           0 :             if (nHgt!=0) {
      78             :                 // stop possible overruns for very large objects
      79           0 :                 if (std::abs(nWdt)>32767 || std::abs(aRetval.X())>32767) {
      80           0 :                     aRetval.X()=BigMulDiv(aRetval.X(),nWdt,nHgt);
      81             :                 } else {
      82           0 :                     aRetval.X()=aRetval.X()*nWdt/nHgt;
      83             :                 }
      84             :             }
      85             :         }
      86             :     }
      87           0 :     aRetval+=aCenter;
      88           0 :     return aRetval;
      89             : }
      90             : 
      91             : 
      92             : // BaseProperties section
      93             : 
      94         186 : sdr::properties::BaseProperties* SdrCircObj::CreateObjectSpecificProperties()
      95             : {
      96         186 :     return new sdr::properties::CircleProperties(*this);
      97             : }
      98             : 
      99             : 
     100             : // DrawContact section
     101             : 
     102         188 : sdr::contact::ViewContact* SdrCircObj::CreateObjectSpecificViewContact()
     103             : {
     104         188 :     return new sdr::contact::ViewContactOfSdrCircObj(*this);
     105             : }
     106             : 
     107             : 
     108             : 
     109       18346 : TYPEINIT1(SdrCircObj,SdrRectObj);
     110             : 
     111         186 : SdrCircObj::SdrCircObj(SdrObjKind eNewKind)
     112             : {
     113         186 :     nStartWink=0;
     114         186 :     nEndWink=36000;
     115         186 :     meCircleKind=eNewKind;
     116         186 :     bClosedObj=eNewKind!=OBJ_CARC;
     117         186 : }
     118             : 
     119           2 : SdrCircObj::SdrCircObj(SdrObjKind eNewKind, const Rectangle& rRect):
     120           2 :     SdrRectObj(rRect)
     121             : {
     122           2 :     nStartWink=0;
     123           2 :     nEndWink=36000;
     124           2 :     meCircleKind=eNewKind;
     125           2 :     bClosedObj=eNewKind!=OBJ_CARC;
     126           2 : }
     127             : 
     128           0 : SdrCircObj::SdrCircObj(SdrObjKind eNewKind, const Rectangle& rRect, long nNewStartWink, long nNewEndWink):
     129           0 :     SdrRectObj(rRect)
     130             : {
     131           0 :     long nWinkDif=nNewEndWink-nNewStartWink;
     132           0 :     nStartWink=NormAngle360(nNewStartWink);
     133           0 :     nEndWink=NormAngle360(nNewEndWink);
     134           0 :     if (nWinkDif==36000) nEndWink+=nWinkDif; // full circle
     135           0 :     meCircleKind=eNewKind;
     136           0 :     bClosedObj=eNewKind!=OBJ_CARC;
     137           0 : }
     138             : 
     139         376 : SdrCircObj::~SdrCircObj()
     140             : {
     141         376 : }
     142             : 
     143           0 : void SdrCircObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
     144             : {
     145           0 :     bool bCanConv=!HasText() || ImpCanConvTextToCurve();
     146           0 :     rInfo.bEdgeRadiusAllowed    = false;
     147           0 :     rInfo.bCanConvToPath=bCanConv;
     148           0 :     rInfo.bCanConvToPoly=bCanConv;
     149           0 :     rInfo.bCanConvToContour = !IsFontwork() && (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary());
     150           0 : }
     151             : 
     152        3077 : sal_uInt16 SdrCircObj::GetObjIdentifier() const
     153             : {
     154        3077 :     return sal_uInt16(meCircleKind);
     155             : }
     156             : 
     157         247 : bool SdrCircObj::PaintNeedsXPolyCirc() const
     158             : {
     159             :     // XPoly is necessary for all rotated ellipse objects, circle and
     160             :     // ellipse segments.
     161             :     // If not WIN, then (for now) also for circle/ellipse segments and circle/
     162             :     // ellipse arcs (for precision)
     163         247 :     bool bNeed=aGeo.nRotationAngle!=0 || aGeo.nShearAngle!=0 || meCircleKind==OBJ_CCUT;
     164             :     // If not WIN, then for everything except full circle (for now!)
     165         247 :     if (meCircleKind!=OBJ_CIRC) bNeed = true;
     166             : 
     167         247 :     const SfxItemSet& rSet = GetObjectItemSet();
     168         247 :     if(!bNeed)
     169             :     {
     170             :         // XPoly is necessary for everything that isn't LineSolid or LineNone
     171         155 :         XLineStyle eLine = static_cast<const XLineStyleItem&>(rSet.Get(XATTR_LINESTYLE)).GetValue();
     172         155 :         bNeed = eLine != XLINE_NONE && eLine != XLINE_SOLID;
     173             : 
     174             :         // XPoly is necessary for thick lines
     175         155 :         if(!bNeed && eLine != XLINE_NONE)
     176         147 :             bNeed = static_cast<const XLineWidthItem&>(rSet.Get(XATTR_LINEWIDTH)).GetValue() != 0;
     177             : 
     178             :         // XPoly is necessary for circle arcs with line ends
     179         155 :         if(!bNeed && meCircleKind == OBJ_CARC)
     180             :         {
     181             :             // start of the line is here if StartPolygon, StartWidth!=0
     182           0 :             bNeed=static_cast<const XLineStartItem&>(rSet.Get(XATTR_LINESTART)).GetLineStartValue().count() != 0L &&
     183           0 :                   static_cast<const XLineStartWidthItem&>(rSet.Get(XATTR_LINESTARTWIDTH)).GetValue() != 0;
     184             : 
     185           0 :             if(!bNeed)
     186             :             {
     187             :                 // end of the line is here if EndPolygon, EndWidth!=0
     188           0 :                 bNeed = static_cast<const XLineEndItem&>(rSet.Get(XATTR_LINEEND)).GetLineEndValue().count() != 0L &&
     189           0 :                         static_cast<const XLineEndWidthItem&>(rSet.Get(XATTR_LINEENDWIDTH)).GetValue() != 0;
     190             :             }
     191             :         }
     192             :     }
     193             : 
     194             :     // XPoly is necessary if Fill !=None and !=Solid
     195         247 :     if(!bNeed && meCircleKind != OBJ_CARC)
     196             :     {
     197         133 :         drawing::FillStyle eFill=static_cast<const XFillStyleItem&>(rSet.Get(XATTR_FILLSTYLE)).GetValue();
     198         133 :         bNeed = eFill != drawing::FillStyle_NONE && eFill != drawing::FillStyle_SOLID;
     199             :     }
     200             : 
     201         247 :     if(!bNeed && meCircleKind != OBJ_CIRC && nStartWink == nEndWink)
     202           0 :         bNeed = true; // otherwise we're drawing a full circle
     203             : 
     204         247 :     return bNeed;
     205             : }
     206             : 
     207         126 : basegfx::B2DPolygon SdrCircObj::ImpCalcXPolyCirc(const SdrObjKind eCicrleKind, const Rectangle& rRect1, long nStart, long nEnd) const
     208             : {
     209         126 :     const basegfx::B2DRange aRange(rRect1.Left(), rRect1.Top(), rRect1.Right(), rRect1.Bottom());
     210         126 :     basegfx::B2DPolygon aCircPolygon;
     211             : 
     212         126 :     if(OBJ_CIRC == eCicrleKind)
     213             :     {
     214             :         // create full circle. Do not use createPolygonFromEllipse; it's necessary
     215             :         // to get the start point to the bottom of the circle to keep compatible to
     216             :         // old geometry creation
     217          34 :         aCircPolygon = basegfx::tools::createPolygonFromUnitCircle(1);
     218             : 
     219             :         // needs own scaling and translation from unit circle to target size (same as
     220             :         // would be in createPolygonFromEllipse)
     221          34 :         const basegfx::B2DPoint aCenter(aRange.getCenter());
     222             :         const basegfx::B2DHomMatrix aMatrix(basegfx::tools::createScaleTranslateB2DHomMatrix(
     223          68 :             aRange.getWidth() / 2.0, aRange.getHeight() / 2.0,
     224         136 :             aCenter.getX(), aCenter.getY()));
     225          68 :         aCircPolygon.transform(aMatrix);
     226             :     }
     227             :     else
     228             :     {
     229             :         // mirror start, end for geometry creation since model coordinate system is mirrored in Y
     230             :         // #i111715# increase numerical correctness by first dividing and not using F_PI1800
     231          92 :         const double fStart((((36000 - nEnd) % 36000) / 18000.0) * F_PI);
     232          92 :         const double fEnd((((36000 - nStart) % 36000) / 18000.0) * F_PI);
     233             : 
     234             :         // create circle segment. This is not closed by default
     235         276 :         aCircPolygon = basegfx::tools::createPolygonFromEllipseSegment(
     236         184 :             aRange.getCenter(), aRange.getWidth() / 2.0, aRange.getHeight() / 2.0,
     237          92 :             fStart, fEnd);
     238             : 
     239             :         // check closing states
     240          92 :         const bool bCloseSegment(OBJ_CARC != eCicrleKind);
     241          92 :         const bool bCloseUsingCenter(OBJ_SECT == eCicrleKind);
     242             : 
     243          92 :         if(bCloseSegment)
     244             :         {
     245          68 :             if(bCloseUsingCenter)
     246             :             {
     247             :                 // add center point at start (for historical reasons)
     248          24 :                 basegfx::B2DPolygon aSector;
     249          24 :                 aSector.append(aRange.getCenter());
     250          24 :                 aSector.append(aCircPolygon);
     251          24 :                 aCircPolygon = aSector;
     252             :             }
     253             : 
     254             :             // close
     255          68 :             aCircPolygon.setClosed(true);
     256             :         }
     257             :     }
     258             : 
     259             :     // #i76950#
     260         126 :     if(aGeo.nShearAngle || aGeo.nRotationAngle)
     261             :     {
     262             :         // translate top left to (0,0)
     263           0 :         const basegfx::B2DPoint aTopLeft(aRange.getMinimum());
     264             :         basegfx::B2DHomMatrix aMatrix(basegfx::tools::createTranslateB2DHomMatrix(
     265           0 :             -aTopLeft.getX(), -aTopLeft.getY()));
     266             : 
     267             :         // shear, rotate and back to top left (if needed)
     268             :         aMatrix = basegfx::tools::createShearXRotateTranslateB2DHomMatrix(
     269           0 :             aGeo.nShearAngle ? tan((36000 - aGeo.nShearAngle) * F_PI18000) : 0.0,
     270           0 :             aGeo.nRotationAngle ? (36000 - aGeo.nRotationAngle) * F_PI18000 : 0.0,
     271           0 :             aTopLeft) * aMatrix;
     272             : 
     273             :         // apply transformation
     274           0 :         aCircPolygon.transform(aMatrix);
     275             :     }
     276             : 
     277         126 :     return aCircPolygon;
     278             : }
     279             : 
     280         120 : void SdrCircObj::RecalcXPoly()
     281             : {
     282         120 :     const basegfx::B2DPolygon aPolyCirc(ImpCalcXPolyCirc(meCircleKind, aRect, nStartWink, nEndWink));
     283         120 :     mpXPoly = new XPolygon(aPolyCirc);
     284         120 : }
     285             : 
     286           4 : OUString SdrCircObj::TakeObjNameSingul() const
     287             : {
     288           4 :     sal_uInt16 nID=STR_ObjNameSingulCIRC;
     289           4 :     if (aRect.GetWidth()==aRect.GetHeight() && aGeo.nShearAngle==0) {
     290           2 :         switch (meCircleKind) {
     291           2 :             case OBJ_CIRC: nID=STR_ObjNameSingulCIRC; break;
     292           0 :             case OBJ_SECT: nID=STR_ObjNameSingulSECT; break;
     293           0 :             case OBJ_CARC: nID=STR_ObjNameSingulCARC; break;
     294           0 :             case OBJ_CCUT: nID=STR_ObjNameSingulCCUT; break;
     295           0 :             default: break;
     296             :         }
     297             :     } else {
     298           2 :         switch (meCircleKind) {
     299           2 :             case OBJ_CIRC: nID=STR_ObjNameSingulCIRCE; break;
     300           0 :             case OBJ_SECT: nID=STR_ObjNameSingulSECTE; break;
     301           0 :             case OBJ_CARC: nID=STR_ObjNameSingulCARCE; break;
     302           0 :             case OBJ_CCUT: nID=STR_ObjNameSingulCCUTE; break;
     303           0 :             default: break;
     304             :         }
     305             :     }
     306           4 :     OUStringBuffer sName(ImpGetResStr(nID));
     307             : 
     308           8 :     OUString aName(GetName());
     309           4 :     if (!aName.isEmpty())
     310             :     {
     311           0 :         sName.append(' ');
     312           0 :         sName.append('\'');
     313           0 :         sName.append(aName);
     314           0 :         sName.append('\'');
     315             :     }
     316           8 :     return sName.makeStringAndClear();
     317             : }
     318             : 
     319          40 : OUString SdrCircObj::TakeObjNamePlural() const
     320             : {
     321          40 :     sal_uInt16 nID=STR_ObjNamePluralCIRC;
     322          40 :     if (aRect.GetWidth()==aRect.GetHeight() && aGeo.nShearAngle==0) {
     323          28 :         switch (meCircleKind) {
     324           4 :             case OBJ_CIRC: nID=STR_ObjNamePluralCIRC; break;
     325           0 :             case OBJ_SECT: nID=STR_ObjNamePluralSECT; break;
     326          24 :             case OBJ_CARC: nID=STR_ObjNamePluralCARC; break;
     327           0 :             case OBJ_CCUT: nID=STR_ObjNamePluralCCUT; break;
     328           0 :             default: break;
     329             :         }
     330             :     } else {
     331          12 :         switch (meCircleKind) {
     332          12 :             case OBJ_CIRC: nID=STR_ObjNamePluralCIRCE; break;
     333           0 :             case OBJ_SECT: nID=STR_ObjNamePluralSECTE; break;
     334           0 :             case OBJ_CARC: nID=STR_ObjNamePluralCARCE; break;
     335           0 :             case OBJ_CCUT: nID=STR_ObjNamePluralCCUTE; break;
     336           0 :             default: break;
     337             :         }
     338             :     }
     339          40 :     return ImpGetResStr(nID);
     340             : }
     341             : 
     342           2 : SdrCircObj* SdrCircObj::Clone() const
     343             : {
     344           2 :     return CloneHelper< SdrCircObj >();
     345             : }
     346             : 
     347           0 : basegfx::B2DPolyPolygon SdrCircObj::TakeXorPoly() const
     348             : {
     349           0 :     const basegfx::B2DPolygon aCircPolygon(ImpCalcXPolyCirc(meCircleKind, aRect, nStartWink, nEndWink));
     350           0 :     return basegfx::B2DPolyPolygon(aCircPolygon);
     351             : }
     352             : 
     353             : struct ImpCircUser : public SdrDragStatUserData
     354             : {
     355             :     Rectangle                   aR;
     356             :     Point                       aCenter;
     357             :     Point                       aRadius;
     358             :     Point                       aP1;
     359             :     Point                       aP2;
     360             :     long                        nMaxRad;
     361             :     long                        nHgt;
     362             :     long                        nWdt;
     363             :     long                        nStart;
     364             :     long                        nEnd;
     365             :     long                        nWink;
     366             :     bool                        bRight; // not yet implemented
     367             : 
     368             : public:
     369           0 :     ImpCircUser()
     370             :     :   nMaxRad(0),
     371             :         nHgt(0),
     372             :         nWdt(0),
     373             :         nStart(0),
     374             :         nEnd(0),
     375             :         nWink(0),
     376           0 :         bRight(false)
     377           0 :     {}
     378             :     void SetCreateParams(SdrDragStat& rStat);
     379             : };
     380             : 
     381          24 : sal_uInt32 SdrCircObj::GetHdlCount() const
     382             : {
     383          24 :     if(OBJ_CIRC != meCircleKind)
     384             :     {
     385           0 :         return 10L;
     386             :     }
     387             :     else
     388             :     {
     389          24 :         return 8L;
     390             :     }
     391             : }
     392             : 
     393         192 : SdrHdl* SdrCircObj::GetHdl(sal_uInt32 nHdlNum) const
     394             : {
     395         192 :     if (meCircleKind==OBJ_CIRC)
     396             :     {
     397         192 :         nHdlNum += 2L;
     398             :     }
     399             : 
     400         192 :     SdrHdl* pH = NULL;
     401         192 :     Point aPnt;
     402         192 :     SdrHdlKind eLocalKind(HDL_MOVE);
     403         192 :     sal_uInt32 nPNum(0);
     404             : 
     405         192 :     switch (nHdlNum)
     406             :     {
     407             :         case 0:
     408           0 :             aPnt = GetWinkPnt(aRect,nStartWink);
     409           0 :             eLocalKind = HDL_CIRC;
     410           0 :             nPNum = 1;
     411           0 :             break;
     412             :         case 1:
     413           0 :             aPnt = GetWinkPnt(aRect,nEndWink);
     414           0 :             eLocalKind = HDL_CIRC;
     415           0 :             nPNum = 2L;
     416           0 :             break;
     417             :         case 2:
     418          24 :             aPnt = aRect.TopLeft();
     419          24 :             eLocalKind = HDL_UPLFT;
     420          24 :             break;
     421             :         case 3:
     422          24 :             aPnt = aRect.TopCenter();
     423          24 :             eLocalKind = HDL_UPPER;
     424          24 :             break;
     425             :         case 4:
     426          24 :             aPnt = aRect.TopRight();
     427          24 :             eLocalKind = HDL_UPRGT;
     428          24 :             break;
     429             :         case 5:
     430          24 :             aPnt = aRect.LeftCenter();
     431          24 :             eLocalKind = HDL_LEFT;
     432          24 :             break;
     433             :         case 6:
     434          24 :             aPnt = aRect.RightCenter();
     435          24 :             eLocalKind = HDL_RIGHT;
     436          24 :             break;
     437             :         case 7:
     438          24 :             aPnt = aRect.BottomLeft();
     439          24 :             eLocalKind = HDL_LWLFT;
     440          24 :             break;
     441             :         case 8:
     442          24 :             aPnt = aRect.BottomCenter();
     443          24 :             eLocalKind = HDL_LOWER;
     444          24 :             break;
     445             :         case 9:
     446          24 :             aPnt = aRect.BottomRight();
     447          24 :             eLocalKind = HDL_LWRGT;
     448          24 :             break;
     449             :     }
     450             : 
     451         192 :     if (aGeo.nShearAngle)
     452             :     {
     453           0 :         ShearPoint(aPnt,aRect.TopLeft(),aGeo.nTan);
     454             :     }
     455             : 
     456         192 :     if (aGeo.nRotationAngle)
     457             :     {
     458           0 :         RotatePoint(aPnt,aRect.TopLeft(),aGeo.nSin,aGeo.nCos);
     459             :     }
     460             : 
     461         192 :     if (eLocalKind != HDL_MOVE)
     462             :     {
     463         192 :         pH = new SdrHdl(aPnt,eLocalKind);
     464         192 :         pH->SetPointNum(nPNum);
     465         192 :         pH->SetObj((SdrObject*)this);
     466         192 :         pH->SetDrehWink(aGeo.nRotationAngle);
     467             :     }
     468             : 
     469         192 :     return pH;
     470             : }
     471             : 
     472             : 
     473             : 
     474          30 : bool SdrCircObj::hasSpecialDrag() const
     475             : {
     476          30 :     return true;
     477             : }
     478             : 
     479           0 : bool SdrCircObj::beginSpecialDrag(SdrDragStat& rDrag) const
     480             : {
     481           0 :     const bool bWink(rDrag.GetHdl() && HDL_CIRC == rDrag.GetHdl()->GetKind());
     482             : 
     483           0 :     if(bWink)
     484             :     {
     485           0 :         if(1 == rDrag.GetHdl()->GetPointNum() || 2 == rDrag.GetHdl()->GetPointNum())
     486             :         {
     487           0 :             rDrag.SetNoSnap(true);
     488             :         }
     489             : 
     490           0 :         return true;
     491             :     }
     492             : 
     493           0 :     return SdrTextObj::beginSpecialDrag(rDrag);
     494             : }
     495             : 
     496           0 : bool SdrCircObj::applySpecialDrag(SdrDragStat& rDrag)
     497             : {
     498           0 :     const bool bWink(rDrag.GetHdl() && HDL_CIRC == rDrag.GetHdl()->GetKind());
     499             : 
     500           0 :     if(bWink)
     501             :     {
     502           0 :         Point aPt(rDrag.GetNow());
     503             : 
     504           0 :         if (aGeo.nRotationAngle!=0)
     505           0 :             RotatePoint(aPt,aRect.TopLeft(),-aGeo.nSin,aGeo.nCos);
     506             : 
     507           0 :         if (aGeo.nShearAngle!=0)
     508           0 :             ShearPoint(aPt,aRect.TopLeft(),-aGeo.nTan);
     509             : 
     510           0 :         aPt-=aRect.Center();
     511             : 
     512           0 :         long nWdt=aRect.Right()-aRect.Left();
     513           0 :         long nHgt=aRect.Bottom()-aRect.Top();
     514             : 
     515           0 :         if(nWdt>=nHgt)
     516             :         {
     517           0 :             aPt.Y()=BigMulDiv(aPt.Y(),nWdt,nHgt);
     518             :         }
     519             :         else
     520             :         {
     521           0 :             aPt.X()=BigMulDiv(aPt.X(),nHgt,nWdt);
     522             :         }
     523             : 
     524           0 :         long nWink=NormAngle360(GetAngle(aPt));
     525             : 
     526           0 :         if (rDrag.GetView() && rDrag.GetView()->IsAngleSnapEnabled())
     527             :         {
     528           0 :             long nSA=rDrag.GetView()->GetSnapAngle();
     529             : 
     530           0 :             if (nSA!=0)
     531             :             {
     532           0 :                 nWink+=nSA/2;
     533           0 :                 nWink/=nSA;
     534           0 :                 nWink*=nSA;
     535           0 :                 nWink=NormAngle360(nWink);
     536             :             }
     537             :         }
     538             : 
     539           0 :         if(1 == rDrag.GetHdl()->GetPointNum())
     540             :         {
     541           0 :             nStartWink = nWink;
     542             :         }
     543           0 :         else if(2 == rDrag.GetHdl()->GetPointNum())
     544             :         {
     545           0 :             nEndWink = nWink;
     546             :         }
     547             : 
     548           0 :         SetRectsDirty();
     549           0 :         SetXPolyDirty();
     550           0 :         ImpSetCircInfoToAttr();
     551           0 :         SetChanged();
     552             : 
     553           0 :         return true;
     554             :     }
     555             :     else
     556             :     {
     557           0 :         return SdrTextObj::applySpecialDrag(rDrag);
     558             :     }
     559             : }
     560             : 
     561           0 : OUString SdrCircObj::getSpecialDragComment(const SdrDragStat& rDrag) const
     562             : {
     563           0 :     const bool bCreateComment(rDrag.GetView() && this == rDrag.GetView()->GetCreateObj());
     564             : 
     565           0 :     if(bCreateComment)
     566             :     {
     567           0 :         OUString aStr;
     568           0 :         ImpTakeDescriptionStr(STR_ViewCreateObj, aStr);
     569           0 :         OUStringBuffer aBuf(aStr);
     570           0 :         const sal_uInt32 nPntAnz(rDrag.GetPointAnz());
     571             : 
     572           0 :         if(OBJ_CIRC != meCircleKind && nPntAnz > 2)
     573             :         {
     574           0 :             const ImpCircUser* pU = static_cast<const ImpCircUser*>(rDrag.GetUser());
     575             :             sal_Int32 nWink;
     576             : 
     577           0 :             aBuf.appendAscii(" (");
     578             : 
     579           0 :             if(3 == nPntAnz)
     580             :             {
     581           0 :                 nWink = pU->nStart;
     582             :             }
     583             :             else
     584             :             {
     585           0 :                 nWink = pU->nEnd;
     586             :             }
     587             : 
     588           0 :             aBuf.append(GetWinkStr(nWink,false));
     589           0 :             aBuf.append(')');
     590             :         }
     591             : 
     592           0 :         return aBuf.makeStringAndClear();
     593             :     }
     594             :     else
     595             :     {
     596           0 :         const bool bWink(rDrag.GetHdl() && HDL_CIRC == rDrag.GetHdl()->GetKind());
     597             : 
     598           0 :         if(bWink)
     599             :         {
     600           0 :             const sal_Int32 nWink(1 == rDrag.GetHdl()->GetPointNum() ? nStartWink : nEndWink);
     601             : 
     602           0 :             OUString aStr;
     603           0 :             ImpTakeDescriptionStr(STR_DragCircAngle, aStr);
     604           0 :             OUStringBuffer aBuf(aStr);
     605           0 :             aBuf.appendAscii(" (");
     606           0 :             aBuf.append(GetWinkStr(nWink,false));
     607           0 :             aBuf.append(')');
     608             : 
     609           0 :             return aBuf.makeStringAndClear();
     610             :         }
     611             :         else
     612             :         {
     613           0 :             return SdrTextObj::getSpecialDragComment(rDrag);
     614             :         }
     615             :     }
     616             : }
     617             : 
     618             : 
     619             : 
     620           0 : void ImpCircUser::SetCreateParams(SdrDragStat& rStat)
     621             : {
     622           0 :     rStat.TakeCreateRect(aR);
     623           0 :     aR.Justify();
     624           0 :     aCenter=aR.Center();
     625           0 :     nWdt=aR.Right()-aR.Left();
     626           0 :     nHgt=aR.Bottom()-aR.Top();
     627           0 :     nMaxRad=((nWdt>nHgt ? nWdt : nHgt)+1) /2;
     628           0 :     nStart=0;
     629           0 :     nEnd=36000;
     630           0 :     if (rStat.GetPointAnz()>2) {
     631           0 :         Point aP(rStat.GetPoint(2)-aCenter);
     632           0 :         if (nWdt==0) aP.X()=0;
     633           0 :         if (nHgt==0) aP.Y()=0;
     634           0 :         if (nWdt>=nHgt) {
     635           0 :             if (nHgt!=0) aP.Y()=aP.Y()*nWdt/nHgt;
     636             :         } else {
     637           0 :             if (nWdt!=0) aP.X()=aP.X()*nHgt/nWdt;
     638             :         }
     639           0 :         nStart=NormAngle360(GetAngle(aP));
     640           0 :         if (rStat.GetView()!=NULL && rStat.GetView()->IsAngleSnapEnabled()) {
     641           0 :             long nSA=rStat.GetView()->GetSnapAngle();
     642           0 :             if (nSA!=0) { // angle snapping
     643           0 :                 nStart+=nSA/2;
     644           0 :                 nStart/=nSA;
     645           0 :                 nStart*=nSA;
     646           0 :                 nStart=NormAngle360(nStart);
     647             :             }
     648             :         }
     649           0 :         aP1 = GetWinkPnt(aR,nStart);
     650           0 :         nEnd=nStart;
     651           0 :         aP2=aP1;
     652           0 :     } else aP1=aCenter;
     653           0 :     if (rStat.GetPointAnz()>3) {
     654           0 :         Point aP(rStat.GetPoint(3)-aCenter);
     655           0 :         if (nWdt>=nHgt) {
     656           0 :             aP.Y()=BigMulDiv(aP.Y(),nWdt,nHgt);
     657             :         } else {
     658           0 :             aP.X()=BigMulDiv(aP.X(),nHgt,nWdt);
     659             :         }
     660           0 :         nEnd=NormAngle360(GetAngle(aP));
     661           0 :         if (rStat.GetView()!=NULL && rStat.GetView()->IsAngleSnapEnabled()) {
     662           0 :             long nSA=rStat.GetView()->GetSnapAngle();
     663           0 :             if (nSA!=0) { // angle snapping
     664           0 :                 nEnd+=nSA/2;
     665           0 :                 nEnd/=nSA;
     666           0 :                 nEnd*=nSA;
     667           0 :                 nEnd=NormAngle360(nEnd);
     668             :             }
     669             :         }
     670           0 :         aP2 = GetWinkPnt(aR,nEnd);
     671           0 :     } else aP2=aCenter;
     672           0 : }
     673             : 
     674           0 : void SdrCircObj::ImpSetCreateParams(SdrDragStat& rStat) const
     675             : {
     676           0 :     ImpCircUser* pU=static_cast<ImpCircUser*>(rStat.GetUser());
     677           0 :     if (pU==NULL) {
     678           0 :         pU=new ImpCircUser;
     679           0 :         rStat.SetUser(pU);
     680             :     }
     681           0 :     pU->SetCreateParams(rStat);
     682           0 : }
     683             : 
     684           0 : bool SdrCircObj::BegCreate(SdrDragStat& rStat)
     685             : {
     686           0 :     rStat.SetOrtho4Possible();
     687           0 :     Rectangle aRect1(rStat.GetStart(), rStat.GetNow());
     688           0 :     aRect1.Justify();
     689           0 :     rStat.SetActionRect(aRect1);
     690           0 :     aRect = aRect1;
     691           0 :     ImpSetCreateParams(rStat);
     692           0 :     return true;
     693             : }
     694             : 
     695           0 : bool SdrCircObj::MovCreate(SdrDragStat& rStat)
     696             : {
     697           0 :     ImpSetCreateParams(rStat);
     698           0 :     ImpCircUser* pU=static_cast<ImpCircUser*>(rStat.GetUser());
     699           0 :     rStat.SetActionRect(pU->aR);
     700           0 :     aRect=pU->aR; // for ObjName
     701           0 :     ImpJustifyRect(aRect);
     702           0 :     nStartWink=pU->nStart;
     703           0 :     nEndWink=pU->nEnd;
     704           0 :     SetBoundRectDirty();
     705           0 :     bSnapRectDirty=true;
     706           0 :     SetXPolyDirty();
     707             : 
     708             :     // #i103058# push current angle settings to ItemSet to
     709             :     // allow FullDrag visualisation
     710           0 :     if(rStat.GetPointAnz() >= 4)
     711             :     {
     712           0 :         ImpSetCircInfoToAttr();
     713             :     }
     714             : 
     715           0 :     return true;
     716             : }
     717             : 
     718           0 : bool SdrCircObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
     719             : {
     720           0 :     ImpSetCreateParams(rStat);
     721           0 :     ImpCircUser* pU=static_cast<ImpCircUser*>(rStat.GetUser());
     722           0 :     bool bRet = false;
     723           0 :     if (eCmd==SDRCREATE_FORCEEND && rStat.GetPointAnz()<4) meCircleKind=OBJ_CIRC;
     724           0 :     if (meCircleKind==OBJ_CIRC) {
     725           0 :         bRet=rStat.GetPointAnz()>=2;
     726           0 :         if (bRet) {
     727           0 :             aRect=pU->aR;
     728           0 :             ImpJustifyRect(aRect);
     729             :         }
     730             :     } else {
     731           0 :         rStat.SetNoSnap(rStat.GetPointAnz()>=2);
     732           0 :         rStat.SetOrtho4Possible(rStat.GetPointAnz()<2);
     733           0 :         bRet=rStat.GetPointAnz()>=4;
     734           0 :         if (bRet) {
     735           0 :             aRect=pU->aR;
     736           0 :             ImpJustifyRect(aRect);
     737           0 :             nStartWink=pU->nStart;
     738           0 :             nEndWink=pU->nEnd;
     739             :         }
     740             :     }
     741           0 :     bClosedObj=meCircleKind!=OBJ_CARC;
     742           0 :     SetRectsDirty();
     743           0 :     SetXPolyDirty();
     744           0 :     ImpSetCircInfoToAttr();
     745           0 :     if (bRet) {
     746           0 :         delete pU;
     747           0 :         rStat.SetUser(NULL);
     748             :     }
     749           0 :     return bRet;
     750             : }
     751             : 
     752           0 : void SdrCircObj::BrkCreate(SdrDragStat& rStat)
     753             : {
     754           0 :     ImpCircUser* pU=static_cast<ImpCircUser*>(rStat.GetUser());
     755           0 :     delete pU;
     756           0 :     rStat.SetUser(NULL);
     757           0 : }
     758             : 
     759           0 : bool SdrCircObj::BckCreate(SdrDragStat& rStat)
     760             : {
     761           0 :     rStat.SetNoSnap(rStat.GetPointAnz()>=3);
     762           0 :     rStat.SetOrtho4Possible(rStat.GetPointAnz()<3);
     763           0 :     return meCircleKind!=OBJ_CIRC;
     764             : }
     765             : 
     766           0 : basegfx::B2DPolyPolygon SdrCircObj::TakeCreatePoly(const SdrDragStat& rDrag) const
     767             : {
     768           0 :     const ImpCircUser* pU = static_cast<const ImpCircUser*>(rDrag.GetUser());
     769             : 
     770           0 :     if(rDrag.GetPointAnz() < 4L)
     771             :     {
     772             :         // force to OBJ_CIRC to get full visualisation
     773           0 :         basegfx::B2DPolyPolygon aRetval(ImpCalcXPolyCirc(OBJ_CIRC, pU->aR, pU->nStart, pU->nEnd));
     774             : 
     775           0 :         if(3L == rDrag.GetPointAnz())
     776             :         {
     777             :             // add edge to first point on ellipse
     778           0 :             basegfx::B2DPolygon aNew;
     779             : 
     780           0 :             aNew.append(basegfx::B2DPoint(pU->aCenter.X(), pU->aCenter.Y()));
     781           0 :             aNew.append(basegfx::B2DPoint(pU->aP1.X(), pU->aP1.Y()));
     782           0 :             aRetval.append(aNew);
     783             :         }
     784             : 
     785           0 :         return aRetval;
     786             :     }
     787             :     else
     788             :     {
     789           0 :         return basegfx::B2DPolyPolygon(ImpCalcXPolyCirc(meCircleKind, pU->aR, pU->nStart, pU->nEnd));
     790             :     }
     791             : }
     792             : 
     793           0 : Pointer SdrCircObj::GetCreatePointer() const
     794             : {
     795           0 :     switch (meCircleKind) {
     796           0 :         case OBJ_CIRC: return Pointer(POINTER_DRAW_ELLIPSE);
     797           0 :         case OBJ_SECT: return Pointer(POINTER_DRAW_PIE);
     798           0 :         case OBJ_CARC: return Pointer(POINTER_DRAW_ARC);
     799           0 :         case OBJ_CCUT: return Pointer(POINTER_DRAW_CIRCLECUT);
     800           0 :         default: break;
     801             :     } // switch
     802           0 :     return Pointer(POINTER_CROSS);
     803             : }
     804             : 
     805         184 : void SdrCircObj::NbcMove(const Size& aSiz)
     806             : {
     807         184 :     MoveRect(aRect,aSiz);
     808         184 :     MoveRect(aOutRect,aSiz);
     809         184 :     MoveRect(maSnapRect,aSiz);
     810         184 :     SetXPolyDirty();
     811         184 :     SetRectsDirty(true);
     812         184 : }
     813             : 
     814          10 : void SdrCircObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
     815             : {
     816          10 :     long nWink0=aGeo.nRotationAngle;
     817          10 :     bool bNoShearRota=(aGeo.nRotationAngle==0 && aGeo.nShearAngle==0);
     818          10 :     SdrTextObj::NbcResize(rRef,xFact,yFact);
     819          10 :     bNoShearRota|=(aGeo.nRotationAngle==0 && aGeo.nShearAngle==0);
     820          10 :     if (meCircleKind!=OBJ_CIRC) {
     821          10 :         bool bXMirr=(xFact.GetNumerator()<0) != (xFact.GetDenominator()<0);
     822          10 :         bool bYMirr=(yFact.GetNumerator()<0) != (yFact.GetDenominator()<0);
     823          10 :         if (bXMirr || bYMirr) {
     824             :             // At bXMirr!=bYMirr we should actually swap both line ends.
     825             :             // That, however, is pretty bad (because of forced "hard" formatting).
     826             :             // Alternatively, we could implement a bMirrored flag (maybe even
     827             :             // a more general one, e. g. for mirrored text, ...).
     828           0 :             long nS0=nStartWink;
     829           0 :             long nE0=nEndWink;
     830           0 :             if (bNoShearRota) {
     831             :                 // the RectObj already mirrors at VMirror because of a 180deg rotation
     832           0 :                 if (! (bXMirr && bYMirr)) {
     833           0 :                     long nTmp=nS0;
     834           0 :                     nS0=18000-nE0;
     835           0 :                     nE0=18000-nTmp;
     836             :                 }
     837             :             } else { // mirror contorted ellipses
     838           0 :                 if (bXMirr!=bYMirr) {
     839           0 :                     nS0+=nWink0;
     840           0 :                     nE0+=nWink0;
     841           0 :                     if (bXMirr) {
     842           0 :                         long nTmp=nS0;
     843           0 :                         nS0=18000-nE0;
     844           0 :                         nE0=18000-nTmp;
     845             :                     }
     846           0 :                     if (bYMirr) {
     847           0 :                         long nTmp=nS0;
     848           0 :                         nS0=-nE0;
     849           0 :                         nE0=-nTmp;
     850             :                     }
     851           0 :                     nS0-=aGeo.nRotationAngle;
     852           0 :                     nE0-=aGeo.nRotationAngle;
     853             :                 }
     854             :             }
     855           0 :             long nWinkDif=nE0-nS0;
     856           0 :             nStartWink=NormAngle360(nS0);
     857           0 :             nEndWink  =NormAngle360(nE0);
     858           0 :             if (nWinkDif==36000) nEndWink+=nWinkDif; // full circle
     859             :         }
     860             :     }
     861          10 :     SetXPolyDirty();
     862          10 :     ImpSetCircInfoToAttr();
     863          10 : }
     864             : 
     865           0 : void SdrCircObj::NbcShear(const Point& rRef, long nWink, double tn, bool bVShear)
     866             : {
     867           0 :     SdrTextObj::NbcShear(rRef,nWink,tn,bVShear);
     868           0 :     SetXPolyDirty();
     869           0 :     ImpSetCircInfoToAttr();
     870           0 : }
     871             : 
     872           0 : void SdrCircObj::NbcMirror(const Point& rRef1, const Point& rRef2)
     873             : {
     874           0 :     bool bFreeMirr=meCircleKind!=OBJ_CIRC;
     875           0 :     Point aTmpPt1;
     876           0 :     Point aTmpPt2;
     877           0 :     if (bFreeMirr) { // some preparations for using an arbitrary axis of reflection
     878           0 :         Point aCenter(aRect.Center());
     879           0 :         long nWdt=aRect.GetWidth()-1;
     880           0 :         long nHgt=aRect.GetHeight()-1;
     881           0 :         long nMaxRad=((nWdt>nHgt ? nWdt : nHgt)+1) /2;
     882             :         double a;
     883             :         // starting point
     884           0 :         a=nStartWink*nPi180;
     885           0 :         aTmpPt1=Point(Round(cos(a)*nMaxRad),-Round(sin(a)*nMaxRad));
     886           0 :         if (nWdt==0) aTmpPt1.X()=0;
     887           0 :         if (nHgt==0) aTmpPt1.Y()=0;
     888           0 :         aTmpPt1+=aCenter;
     889             :         // finishing point
     890           0 :         a=nEndWink*nPi180;
     891           0 :         aTmpPt2=Point(Round(cos(a)*nMaxRad),-Round(sin(a)*nMaxRad));
     892           0 :         if (nWdt==0) aTmpPt2.X()=0;
     893           0 :         if (nHgt==0) aTmpPt2.Y()=0;
     894           0 :         aTmpPt2+=aCenter;
     895           0 :         if (aGeo.nRotationAngle!=0) {
     896           0 :             RotatePoint(aTmpPt1,aRect.TopLeft(),aGeo.nSin,aGeo.nCos);
     897           0 :             RotatePoint(aTmpPt2,aRect.TopLeft(),aGeo.nSin,aGeo.nCos);
     898             :         }
     899           0 :         if (aGeo.nShearAngle!=0) {
     900           0 :             ShearPoint(aTmpPt1,aRect.TopLeft(),aGeo.nTan);
     901           0 :             ShearPoint(aTmpPt2,aRect.TopLeft(),aGeo.nTan);
     902             :         }
     903             :     }
     904           0 :     SdrTextObj::NbcMirror(rRef1,rRef2);
     905           0 :     if (meCircleKind!=OBJ_CIRC) { // adapt starting and finishing angle
     906           0 :         MirrorPoint(aTmpPt1,rRef1,rRef2);
     907           0 :         MirrorPoint(aTmpPt2,rRef1,rRef2);
     908             :         // unrotate:
     909           0 :         if (aGeo.nRotationAngle!=0) {
     910           0 :             RotatePoint(aTmpPt1,aRect.TopLeft(),-aGeo.nSin,aGeo.nCos); // -sin for reversion
     911           0 :             RotatePoint(aTmpPt2,aRect.TopLeft(),-aGeo.nSin,aGeo.nCos); // -sin for reversion
     912             :         }
     913             :         // unshear:
     914           0 :         if (aGeo.nShearAngle!=0) {
     915           0 :             ShearPoint(aTmpPt1,aRect.TopLeft(),-aGeo.nTan); // -tan for reversion
     916           0 :             ShearPoint(aTmpPt2,aRect.TopLeft(),-aGeo.nTan); // -tan for reversion
     917             :         }
     918           0 :         Point aCenter(aRect.Center());
     919           0 :         aTmpPt1-=aCenter;
     920           0 :         aTmpPt2-=aCenter;
     921             :         // because it's mirrored, the angles are swapped, too
     922           0 :         nStartWink=GetAngle(aTmpPt2);
     923           0 :         nEndWink  =GetAngle(aTmpPt1);
     924           0 :         long nWinkDif=nEndWink-nStartWink;
     925           0 :         nStartWink=NormAngle360(nStartWink);
     926           0 :         nEndWink  =NormAngle360(nEndWink);
     927           0 :         if (nWinkDif==36000) nEndWink+=nWinkDif; // full circle
     928             :     }
     929           0 :     SetXPolyDirty();
     930           0 :     ImpSetCircInfoToAttr();
     931           0 : }
     932             : 
     933           0 : SdrObjGeoData* SdrCircObj::NewGeoData() const
     934             : {
     935           0 :     return new SdrCircObjGeoData;
     936             : }
     937             : 
     938           0 : void SdrCircObj::SaveGeoData(SdrObjGeoData& rGeo) const
     939             : {
     940           0 :     SdrRectObj::SaveGeoData(rGeo);
     941           0 :     SdrCircObjGeoData& rCGeo=static_cast<SdrCircObjGeoData&>(rGeo);
     942           0 :     rCGeo.nStartWink=nStartWink;
     943           0 :     rCGeo.nEndWink  =nEndWink;
     944           0 : }
     945             : 
     946           0 : void SdrCircObj::RestGeoData(const SdrObjGeoData& rGeo)
     947             : {
     948           0 :     SdrRectObj::RestGeoData(rGeo);
     949           0 :     const SdrCircObjGeoData& rCGeo=static_cast<const SdrCircObjGeoData&>(rGeo);
     950           0 :     nStartWink=rCGeo.nStartWink;
     951           0 :     nEndWink  =rCGeo.nEndWink;
     952           0 :     SetXPolyDirty();
     953           0 :     ImpSetCircInfoToAttr();
     954           0 : }
     955             : 
     956           0 : void Union(Rectangle& rR, const Point& rP)
     957             : {
     958           0 :     if (rP.X()<rR.Left  ()) rR.Left  ()=rP.X();
     959           0 :     if (rP.X()>rR.Right ()) rR.Right ()=rP.X();
     960           0 :     if (rP.Y()<rR.Top   ()) rR.Top   ()=rP.Y();
     961           0 :     if (rP.Y()>rR.Bottom()) rR.Bottom()=rP.Y();
     962           0 : }
     963             : 
     964         125 : void SdrCircObj::TakeUnrotatedSnapRect(Rectangle& rRect) const
     965             : {
     966         125 :     rRect=aRect;
     967         125 :     if (meCircleKind!=OBJ_CIRC) {
     968           0 :         const Point aPntStart(GetWinkPnt(aRect,nStartWink));
     969           0 :         const Point aPntEnd(GetWinkPnt(aRect,nEndWink));
     970           0 :         long a=nStartWink;
     971           0 :         long e=nEndWink;
     972           0 :         rRect.Left  ()=aRect.Right();
     973           0 :         rRect.Right ()=aRect.Left();
     974           0 :         rRect.Top   ()=aRect.Bottom();
     975           0 :         rRect.Bottom()=aRect.Top();
     976           0 :         Union(rRect,aPntStart);
     977           0 :         Union(rRect,aPntEnd);
     978           0 :         if ((a<=18000 && e>=18000) || (a>e && (a<=18000 || e>=18000))) {
     979           0 :             Union(rRect,aRect.LeftCenter());
     980             :         }
     981           0 :         if ((a<=27000 && e>=27000) || (a>e && (a<=27000 || e>=27000))) {
     982           0 :             Union(rRect,aRect.BottomCenter());
     983             :         }
     984           0 :         if (a>e) {
     985           0 :             Union(rRect,aRect.RightCenter());
     986             :         }
     987           0 :         if ((a<=9000 && e>=9000) || (a>e && (a<=9000 || e>=9000))) {
     988           0 :             Union(rRect,aRect.TopCenter());
     989             :         }
     990           0 :         if (meCircleKind==OBJ_SECT) {
     991           0 :             Union(rRect,aRect.Center());
     992             :         }
     993           0 :         if (aGeo.nRotationAngle!=0) {
     994           0 :             Point aDst(rRect.TopLeft());
     995           0 :             aDst-=aRect.TopLeft();
     996           0 :             Point aDst0(aDst);
     997           0 :             RotatePoint(aDst,Point(),aGeo.nSin,aGeo.nCos);
     998           0 :             aDst-=aDst0;
     999           0 :             rRect.Move(aDst.X(),aDst.Y());
    1000             :         }
    1001             :     }
    1002         125 :     if (aGeo.nShearAngle!=0) {
    1003           0 :         long nDst=Round((rRect.Bottom()-rRect.Top())*aGeo.nTan);
    1004           0 :         if (aGeo.nShearAngle>0) {
    1005           0 :             Point aRef(rRect.TopLeft());
    1006           0 :             rRect.Left()-=nDst;
    1007           0 :             Point aTmpPt(rRect.TopLeft());
    1008           0 :             RotatePoint(aTmpPt,aRef,aGeo.nSin,aGeo.nCos);
    1009           0 :             aTmpPt-=rRect.TopLeft();
    1010           0 :             rRect.Move(aTmpPt.X(),aTmpPt.Y());
    1011             :         } else {
    1012           0 :             rRect.Right()-=nDst;
    1013             :         }
    1014             :     }
    1015         125 : }
    1016             : 
    1017         247 : void SdrCircObj::RecalcSnapRect()
    1018             : {
    1019         247 :     if (PaintNeedsXPolyCirc()) {
    1020         122 :         maSnapRect=GetXPoly().GetBoundRect();
    1021             :     } else {
    1022         125 :         TakeUnrotatedSnapRect(maSnapRect);
    1023             :     }
    1024         247 : }
    1025             : 
    1026         256 : void SdrCircObj::NbcSetSnapRect(const Rectangle& rRect)
    1027             : {
    1028         256 :     if (aGeo.nRotationAngle!=0 || aGeo.nShearAngle!=0 || meCircleKind!=OBJ_CIRC) {
    1029          10 :         Rectangle aSR0(GetSnapRect());
    1030          10 :         long nWdt0=aSR0.Right()-aSR0.Left();
    1031          10 :         long nHgt0=aSR0.Bottom()-aSR0.Top();
    1032          10 :         long nWdt1=rRect.Right()-rRect.Left();
    1033          10 :         long nHgt1=rRect.Bottom()-rRect.Top();
    1034          10 :         NbcResize(maSnapRect.TopLeft(),Fraction(nWdt1,nWdt0),Fraction(nHgt1,nHgt0));
    1035          10 :         NbcMove(Size(rRect.Left()-aSR0.Left(),rRect.Top()-aSR0.Top()));
    1036             :     } else {
    1037         246 :         aRect=rRect;
    1038         246 :         ImpJustifyRect(aRect);
    1039             :     }
    1040         256 :     SetRectsDirty();
    1041         256 :     SetXPolyDirty();
    1042         256 :     ImpSetCircInfoToAttr();
    1043         256 : }
    1044             : 
    1045           0 : sal_uInt32 SdrCircObj::GetSnapPointCount() const
    1046             : {
    1047           0 :     if (meCircleKind==OBJ_CIRC) {
    1048           0 :         return 1L;
    1049             :     } else {
    1050           0 :         return 3L;
    1051             :     }
    1052             : }
    1053             : 
    1054           0 : Point SdrCircObj::GetSnapPoint(sal_uInt32 i) const
    1055             : {
    1056           0 :     switch (i) {
    1057           0 :         case 1 : return GetWinkPnt(aRect,nStartWink);
    1058           0 :         case 2 : return GetWinkPnt(aRect,nEndWink);
    1059           0 :         default: return aRect.Center();
    1060             :     }
    1061             : }
    1062             : 
    1063         332 : void SdrCircObj::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
    1064             : {
    1065         332 :     SetXPolyDirty();
    1066         332 :     SdrRectObj::Notify(rBC,rHint);
    1067         332 :     ImpSetAttrToCircInfo();
    1068         332 : }
    1069             : 
    1070             : 
    1071             : 
    1072        1476 : void SdrCircObj::ImpSetAttrToCircInfo()
    1073             : {
    1074        1476 :     const SfxItemSet& rSet = GetObjectItemSet();
    1075        1476 :     SdrCircKind eNewKindA = static_cast<const SdrCircKindItem&>(rSet.Get(SDRATTR_CIRCKIND)).GetValue();
    1076        1476 :     SdrObjKind eNewKind = meCircleKind;
    1077             : 
    1078        1476 :     if(eNewKindA == SDRCIRC_FULL)
    1079         926 :         eNewKind = OBJ_CIRC;
    1080         550 :     else if(eNewKindA == SDRCIRC_SECT)
    1081         188 :         eNewKind = OBJ_SECT;
    1082         362 :     else if(eNewKindA == SDRCIRC_ARC)
    1083         144 :         eNewKind = OBJ_CARC;
    1084         218 :     else if(eNewKindA == SDRCIRC_CUT)
    1085         218 :         eNewKind = OBJ_CCUT;
    1086             : 
    1087        1476 :     sal_Int32 nNewStart = static_cast<const SdrAngleItem&>(rSet.Get(SDRATTR_CIRCSTARTANGLE)).GetValue();
    1088        1476 :     sal_Int32 nNewEnd = static_cast<const SdrAngleItem&>(rSet.Get(SDRATTR_CIRCENDANGLE)).GetValue();
    1089             : 
    1090        1476 :     bool bKindChg = meCircleKind != eNewKind;
    1091        1476 :     bool bWinkChg = nNewStart != nStartWink || nNewEnd != nEndWink;
    1092             : 
    1093        1476 :     if(bKindChg || bWinkChg)
    1094             :     {
    1095         246 :         meCircleKind = eNewKind;
    1096         246 :         nStartWink = nNewStart;
    1097         246 :         nEndWink = nNewEnd;
    1098             : 
    1099         246 :         if(bKindChg || (meCircleKind != OBJ_CIRC && bWinkChg))
    1100             :         {
    1101         246 :             SetXPolyDirty();
    1102         246 :             SetRectsDirty();
    1103             :         }
    1104             :     }
    1105        1476 : }
    1106             : 
    1107         266 : void SdrCircObj::ImpSetCircInfoToAttr()
    1108             : {
    1109         266 :     SdrCircKind eNewKindA = SDRCIRC_FULL;
    1110         266 :     const SfxItemSet& rSet = GetObjectItemSet();
    1111             : 
    1112         266 :     if(meCircleKind == OBJ_SECT)
    1113           0 :         eNewKindA = SDRCIRC_SECT;
    1114         266 :     else if(meCircleKind == OBJ_CARC)
    1115           0 :         eNewKindA = SDRCIRC_ARC;
    1116         266 :     else if(meCircleKind == OBJ_CCUT)
    1117          20 :         eNewKindA = SDRCIRC_CUT;
    1118             : 
    1119         266 :     SdrCircKind eOldKindA = static_cast<const SdrCircKindItem&>(rSet.Get(SDRATTR_CIRCKIND)).GetValue();
    1120         266 :     sal_Int32 nOldStartWink = static_cast<const SdrAngleItem&>(rSet.Get(SDRATTR_CIRCSTARTANGLE)).GetValue();
    1121         266 :     sal_Int32 nOldEndWink = static_cast<const SdrAngleItem&>(rSet.Get(SDRATTR_CIRCENDANGLE)).GetValue();
    1122             : 
    1123         266 :     if(eNewKindA != eOldKindA || nStartWink != nOldStartWink || nEndWink != nOldEndWink)
    1124             :     {
    1125             :         // since SetItem() implicitly calls ImpSetAttrToCircInfo()
    1126             :         // setting the item directly is necessary here.
    1127           0 :         if(eNewKindA != eOldKindA)
    1128             :         {
    1129           0 :             GetProperties().SetObjectItemDirect(SdrCircKindItem(eNewKindA));
    1130             :         }
    1131             : 
    1132           0 :         if(nStartWink != nOldStartWink)
    1133             :         {
    1134           0 :             GetProperties().SetObjectItemDirect(makeSdrCircStartAngleItem(nStartWink));
    1135             :         }
    1136             : 
    1137           0 :         if(nEndWink != nOldEndWink)
    1138             :         {
    1139           0 :             GetProperties().SetObjectItemDirect(makeSdrCircEndAngleItem(nEndWink));
    1140             :         }
    1141             : 
    1142           0 :         SetXPolyDirty();
    1143           0 :         ImpSetAttrToCircInfo();
    1144             :     }
    1145         266 : }
    1146             : 
    1147           6 : SdrObject* SdrCircObj::DoConvertToPolyObj(bool bBezier, bool bAddText) const
    1148             : {
    1149           6 :     const bool bFill(OBJ_CARC == meCircleKind ? sal_False : sal_True);
    1150           6 :     const basegfx::B2DPolygon aCircPolygon(ImpCalcXPolyCirc(meCircleKind, aRect, nStartWink, nEndWink));
    1151           6 :     SdrObject* pRet = ImpConvertMakeObj(basegfx::B2DPolyPolygon(aCircPolygon), bFill, bBezier);
    1152             : 
    1153           6 :     if(bAddText)
    1154             :     {
    1155           6 :         pRet = ImpConvertAddText(pRet, bBezier);
    1156             :     }
    1157             : 
    1158           6 :     return pRet;
    1159         651 : }
    1160             : 
    1161             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10