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