xref: /aoo41x/main/svx/source/svdraw/svdopath.cxx (revision da72173f)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svx.hxx"
26 
27 #include <tools/bigint.hxx>
28 #include <svx/svdopath.hxx>
29 #include <math.h>
30 #include <svx/xpool.hxx>
31 #include <svx/xpoly.hxx>
32 #include <svx/svdattr.hxx>
33 #include <svx/svdtrans.hxx>
34 #include <svx/svdetc.hxx>
35 #include <svx/svddrag.hxx>
36 #include <svx/svdmodel.hxx>
37 #include <svx/svdpage.hxx>
38 #include <svx/svdhdl.hxx>
39 #include <svx/svdview.hxx>  // fuer MovCreate bei Freihandlinien
40 #include "svx/svdglob.hxx"  // Stringcache
41 #include "svx/svdstr.hrc"   // Objektname
42 
43 #ifdef _MSC_VER
44 #pragma optimize ("",off)
45 #pragma warning(disable: 4748) // "... because optimizations are disabled ..."
46 #endif
47 
48 #include <svx/xlnwtit.hxx>
49 #include <svx/xlnclit.hxx>
50 #include <svx/xflclit.hxx>
51 #include <svx/svdogrp.hxx>
52 #include <svx/polypolygoneditor.hxx>
53 #include <svx/xlntrit.hxx>
54 #include <vcl/salbtype.hxx>		// FRound
55 #include "svdoimp.hxx"
56 #include <svx/sdr/contact/viewcontactofsdrpathobj.hxx>
57 #include <basegfx/matrix/b2dhommatrix.hxx>
58 
59 // #104018# replace macros above with type-safe methods
ImplTwipsToMM(sal_Int32 nVal)60 inline sal_Int32 ImplTwipsToMM(sal_Int32 nVal) { return ((nVal * 127 + 36) / 72); }
ImplMMToTwips(sal_Int32 nVal)61 inline sal_Int32 ImplMMToTwips(sal_Int32 nVal) { return ((nVal * 72 + 63) / 127); }
ImplTwipsToMM(sal_Int64 nVal)62 inline sal_Int64 ImplTwipsToMM(sal_Int64 nVal) { return ((nVal * 127 + 36) / 72); }
ImplMMToTwips(sal_Int64 nVal)63 inline sal_Int64 ImplMMToTwips(sal_Int64 nVal) { return ((nVal * 72 + 63) / 127); }
ImplTwipsToMM(double fVal)64 inline double ImplTwipsToMM(double fVal) { return (fVal * (127.0 / 72.0)); }
ImplMMToTwips(double fVal)65 inline double ImplMMToTwips(double fVal) { return (fVal * (72.0 / 127.0)); }
66 #include <basegfx/point/b2dpoint.hxx>
67 #include <basegfx/polygon/b2dpolypolygontools.hxx>
68 #include <basegfx/matrix/b2dhommatrix.hxx>
69 #include <basegfx/range/b2drange.hxx>
70 #include <basegfx/curve/b2dcubicbezier.hxx>
71 #include <basegfx/polygon/b2dpolygontools.hxx>
72 #include <svx/sdr/attribute/sdrtextattribute.hxx>
73 #include <svx/sdr/primitive2d/sdrattributecreator.hxx>
74 #include <basegfx/matrix/b2dhommatrixtools.hxx>
75 #include <svx/sdr/attribute/sdrformtextattribute.hxx>
76 
77 using namespace sdr;
78 
GetPrevPnt(sal_uInt16 nPnt,sal_uInt16 nPntMax,FASTBOOL bClosed)79 inline sal_uInt16 GetPrevPnt(sal_uInt16 nPnt, sal_uInt16 nPntMax, FASTBOOL bClosed)
80 {
81 	if (nPnt>0) {
82 		nPnt--;
83 	} else {
84 		nPnt=nPntMax;
85 		if (bClosed) nPnt--;
86 	}
87 	return nPnt;
88 }
89 
GetNextPnt(sal_uInt16 nPnt,sal_uInt16 nPntMax,FASTBOOL bClosed)90 inline sal_uInt16 GetNextPnt(sal_uInt16 nPnt, sal_uInt16 nPntMax, FASTBOOL bClosed)
91 {
92 	nPnt++;
93 	if (nPnt>nPntMax || (bClosed && nPnt>=nPntMax)) nPnt=0;
94 	return nPnt;
95 }
96 
97 struct ImpSdrPathDragData  : public SdrDragStatUserData
98 {
99 	XPolygon					aXP;            // Ausschnitt aud dem Originalpolygon
100 	FASTBOOL					bValid;         // sal_False = zu wenig Punkte
101 	FASTBOOL					bClosed;        // geschlossenes Objekt?
102 	sal_uInt16						nPoly;          // Nummer des Polygons im PolyPolygon
103 	sal_uInt16						nPnt;           // Punktnummer innerhalb des obigen Polygons
104 	sal_uInt16						nPntAnz;        // Punktanzahl des Polygons
105 	sal_uInt16						nPntMax;        // Maximaler Index
106 	FASTBOOL					bBegPnt;        // Gedraggter Punkt ist der Anfangspunkt einer Polyline
107 	FASTBOOL					bEndPnt;        // Gedraggter Punkt ist der Endpunkt einer Polyline
108 	sal_uInt16						nPrevPnt;       // Index des vorherigen Punkts
109 	sal_uInt16						nNextPnt;       // Index des naechsten Punkts
110 	FASTBOOL					bPrevIsBegPnt;  // Vorheriger Punkt ist Anfangspunkt einer Polyline
111 	FASTBOOL					bNextIsEndPnt;  // Folgepunkt ist Endpunkt einer Polyline
112 	sal_uInt16						nPrevPrevPnt;   // Index des vorvorherigen Punkts
113 	sal_uInt16						nNextNextPnt;   // Index des uebernaechsten Punkts
114 	FASTBOOL					bControl;       // Punkt ist ein Kontrollpunkt
115 	FASTBOOL					bIsPrevControl; // Punkt ist Kontrollpunkt vor einem Stuetzpunkt
116 	FASTBOOL					bIsNextControl; // Punkt ist Kontrollpunkt hinter einem Stuetzpunkt
117 	FASTBOOL					bPrevIsControl; // Falls nPnt ein StPnt: Davor ist ein Kontrollpunkt
118 	FASTBOOL					bNextIsControl; // Falls nPnt ein StPnt: Dahinter ist ein Kontrollpunkt
119 	sal_uInt16						nPrevPrevPnt0;
120 	sal_uInt16						nPrevPnt0;
121 	sal_uInt16						nPnt0;
122 	sal_uInt16						nNextPnt0;
123 	sal_uInt16						nNextNextPnt0;
124 	FASTBOOL					bEliminate;     // Punkt loeschen? (wird von MovDrag gesetzt)
125 
126 	// ##
127 	sal_Bool						mbMultiPointDrag;
128 	const XPolyPolygon			maOrig;
129 	XPolyPolygon				maMove;
130 	Container					maHandles;
131 
132 public:
133 	ImpSdrPathDragData(const SdrPathObj& rPO, const SdrHdl& rHdl, sal_Bool bMuPoDr, const SdrDragStat& rDrag);
134 	void ResetPoly(const SdrPathObj& rPO);
IsMultiPointDragImpSdrPathDragData135 	sal_Bool IsMultiPointDrag() const { return mbMultiPointDrag; }
136 };
137 
ImpSdrPathDragData(const SdrPathObj & rPO,const SdrHdl & rHdl,sal_Bool bMuPoDr,const SdrDragStat & rDrag)138 ImpSdrPathDragData::ImpSdrPathDragData(const SdrPathObj& rPO, const SdrHdl& rHdl, sal_Bool bMuPoDr, const SdrDragStat& rDrag)
139 :	aXP(5),
140 	mbMultiPointDrag(bMuPoDr),
141 	maOrig(rPO.GetPathPoly()),
142 	maHandles(0)
143 {
144 	if(mbMultiPointDrag)
145 	{
146 		const SdrMarkView& rMarkView = *rDrag.GetView();
147 		const SdrHdlList& rHdlList = rMarkView.GetHdlList();
148 		const sal_uInt32 nHdlCount = rHdlList.GetHdlCount();
149         const SdrObject* pInteractionObject(nHdlCount && rHdlList.GetHdl(0) ? rHdlList.GetHdl(0)->GetObj() : 0);
150 
151 		for(sal_uInt32 a(0); a < nHdlCount; a++)
152 		{
153 			SdrHdl* pTestHdl = rHdlList.GetHdl(a);
154 
155 			if(pTestHdl && pTestHdl->IsSelected() && pTestHdl->GetObj() == pInteractionObject)
156 			{
157 				maHandles.Insert(pTestHdl, CONTAINER_APPEND);
158 			}
159 		}
160 
161 		maMove = maOrig;
162 		bValid = sal_True;
163 	}
164 	else
165 	{
166 		bValid=sal_False;
167 		bClosed=rPO.IsClosed();          // geschlossenes Objekt?
168 		nPoly=(sal_uInt16)rHdl.GetPolyNum();            // Nummer des Polygons im PolyPolygon
169 		nPnt=(sal_uInt16)rHdl.GetPointNum();            // Punktnummer innerhalb des obigen Polygons
170 		const XPolygon aTmpXP(rPO.GetPathPoly().getB2DPolygon(nPoly));
171 		nPntAnz=aTmpXP.GetPointCount();        // Punktanzahl des Polygons
172 		if (nPntAnz==0 || (bClosed && nPntAnz==1)) return; // min. 1Pt bei Line, min. 2 bei Polygon
173 		nPntMax=nPntAnz-1;                  // Maximaler Index
174 		bBegPnt=!bClosed && nPnt==0;        // Gedraggter Punkt ist der Anfangspunkt einer Polyline
175 		bEndPnt=!bClosed && nPnt==nPntMax;  // Gedraggter Punkt ist der Endpunkt einer Polyline
176 		if (bClosed && nPntAnz<=3) {        // Falls Polygon auch nur eine Linie ist
177 			bBegPnt=(nPntAnz<3) || nPnt==0;
178 			bEndPnt=(nPntAnz<3) || nPnt==nPntMax-1;
179 		}
180 		nPrevPnt=nPnt;                      // Index des vorherigen Punkts
181 		nNextPnt=nPnt;                      // Index des naechsten Punkts
182 		if (!bBegPnt) nPrevPnt=GetPrevPnt(nPnt,nPntMax,bClosed);
183 		if (!bEndPnt) nNextPnt=GetNextPnt(nPnt,nPntMax,bClosed);
184 		bPrevIsBegPnt=bBegPnt || (!bClosed && nPrevPnt==0);
185 		bNextIsEndPnt=bEndPnt || (!bClosed && nNextPnt==nPntMax);
186 		nPrevPrevPnt=nPnt;                  // Index des vorvorherigen Punkts
187 		nNextNextPnt=nPnt;                  // Index des uebernaechsten Punkts
188 		if (!bPrevIsBegPnt) nPrevPrevPnt=GetPrevPnt(nPrevPnt,nPntMax,bClosed);
189 		if (!bNextIsEndPnt) nNextNextPnt=GetNextPnt(nNextPnt,nPntMax,bClosed);
190 		bControl=rHdl.IsPlusHdl();          // Punkt ist ein Kontrollpunkt
191 		bIsPrevControl=sal_False;               // Punkt ist Kontrollpunkt vor einem Stuetzpunkt
192 		bIsNextControl=sal_False;               // Punkt ist Kontrollpunkt hinter einem Stuetzpunkt
193 		bPrevIsControl=sal_False;               // Falls nPnt ein StPnt: Davor ist ein Kontrollpunkt
194 		bNextIsControl=sal_False;               // Falls nPnt ein StPnt: Dahinter ist ein Kontrollpunkt
195 		if (bControl) {
196 			bIsPrevControl=aTmpXP.IsControl(nPrevPnt);
197 			bIsNextControl=!bIsPrevControl;
198 		} else {
199 			bPrevIsControl=!bBegPnt && !bPrevIsBegPnt && aTmpXP.GetFlags(nPrevPnt)==XPOLY_CONTROL;
200 			bNextIsControl=!bEndPnt && !bNextIsEndPnt && aTmpXP.GetFlags(nNextPnt)==XPOLY_CONTROL;
201 		}
202 		nPrevPrevPnt0=nPrevPrevPnt;
203 		nPrevPnt0    =nPrevPnt;
204 		nPnt0        =nPnt;
205 		nNextPnt0    =nNextPnt;
206 		nNextNextPnt0=nNextNextPnt;
207 		nPrevPrevPnt=0;
208 		nPrevPnt=1;
209 		nPnt=2;
210 		nNextPnt=3;
211 		nNextNextPnt=4;
212 		bEliminate=sal_False;
213 		ResetPoly(rPO);
214 		bValid=sal_True;
215 	}
216 }
217 
ResetPoly(const SdrPathObj & rPO)218 void ImpSdrPathDragData::ResetPoly(const SdrPathObj& rPO)
219 {
220 	const XPolygon aTmpXP(rPO.GetPathPoly().getB2DPolygon(nPoly));
221 	aXP[0]=aTmpXP[nPrevPrevPnt0];  aXP.SetFlags(0,aTmpXP.GetFlags(nPrevPrevPnt0));
222 	aXP[1]=aTmpXP[nPrevPnt0];      aXP.SetFlags(1,aTmpXP.GetFlags(nPrevPnt0));
223 	aXP[2]=aTmpXP[nPnt0];          aXP.SetFlags(2,aTmpXP.GetFlags(nPnt0));
224 	aXP[3]=aTmpXP[nNextPnt0];      aXP.SetFlags(3,aTmpXP.GetFlags(nNextPnt0));
225 	aXP[4]=aTmpXP[nNextNextPnt0];  aXP.SetFlags(4,aTmpXP.GetFlags(nNextNextPnt0));
226 }
227 
228 /*************************************************************************/
229 
230 struct ImpPathCreateUser  : public SdrDragStatUserData
231 {
232 	Point					aBezControl0;
233 	Point					aBezStart;
234 	Point					aBezCtrl1;
235 	Point					aBezCtrl2;
236 	Point					aBezEnd;
237 	Point					aCircStart;
238 	Point					aCircEnd;
239 	Point					aCircCenter;
240 	Point					aLineStart;
241 	Point					aLineEnd;
242 	Point					aRectP1;
243 	Point					aRectP2;
244 	Point					aRectP3;
245 	long					nCircRadius;
246 	long					nCircStWink;
247 	long					nCircRelWink;
248 	FASTBOOL				bBezier;
249 	FASTBOOL				bBezHasCtrl0;
250 	FASTBOOL				bCurve;
251 	FASTBOOL				bCircle;
252 	FASTBOOL				bAngleSnap;
253 	FASTBOOL				bLine;
254 	FASTBOOL				bLine90;
255 	FASTBOOL				bRect;
256 	FASTBOOL				bMixedCreate;
257 	sal_uInt16					nBezierStartPoint;
258 	SdrObjKind				eStartKind;
259 	SdrObjKind				eAktKind;
260 
261 public:
ImpPathCreateUserImpPathCreateUser262 	ImpPathCreateUser(): nCircRadius(0),nCircStWink(0),nCircRelWink(0),
263 		bBezier(sal_False),bBezHasCtrl0(sal_False),bCurve(sal_False),bCircle(sal_False),bAngleSnap(sal_False),bLine(sal_False),bLine90(sal_False),bRect(sal_False),
264 		bMixedCreate(sal_False),nBezierStartPoint(0),eStartKind(OBJ_NONE),eAktKind(OBJ_NONE) { }
265 
ResetFormFlagsImpPathCreateUser266 	void ResetFormFlags() { bBezier=sal_False; bCurve=sal_False; bCircle=sal_False; bLine=sal_False; bRect=sal_False; }
IsFormFlagImpPathCreateUser267 	FASTBOOL IsFormFlag() const { return bBezier || bCurve || bCircle || bLine || bRect; }
268 	XPolygon GetFormPoly() const;
269 	FASTBOOL CalcBezier(const Point& rP1, const Point& rP2, const Point& rDir, FASTBOOL bMouseDown);
270 	XPolygon GetBezierPoly() const;
271 	//int CalcCurve(const Point& rP1, const Point& rP2, const Point& rDir, SdrView* pView) { return sal_False; }
GetCurvePolyImpPathCreateUser272 	XPolygon GetCurvePoly() const { return XPolygon(); }
273 	FASTBOOL CalcCircle(const Point& rP1, const Point& rP2, const Point& rDir, SdrView* pView);
274 	XPolygon GetCirclePoly() const;
275 	FASTBOOL CalcLine(const Point& rP1, const Point& rP2, const Point& rDir, SdrView* pView);
276 	Point    CalcLine(const Point& rCsr, long nDirX, long nDirY, SdrView* pView) const;
277 	XPolygon GetLinePoly() const;
278 	FASTBOOL CalcRect(const Point& rP1, const Point& rP2, const Point& rDir, SdrView* pView);
279 	XPolygon GetRectPoly() const;
280 };
281 
GetFormPoly() const282 XPolygon ImpPathCreateUser::GetFormPoly() const
283 {
284 	if (bBezier) return GetBezierPoly();
285 	if (bCurve)  return GetCurvePoly();
286 	if (bCircle) return GetCirclePoly();
287 	if (bLine)   return GetLinePoly();
288 	if (bRect)   return GetRectPoly();
289 	return XPolygon();
290 }
291 
CalcBezier(const Point & rP1,const Point & rP2,const Point & rDir,FASTBOOL bMouseDown)292 FASTBOOL ImpPathCreateUser::CalcBezier(const Point& rP1, const Point& rP2, const Point& rDir, FASTBOOL bMouseDown)
293 {
294 	FASTBOOL bRet=sal_True;
295 	aBezStart=rP1;
296 	aBezCtrl1=rP1+rDir;
297 	aBezCtrl2=rP2;
298 
299 	// #i21479#
300 	// Also copy the end point when no end point is set yet
301 	if (!bMouseDown || (0L == aBezEnd.X() && 0L == aBezEnd.Y())) aBezEnd=rP2;
302 
303 	bBezier=bRet;
304 	return bRet;
305 }
306 
GetBezierPoly() const307 XPolygon ImpPathCreateUser::GetBezierPoly() const
308 {
309 	XPolygon aXP(4);
310 	aXP[0]=aBezStart; aXP.SetFlags(0,XPOLY_SMOOTH);
311 	aXP[1]=aBezCtrl1; aXP.SetFlags(1,XPOLY_CONTROL);
312 	aXP[2]=aBezCtrl2; aXP.SetFlags(2,XPOLY_CONTROL);
313 	aXP[3]=aBezEnd;
314 	return aXP;
315 }
316 
CalcCircle(const Point & rP1,const Point & rP2,const Point & rDir,SdrView * pView)317 FASTBOOL ImpPathCreateUser::CalcCircle(const Point& rP1, const Point& rP2, const Point& rDir, SdrView* pView)
318 {
319 	long nTangAngle=GetAngle(rDir);
320 	aCircStart=rP1;
321 	aCircEnd=rP2;
322 	aCircCenter=rP1;
323 	long dx=rP2.X()-rP1.X();
324 	long dy=rP2.Y()-rP1.Y();
325 	long dAngle=GetAngle(Point(dx,dy))-nTangAngle;
326 	dAngle=NormAngle360(dAngle);
327 	long nTmpAngle=NormAngle360(9000-dAngle);
328 	FASTBOOL bRet=nTmpAngle!=9000 && nTmpAngle!=27000;
329 	long nRad=0;
330 	if (bRet) {
331 		double cs=cos(nTmpAngle*nPi180);
332 		double nR=(double)GetLen(Point(dx,dy))/cs/2;
333 		nRad=Abs(Round(nR));
334 	}
335 	if (dAngle<18000) {
336 		nCircStWink=NormAngle360(nTangAngle-9000);
337 		nCircRelWink=NormAngle360(2*dAngle);
338 		aCircCenter.X()+=Round(nRad*cos((nTangAngle+9000)*nPi180));
339 		aCircCenter.Y()-=Round(nRad*sin((nTangAngle+9000)*nPi180));
340 	} else {
341 		nCircStWink=NormAngle360(nTangAngle+9000);
342 		nCircRelWink=-NormAngle360(36000-2*dAngle);
343 		aCircCenter.X()+=Round(nRad*cos((nTangAngle-9000)*nPi180));
344 		aCircCenter.Y()-=Round(nRad*sin((nTangAngle-9000)*nPi180));
345 	}
346 	bAngleSnap=pView!=NULL && pView->IsAngleSnapEnabled();
347 	if (bAngleSnap) {
348 		long nSA=pView->GetSnapAngle();
349 		if (nSA!=0) { // Winkelfang
350 			FASTBOOL bNeg=nCircRelWink<0;
351 			if (bNeg) nCircRelWink=-nCircRelWink;
352 			nCircRelWink+=nSA/2;
353 			nCircRelWink/=nSA;
354 			nCircRelWink*=nSA;
355 			nCircRelWink=NormAngle360(nCircRelWink);
356 			if (bNeg) nCircRelWink=-nCircRelWink;
357 		}
358 	}
359 	nCircRadius=nRad;
360 	if (nRad==0 || Abs(nCircRelWink)<5) bRet=sal_False;
361 	bCircle=bRet;
362 	return bRet;
363 }
364 
GetCirclePoly() const365 XPolygon ImpPathCreateUser::GetCirclePoly() const
366 {
367 	if (nCircRelWink>=0) {
368 		XPolygon aXP(aCircCenter,nCircRadius,nCircRadius,
369 					 sal_uInt16((nCircStWink+5)/10),sal_uInt16((nCircStWink+nCircRelWink+5)/10),sal_False);
370 		aXP[0]=aCircStart; aXP.SetFlags(0,XPOLY_SMOOTH);
371 		if (!bAngleSnap) aXP[aXP.GetPointCount()-1]=aCircEnd;
372 		return aXP;
373 	} else {
374 		XPolygon aXP(aCircCenter,nCircRadius,nCircRadius,
375 					 sal_uInt16(NormAngle360(nCircStWink+nCircRelWink+5)/10),sal_uInt16((nCircStWink+5)/10),sal_False);
376 		sal_uInt16 nAnz=aXP.GetPointCount();
377 		for (sal_uInt16 nNum=nAnz/2; nNum>0;) {
378 			nNum--; // XPoly Punktreihenfolge umkehren
379 			sal_uInt16 n2=nAnz-nNum-1;
380 			Point aPt(aXP[nNum]);
381 			aXP[nNum]=aXP[n2];
382 			aXP[n2]=aPt;
383 		}
384 		aXP[0]=aCircStart; aXP.SetFlags(0,XPOLY_SMOOTH);
385 		if (!bAngleSnap) aXP[aXP.GetPointCount()-1]=aCircEnd;
386 		return aXP;
387 	}
388 }
389 
CalcLine(const Point & aCsr,long nDirX,long nDirY,SdrView * pView) const390 Point ImpPathCreateUser::CalcLine(const Point& aCsr, long nDirX, long nDirY, SdrView* pView) const
391 {
392 	long x=aCsr.X(),x1=x,x2=x;
393 	long y=aCsr.Y(),y1=y,y2=y;
394 	FASTBOOL bHLin=nDirY==0;
395 	FASTBOOL bVLin=nDirX==0;
396 	if (bHLin) y=0;
397 	else if (bVLin) x=0;
398 	else {
399 		x1=BigMulDiv(y,nDirX,nDirY);
400 		y2=BigMulDiv(x,nDirY,nDirX);
401 		long l1=Abs(x1)+Abs(y1);
402 		long l2=Abs(x2)+Abs(y2);
403 		if ((l1<=l2) != (pView!=NULL && pView->IsBigOrtho())) {
404 			x=x1; y=y1;
405 		} else {
406 			x=x2; y=y2;
407 		}
408 	}
409 	return Point(x,y);
410 }
411 
CalcLine(const Point & rP1,const Point & rP2,const Point & rDir,SdrView * pView)412 FASTBOOL ImpPathCreateUser::CalcLine(const Point& rP1, const Point& rP2, const Point& rDir, SdrView* pView)
413 {
414 	aLineStart=rP1;
415 	aLineEnd=rP2;
416 	bLine90=sal_False;
417 	if (rP1==rP2 || (rDir.X()==0 && rDir.Y()==0)) { bLine=sal_False; return sal_False; }
418 	Point aTmpPt(rP2-rP1);
419 	long nDirX=rDir.X();
420 	long nDirY=rDir.Y();
421 	Point aP1(CalcLine(aTmpPt, nDirX, nDirY,pView)); aP1-=aTmpPt; long nQ1=Abs(aP1.X())+Abs(aP1.Y());
422 	Point aP2(CalcLine(aTmpPt, nDirY,-nDirX,pView)); aP2-=aTmpPt; long nQ2=Abs(aP2.X())+Abs(aP2.Y());
423 	if (pView!=NULL && pView->IsOrtho()) nQ1=0; // Ortho schaltet rechtwinklig aus
424 	bLine90=nQ1>2*nQ2;
425 	if (!bLine90) { // glatter Uebergang
426 		aLineEnd+=aP1;
427 	} else {          // rechtwinkliger Uebergang
428 		aLineEnd+=aP2;
429 	}
430 	bLine=sal_True;
431 	return sal_True;
432 }
433 
GetLinePoly() const434 XPolygon ImpPathCreateUser::GetLinePoly() const
435 {
436 	XPolygon aXP(2);
437 	aXP[0]=aLineStart; if (!bLine90) aXP.SetFlags(0,XPOLY_SMOOTH);
438 	aXP[1]=aLineEnd;
439 	return aXP;
440 }
441 
CalcRect(const Point & rP1,const Point & rP2,const Point & rDir,SdrView * pView)442 FASTBOOL ImpPathCreateUser::CalcRect(const Point& rP1, const Point& rP2, const Point& rDir, SdrView* pView)
443 {
444 	aRectP1=rP1;
445 	aRectP2=rP1;
446 	aRectP3=rP2;
447 	if (rP1==rP2 || (rDir.X()==0 && rDir.Y()==0)) { bRect=sal_False; return sal_False; }
448 	Point aTmpPt(rP2-rP1);
449 	long nDirX=rDir.X();
450 	long nDirY=rDir.Y();
451 	long x=aTmpPt.X();
452 	long y=aTmpPt.Y();
453 	FASTBOOL bHLin=nDirY==0;
454 	FASTBOOL bVLin=nDirX==0;
455 	if (bHLin) y=0;
456 	else if (bVLin) x=0;
457 	else {
458 		y=BigMulDiv(x,nDirY,nDirX);
459 		long nHypLen=aTmpPt.Y()-y;
460 		long nTangAngle=-GetAngle(rDir);
461 		// sin=g/h, g=h*sin
462 		double a=nTangAngle*nPi180;
463 		double sn=sin(a);
464 		double cs=cos(a);
465 		double nGKathLen=nHypLen*sn;
466 		y+=Round(nGKathLen*sn);
467 		x+=Round(nGKathLen*cs);
468 	}
469 	aRectP2.X()+=x;
470 	aRectP2.Y()+=y;
471 	if (pView!=NULL && pView->IsOrtho()) {
472 		long dx1=aRectP2.X()-aRectP1.X(); long dx1a=Abs(dx1);
473 		long dy1=aRectP2.Y()-aRectP1.Y(); long dy1a=Abs(dy1);
474 		long dx2=aRectP3.X()-aRectP2.X(); long dx2a=Abs(dx2);
475 		long dy2=aRectP3.Y()-aRectP2.Y(); long dy2a=Abs(dy2);
476 		FASTBOOL b1MoreThan2=dx1a+dy1a>dx2a+dy2a;
477 		if (b1MoreThan2 != pView->IsBigOrtho()) {
478 			long xtemp=dy2a-dx1a; if (dx1<0) xtemp=-xtemp;
479 			long ytemp=dx2a-dy1a; if (dy1<0) ytemp=-ytemp;
480 			aRectP2.X()+=xtemp;
481 			aRectP2.Y()+=ytemp;
482 			aRectP3.X()+=xtemp;
483 			aRectP3.Y()+=ytemp;
484 		} else {
485 			long xtemp=dy1a-dx2a; if (dx2<0) xtemp=-xtemp;
486 			long ytemp=dx1a-dy2a; if (dy2<0) ytemp=-ytemp;
487 			aRectP3.X()+=xtemp;
488 			aRectP3.Y()+=ytemp;
489 		}
490 	}
491 	bRect=sal_True;
492 	return sal_True;
493 }
494 
GetRectPoly() const495 XPolygon ImpPathCreateUser::GetRectPoly() const
496 {
497 	XPolygon aXP(3);
498 	aXP[0]=aRectP1; aXP.SetFlags(0,XPOLY_SMOOTH);
499 	aXP[1]=aRectP2;
500 	if (aRectP3!=aRectP2) aXP[2]=aRectP3;
501 	return aXP;
502 }
503 
504 /*************************************************************************/
505 
506 class ImpPathForDragAndCreate
507 {
508 	SdrPathObj&					mrSdrPathObject;
509 	XPolyPolygon				aPathPolygon;
510 	SdrObjKind					meObjectKind;
511     ImpSdrPathDragData*         mpSdrPathDragData;
512 	bool						mbCreating;
513 
514 public:
515 	ImpPathForDragAndCreate(SdrPathObj& rSdrPathObject);
516 	~ImpPathForDragAndCreate();
517 
518 	// drag stuff
519 	bool beginPathDrag( SdrDragStat& rDrag )  const;
520     bool movePathDrag( SdrDragStat& rDrag ) const;
521     bool endPathDrag( SdrDragStat& rDrag );
522     //void cancelSpecialDrag( SdrDragStat& rDrag ) const;
523 	String getSpecialDragComment(const SdrDragStat& rDrag) const;
524     basegfx::B2DPolyPolygon getSpecialDragPoly(const SdrDragStat& rDrag) const;
525 
526 	// create stuff
527 	FASTBOOL BegCreate(SdrDragStat& rStat);
528 	FASTBOOL MovCreate(SdrDragStat& rStat);
529 	FASTBOOL EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd);
530 	FASTBOOL BckCreate(SdrDragStat& rStat);
531 	void BrkCreate(SdrDragStat& rStat);
532 	Pointer GetCreatePointer() const;
533 
534 	// helping stuff
IsClosed(SdrObjKind eKind) const535 	bool IsClosed(SdrObjKind eKind) const { return eKind==OBJ_POLY || eKind==OBJ_PATHPOLY || eKind==OBJ_PATHFILL || eKind==OBJ_FREEFILL || eKind==OBJ_SPLNFILL; }
IsFreeHand(SdrObjKind eKind) const536 	bool IsFreeHand(SdrObjKind eKind) const { return eKind==OBJ_FREELINE || eKind==OBJ_FREEFILL; }
IsBezier(SdrObjKind eKind) const537 	bool IsBezier(SdrObjKind eKind) const { return eKind==OBJ_PATHLINE || eKind==OBJ_PATHFILL; }
IsCreating() const538 	bool IsCreating() const { return mbCreating; }
539 
540 	// get the polygon
541 	basegfx::B2DPolyPolygon TakeObjectPolyPolygon(const SdrDragStat& rDrag) const;
542 	basegfx::B2DPolyPolygon TakeDragPolyPolygon(const SdrDragStat& rDrag) const;
getModifiedPolyPolygon() const543 	basegfx::B2DPolyPolygon getModifiedPolyPolygon() const { return  aPathPolygon.getB2DPolyPolygon(); }
544 };
545 
ImpPathForDragAndCreate(SdrPathObj & rSdrPathObject)546 ImpPathForDragAndCreate::ImpPathForDragAndCreate(SdrPathObj& rSdrPathObject)
547 :	mrSdrPathObject(rSdrPathObject),
548 	aPathPolygon(rSdrPathObject.GetPathPoly()),
549 	meObjectKind(mrSdrPathObject.meKind),
550     mpSdrPathDragData(0),
551 	mbCreating(false)
552 {
553 }
554 
~ImpPathForDragAndCreate()555 ImpPathForDragAndCreate::~ImpPathForDragAndCreate()
556 {
557     if(mpSdrPathDragData)
558     {
559         delete mpSdrPathDragData;
560     }
561 }
562 
beginPathDrag(SdrDragStat & rDrag) const563 bool ImpPathForDragAndCreate::beginPathDrag( SdrDragStat& rDrag )  const
564 {
565 	const SdrHdl* pHdl=rDrag.GetHdl();
566 	if(!pHdl)
567 		return sal_False;
568 
569 	sal_Bool bMultiPointDrag(sal_True);
570 
571 	if(aPathPolygon[(sal_uInt16)pHdl->GetPolyNum()].IsControl((sal_uInt16)pHdl->GetPointNum()))
572 		bMultiPointDrag = sal_False;
573 
574 	if(bMultiPointDrag)
575 	{
576 		const SdrMarkView& rMarkView = *rDrag.GetView();
577 		const SdrHdlList& rHdlList = rMarkView.GetHdlList();
578 		const sal_uInt32 nHdlCount = rHdlList.GetHdlCount();
579         const SdrObject* pInteractionObject(nHdlCount && rHdlList.GetHdl(0) ? rHdlList.GetHdl(0)->GetObj() : 0);
580 		sal_uInt32 nSelectedPoints(0);
581 
582 		for(sal_uInt32 a(0); a < nHdlCount; a++)
583 		{
584 			SdrHdl* pTestHdl = rHdlList.GetHdl(a);
585 
586 			if(pTestHdl && pTestHdl->IsSelected() && pTestHdl->GetObj() == pInteractionObject)
587 			{
588 				nSelectedPoints++;
589 			}
590 		}
591 
592 		if(nSelectedPoints <= 1)
593 			bMultiPointDrag = sal_False;
594 	}
595 
596 	((ImpPathForDragAndCreate*)this)->mpSdrPathDragData = new ImpSdrPathDragData(mrSdrPathObject,*pHdl,bMultiPointDrag,rDrag);
597 
598     if(!mpSdrPathDragData || !mpSdrPathDragData->bValid)
599     {
600 		DBG_ERROR("ImpPathForDragAndCreate::BegDrag(): ImpSdrPathDragData ist ungueltig");
601         delete mpSdrPathDragData;
602         ((ImpPathForDragAndCreate*)this)->mpSdrPathDragData = 0;
603 		return false;
604 	}
605 
606 	return true;
607 }
608 
movePathDrag(SdrDragStat & rDrag) const609 bool ImpPathForDragAndCreate::movePathDrag( SdrDragStat& rDrag ) const
610 {
611 	if(!mpSdrPathDragData || !mpSdrPathDragData->bValid)
612     {
613 		DBG_ERROR("ImpPathForDragAndCreate::MovDrag(): ImpSdrPathDragData ist ungueltig");
614 		return false;
615 	}
616 
617 	if(mpSdrPathDragData->IsMultiPointDrag())
618 	{
619 		Point aDelta(rDrag.GetNow() - rDrag.GetStart());
620 
621 		if(aDelta.X() || aDelta.Y())
622 		{
623 			for(sal_uInt32 a(0); a < mpSdrPathDragData->maHandles.Count(); a++)
624 			{
625 				SdrHdl* pHandle = (SdrHdl*)mpSdrPathDragData->maHandles.GetObject(a);
626 				const sal_uInt16 nPolyIndex((sal_uInt16)pHandle->GetPolyNum());
627 				const sal_uInt16 nPointIndex((sal_uInt16)pHandle->GetPointNum());
628 				const XPolygon& rOrig = mpSdrPathDragData->maOrig[nPolyIndex];
629 				XPolygon& rMove = mpSdrPathDragData->maMove[nPolyIndex];
630 				const sal_uInt16 nPointCount(rOrig.GetPointCount());
631 				sal_Bool bClosed(rOrig[0] == rOrig[nPointCount-1]);
632 
633 				// move point itself
634 				rMove[nPointIndex] = rOrig[nPointIndex] + aDelta;
635 
636 				// when point is first and poly closed, move close point, too.
637 				if(nPointCount > 0 && !nPointIndex && bClosed)
638 				{
639 					rMove[nPointCount - 1] = rOrig[nPointCount - 1] + aDelta;
640 
641 					// when moving the last point it may be necessary to move the
642 					// control point in front of this one, too.
643 					if(nPointCount > 1 && rOrig.IsControl(nPointCount - 2))
644 						rMove[nPointCount - 2] = rOrig[nPointCount - 2] + aDelta;
645 				}
646 
647 				// is a control point before this?
648 				if(nPointIndex > 0 && rOrig.IsControl(nPointIndex - 1))
649 				{
650 					// Yes, move it, too
651 					rMove[nPointIndex - 1] = rOrig[nPointIndex - 1] + aDelta;
652 				}
653 
654 				// is a control point after this?
655 				if(nPointIndex + 1 < nPointCount && rOrig.IsControl(nPointIndex + 1))
656 				{
657 					// Yes, move it, too
658 					rMove[nPointIndex + 1] = rOrig[nPointIndex + 1] + aDelta;
659 				}
660 			}
661 		}
662 	}
663 	else
664 	{
665 		mpSdrPathDragData->ResetPoly(mrSdrPathObject);
666 
667 		// Div. Daten lokal Kopieren fuer weniger Code und schnelleren Zugriff
668 		FASTBOOL bClosed       =mpSdrPathDragData->bClosed       ; // geschlossenes Objekt?
669 		sal_uInt16   nPnt          =mpSdrPathDragData->nPnt          ; // Punktnummer innerhalb des obigen Polygons
670 		FASTBOOL bBegPnt       =mpSdrPathDragData->bBegPnt       ; // Gedraggter Punkt ist der Anfangspunkt einer Polyline
671 		FASTBOOL bEndPnt       =mpSdrPathDragData->bEndPnt       ; // Gedraggter Punkt ist der Endpunkt einer Polyline
672 		sal_uInt16   nPrevPnt      =mpSdrPathDragData->nPrevPnt      ; // Index des vorherigen Punkts
673 		sal_uInt16   nNextPnt      =mpSdrPathDragData->nNextPnt      ; // Index des naechsten Punkts
674 		FASTBOOL bPrevIsBegPnt =mpSdrPathDragData->bPrevIsBegPnt ; // Vorheriger Punkt ist Anfangspunkt einer Polyline
675 		FASTBOOL bNextIsEndPnt =mpSdrPathDragData->bNextIsEndPnt ; // Folgepunkt ist Endpunkt einer Polyline
676 		sal_uInt16   nPrevPrevPnt  =mpSdrPathDragData->nPrevPrevPnt  ; // Index des vorvorherigen Punkts
677 		sal_uInt16   nNextNextPnt  =mpSdrPathDragData->nNextNextPnt  ; // Index des uebernaechsten Punkts
678 		FASTBOOL bControl      =mpSdrPathDragData->bControl      ; // Punkt ist ein Kontrollpunkt
679 		//int bIsPrevControl=mpSdrPathDragData->bIsPrevControl; // Punkt ist Kontrollpunkt vor einem Stuetzpunkt
680 		FASTBOOL bIsNextControl=mpSdrPathDragData->bIsNextControl; // Punkt ist Kontrollpunkt hinter einem Stuetzpunkt
681 		FASTBOOL bPrevIsControl=mpSdrPathDragData->bPrevIsControl; // Falls nPnt ein StPnt: Davor ist ein Kontrollpunkt
682 		FASTBOOL bNextIsControl=mpSdrPathDragData->bNextIsControl; // Falls nPnt ein StPnt: Dahinter ist ein Kontrollpunkt
683 
684 		// Ortho bei Linien/Polygonen = Winkel beibehalten
685 		if (!bControl && rDrag.GetView()!=NULL && rDrag.GetView()->IsOrtho()) {
686 			FASTBOOL bBigOrtho=rDrag.GetView()->IsBigOrtho();
687 			Point  aPos(rDrag.GetNow());      // die aktuelle Position
688 			Point  aPnt(mpSdrPathDragData->aXP[nPnt]);      // der gedraggte Punkt
689 			sal_uInt16 nPnt1=0xFFFF,nPnt2=0xFFFF; // seine Nachbarpunkte
690 			Point  aNeuPos1,aNeuPos2;         // die neuen Alternativen fuer aPos
691 			FASTBOOL bPnt1=sal_False,bPnt2=sal_False; // die neuen Alternativen gueltig?
692 			if (!bClosed && mpSdrPathDragData->nPntAnz>=2) { // Mind. 2 Pt bei Linien
693 				if (!bBegPnt) nPnt1=nPrevPnt;
694 				if (!bEndPnt) nPnt2=nNextPnt;
695 			}
696 			if (bClosed && mpSdrPathDragData->nPntAnz>=3) { // Mind. 3 Pt bei Polygon
697 				nPnt1=nPrevPnt;
698 				nPnt2=nNextPnt;
699 			}
700 			if (nPnt1!=0xFFFF && !bPrevIsControl) {
701 				Point aPnt1=mpSdrPathDragData->aXP[nPnt1];
702 				long ndx0=aPnt.X()-aPnt1.X();
703 				long ndy0=aPnt.Y()-aPnt1.Y();
704 				FASTBOOL bHLin=ndy0==0;
705 				FASTBOOL bVLin=ndx0==0;
706 				if (!bHLin || !bVLin) {
707 					long ndx=aPos.X()-aPnt1.X();
708 					long ndy=aPos.Y()-aPnt1.Y();
709 					bPnt1=sal_True;
710 					double nXFact=0; if (!bVLin) nXFact=(double)ndx/(double)ndx0;
711 					double nYFact=0; if (!bHLin) nYFact=(double)ndy/(double)ndy0;
712 					FASTBOOL bHor=bHLin || (!bVLin && (nXFact>nYFact) ==bBigOrtho);
713 					FASTBOOL bVer=bVLin || (!bHLin && (nXFact<=nYFact)==bBigOrtho);
714 					if (bHor) ndy=long(ndy0*nXFact);
715 					if (bVer) ndx=long(ndx0*nYFact);
716 					aNeuPos1=aPnt1;
717 					aNeuPos1.X()+=ndx;
718 					aNeuPos1.Y()+=ndy;
719 				}
720 			}
721 			if (nPnt2!=0xFFFF && !bNextIsControl) {
722 				Point aPnt2=mpSdrPathDragData->aXP[nPnt2];
723 				long ndx0=aPnt.X()-aPnt2.X();
724 				long ndy0=aPnt.Y()-aPnt2.Y();
725 				FASTBOOL bHLin=ndy0==0;
726 				FASTBOOL bVLin=ndx0==0;
727 				if (!bHLin || !bVLin) {
728 					long ndx=aPos.X()-aPnt2.X();
729 					long ndy=aPos.Y()-aPnt2.Y();
730 					bPnt2=sal_True;
731 					double nXFact=0; if (!bVLin) nXFact=(double)ndx/(double)ndx0;
732 					double nYFact=0; if (!bHLin) nYFact=(double)ndy/(double)ndy0;
733 					FASTBOOL bHor=bHLin || (!bVLin && (nXFact>nYFact) ==bBigOrtho);
734 					FASTBOOL bVer=bVLin || (!bHLin && (nXFact<=nYFact)==bBigOrtho);
735 					if (bHor) ndy=long(ndy0*nXFact);
736 					if (bVer) ndx=long(ndx0*nYFact);
737 					aNeuPos2=aPnt2;
738 					aNeuPos2.X()+=ndx;
739 					aNeuPos2.Y()+=ndy;
740 				}
741 			}
742 			if (bPnt1 && bPnt2) { // beide Alternativen vorhanden (Konkurenz)
743 				BigInt nX1(aNeuPos1.X()-aPos.X()); nX1*=nX1;
744 				BigInt nY1(aNeuPos1.Y()-aPos.Y()); nY1*=nY1;
745 				BigInt nX2(aNeuPos2.X()-aPos.X()); nX2*=nX2;
746 				BigInt nY2(aNeuPos2.Y()-aPos.Y()); nY2*=nY2;
747 				nX1+=nY1; // Korrekturabstand zum Quadrat
748 				nX2+=nY2; // Korrekturabstand zum Quadrat
749 				// Die Alternative mit dem geringeren Korrekturbedarf gewinnt
750 				if (nX1<nX2) bPnt2=sal_False; else bPnt1=sal_False;
751 			}
752 			if (bPnt1) rDrag.Now()=aNeuPos1;
753 			if (bPnt2) rDrag.Now()=aNeuPos2;
754 		}
755 		rDrag.SetActionRect(Rectangle(rDrag.GetNow(),rDrag.GetNow()));
756 
757 		// IBM Special: Punkte eliminieren, wenn die beiden angrenzenden
758 		//              Linien eh' fast 180 deg sind.
759 		if (!bControl && rDrag.GetView()!=NULL && rDrag.GetView()->IsEliminatePolyPoints() &&
760 			!bBegPnt && !bEndPnt && !bPrevIsControl && !bNextIsControl)
761 		{
762 			Point aPt(mpSdrPathDragData->aXP[nNextPnt]);
763 			aPt-=rDrag.GetNow();
764 			long nWink1=GetAngle(aPt);
765 			aPt=rDrag.GetNow();
766 			aPt-=mpSdrPathDragData->aXP[nPrevPnt];
767 			long nWink2=GetAngle(aPt);
768 			long nDiff=nWink1-nWink2;
769 			nDiff=Abs(nDiff);
770 			mpSdrPathDragData->bEliminate=nDiff<=rDrag.GetView()->GetEliminatePolyPointLimitAngle();
771 			if (mpSdrPathDragData->bEliminate) { // Position anpassen, damit Smooth an den Enden stimmt
772 				aPt=mpSdrPathDragData->aXP[nNextPnt];
773 				aPt+=mpSdrPathDragData->aXP[nPrevPnt];
774 				aPt/=2;
775 				rDrag.Now()=aPt;
776 			}
777 		}
778 
779 		// Um diese Entfernung wurde insgesamt gedraggd
780 		Point aDiff(rDrag.GetNow()); aDiff-=mpSdrPathDragData->aXP[nPnt];
781 
782 		// Insgesamt sind 8 Faelle moeglich:
783 		//    X      1. Weder rechts noch links Ctrl.
784 		// o--X--o   2. Rechts und links Ctrl, gedraggd wird St.
785 		// o--X      3. Nur links Ctrl, gedraggd wird St.
786 		//    X--o   4. Nur rechts Ctrl, gedraggd wird St.
787 		// x--O--o   5. Rechts und links Ctrl, gedraggd wird links.
788 		// x--O      6. Nur links Ctrl, gedraggd wird links.
789 		// o--O--x   7. Rechts und links Ctrl, gedraggd wird rechts.
790 		//    O--x   8. Nur rechts Ctrl, gedraggd wird rechts.
791 		// Zusaetzlich ist zu beachten, dass das Veraendern einer Linie (keine Kurve)
792 		// eine evtl. Kurve am anderen Ende der Linie bewirkt, falls dort Smooth
793 		// gesetzt ist (Kontrollpunktausrichtung an Gerade).
794 
795 		mpSdrPathDragData->aXP[nPnt]+=aDiff;
796 
797 		// Nun symmetrische PlusHandles etc. checken
798 		if (bControl) { // Faelle 5,6,7,8
799 			sal_uInt16   nSt=nPnt;   // der zugehoerige Stuetzpunkt
800 			sal_uInt16   nFix=nPnt;  // der gegenueberliegende Kontrollpunkt
801 			if (bIsNextControl) { // Wenn der naechste ein Kontrollpunkt ist, muss der vorh. der Stuetzpunkt sein
802 				nSt=nPrevPnt;
803 				nFix=nPrevPrevPnt;
804 			} else {
805 				nSt=nNextPnt;
806 				nFix=nNextNextPnt;
807 			}
808 			if (mpSdrPathDragData->aXP.IsSmooth(nSt)) {
809 				mpSdrPathDragData->aXP.CalcSmoothJoin(nSt,nPnt,nFix);
810 			}
811 		}
812 
813 		if (!bControl) { // Faelle 1,2,3,4 wobei bei 1 nix passiert und bei 3+4 unten noch mehr folgt
814 			// die beiden Kontrollpunkte mit verschieben
815 			if (bPrevIsControl) mpSdrPathDragData->aXP[nPrevPnt]+=aDiff;
816 			if (bNextIsControl) mpSdrPathDragData->aXP[nNextPnt]+=aDiff;
817 			// Kontrollpunkt ggf. an Gerade ausrichten
818 			if (mpSdrPathDragData->aXP.IsSmooth(nPnt)) {
819 				if (bPrevIsControl && !bNextIsControl && !bEndPnt) { // Fall 3
820 					mpSdrPathDragData->aXP.CalcSmoothJoin(nPnt,nNextPnt,nPrevPnt);
821 				}
822 				if (bNextIsControl && !bPrevIsControl && !bBegPnt) { // Fall 4
823 					mpSdrPathDragData->aXP.CalcSmoothJoin(nPnt,nPrevPnt,nNextPnt);
824 				}
825 			}
826 			// Und nun noch die anderen Enden der Strecken ueberpruefen (nPnt+-1).
827 			// Ist dort eine Kurve (IsControl(nPnt+-2)) mit SmoothJoin (nPnt+-1),
828 			// so muss der entsprechende Kontrollpunkt (nPnt+-2) angepasst werden.
829 			if (!bBegPnt && !bPrevIsControl && !bPrevIsBegPnt && mpSdrPathDragData->aXP.IsSmooth(nPrevPnt)) {
830 				if (mpSdrPathDragData->aXP.IsControl(nPrevPrevPnt)) {
831 					mpSdrPathDragData->aXP.CalcSmoothJoin(nPrevPnt,nPnt,nPrevPrevPnt);
832 				}
833 			}
834 			if (!bEndPnt && !bNextIsControl && !bNextIsEndPnt && mpSdrPathDragData->aXP.IsSmooth(nNextPnt)) {
835 				if (mpSdrPathDragData->aXP.IsControl(nNextNextPnt)) {
836 					mpSdrPathDragData->aXP.CalcSmoothJoin(nNextPnt,nPnt,nNextNextPnt);
837 				}
838 			}
839 		}
840 	}
841 
842 	return true;
843 }
844 
endPathDrag(SdrDragStat & rDrag)845 bool ImpPathForDragAndCreate::endPathDrag(SdrDragStat& rDrag)
846 {
847 	Point aLinePt1;
848 	Point aLinePt2;
849 	bool bLineGlueMirror(OBJ_LINE == meObjectKind);
850 	if (bLineGlueMirror) { // #40549#
851 		XPolygon& rXP=aPathPolygon[0];
852 		aLinePt1=rXP[0];
853 		aLinePt2=rXP[1];
854 	}
855 
856     if(!mpSdrPathDragData || !mpSdrPathDragData->bValid)
857     {
858 		DBG_ERROR("ImpPathForDragAndCreate::MovDrag(): ImpSdrPathDragData ist ungueltig");
859 		return false;
860 	}
861 
862 	if(mpSdrPathDragData->IsMultiPointDrag())
863 	{
864 		aPathPolygon = mpSdrPathDragData->maMove;
865 	}
866 	else
867 	{
868 		const SdrHdl* pHdl=rDrag.GetHdl();
869 
870 		// Referenz auf das Polygon
871 		XPolygon& rXP=aPathPolygon[(sal_uInt16)pHdl->GetPolyNum()];
872 
873 		// Die 5 Punkte die sich evtl. geaendert haben
874 		if (!mpSdrPathDragData->bPrevIsBegPnt) rXP[mpSdrPathDragData->nPrevPrevPnt0]=mpSdrPathDragData->aXP[mpSdrPathDragData->nPrevPrevPnt];
875 		if (!mpSdrPathDragData->bNextIsEndPnt) rXP[mpSdrPathDragData->nNextNextPnt0]=mpSdrPathDragData->aXP[mpSdrPathDragData->nNextNextPnt];
876 		if (!mpSdrPathDragData->bBegPnt)       rXP[mpSdrPathDragData->nPrevPnt0]    =mpSdrPathDragData->aXP[mpSdrPathDragData->nPrevPnt];
877 		if (!mpSdrPathDragData->bEndPnt)       rXP[mpSdrPathDragData->nNextPnt0]    =mpSdrPathDragData->aXP[mpSdrPathDragData->nNextPnt];
878         rXP[mpSdrPathDragData->nPnt0]        =mpSdrPathDragData->aXP[mpSdrPathDragData->nPnt];
879 
880 		// Letzter Punkt muss beim Geschlossenen immer gleich dem Ersten sein
881 		if (mpSdrPathDragData->bClosed) rXP[rXP.GetPointCount()-1]=rXP[0];
882 
883 		if (mpSdrPathDragData->bEliminate)
884 		{
885 			basegfx::B2DPolyPolygon aTempPolyPolygon(aPathPolygon.getB2DPolyPolygon());
886 			sal_uInt32 nPoly,nPnt;
887 
888 			if(PolyPolygonEditor::GetRelativePolyPoint(aTempPolyPolygon, rDrag.GetHdl()->GetSourceHdlNum(), nPoly, nPnt))
889 			{
890 				basegfx::B2DPolygon aCandidate(aTempPolyPolygon.getB2DPolygon(nPoly));
891 				aCandidate.remove(nPnt);
892 
893 				if((IsClosed(meObjectKind) && aCandidate.count() < 3L) || aCandidate.count() < 2L)
894 				{
895 					aTempPolyPolygon.remove(nPoly);
896 				}
897 				else
898 				{
899 					aTempPolyPolygon.setB2DPolygon(nPoly, aCandidate);
900 				}
901 			}
902 
903 			aPathPolygon = XPolyPolygon(aTempPolyPolygon);
904 		}
905 
906 		// Winkel anpassen fuer Text an einfacher Linie
907 		if (bLineGlueMirror)
908 		{ // #40549#
909 			Point aLinePt1_(aPathPolygon[0][0]);
910 			Point aLinePt2_(aPathPolygon[0][1]);
911 			FASTBOOL bXMirr=(aLinePt1_.X()>aLinePt2_.X())!=(aLinePt1.X()>aLinePt2.X());
912 			FASTBOOL bYMirr=(aLinePt1_.Y()>aLinePt2_.Y())!=(aLinePt1.Y()>aLinePt2.Y());
913 			if (bXMirr || bYMirr) {
914 				Point aRef1(mrSdrPathObject.GetSnapRect().Center());
915 				if (bXMirr) {
916 					Point aRef2(aRef1);
917 					aRef2.Y()++;
918 					mrSdrPathObject.NbcMirrorGluePoints(aRef1,aRef2);
919 				}
920 				if (bYMirr) {
921 					Point aRef2(aRef1);
922 					aRef2.X()++;
923 					mrSdrPathObject.NbcMirrorGluePoints(aRef1,aRef2);
924 				}
925 			}
926 		}
927 	}
928 
929 	delete mpSdrPathDragData;
930     mpSdrPathDragData = 0;
931 
932 	return true;
933 }
934 
935 /*void ImpPathForDragAndCreate::cancelSpecialDrag( SdrDragStat& rDrag ) const
936 {
937 	ImpSdrPathDragData* pID=(ImpSdrPathDragData*)rDrag.GetUser();
938 	if (pID!=NULL) {
939 		delete pID;
940 		rDrag.SetUser(NULL);
941 	}
942 }*/
943 
getSpecialDragComment(const SdrDragStat & rDrag) const944 String ImpPathForDragAndCreate::getSpecialDragComment(const SdrDragStat& rDrag) const
945 {
946 	XubString aStr;
947 	const SdrHdl* pHdl = rDrag.GetHdl();
948     const bool bCreateComment(rDrag.GetView() && &mrSdrPathObject == rDrag.GetView()->GetCreateObj());
949 
950     if(bCreateComment && rDrag.GetUser())
951     {
952         // #i103058# re-add old creation comment mode
953     	ImpPathCreateUser* pU = (ImpPathCreateUser*)rDrag.GetUser();
954 		const SdrObjKind eKindMerk(meObjectKind);
955 		mrSdrPathObject.meKind = pU->eAktKind;
956 		mrSdrPathObject.ImpTakeDescriptionStr(STR_ViewCreateObj, aStr);
957 		mrSdrPathObject.meKind = eKindMerk;
958 
959 		Point aPrev(rDrag.GetPrev());
960 		Point aNow(rDrag.GetNow());
961 
962 		if(pU->bLine)
963 			aNow = pU->aLineEnd;
964 
965 		aNow -= aPrev;
966 		aStr.AppendAscii(" (");
967 
968 		XubString aMetr;
969 
970 		if(pU->bCircle)
971 		{
972 			mrSdrPathObject.GetModel()->TakeWinkStr(Abs(pU->nCircRelWink), aMetr);
973 			aStr += aMetr;
974 			aStr.AppendAscii(" r=");
975 			mrSdrPathObject.GetModel()->TakeMetricStr(pU->nCircRadius, aMetr, sal_True);
976 			aStr += aMetr;
977 		}
978 
979 		aStr.AppendAscii("dx=");
980 		mrSdrPathObject.GetModel()->TakeMetricStr(aNow.X(), aMetr, sal_True);
981 		aStr += aMetr;
982 
983 		aStr.AppendAscii(" dy=");
984 		mrSdrPathObject.GetModel()->TakeMetricStr(aNow.Y(), aMetr, sal_True);
985 		aStr += aMetr;
986 
987 		if(!IsFreeHand(meObjectKind))
988 		{
989 			sal_Int32 nLen(GetLen(aNow));
990 			aStr.AppendAscii("  l=");
991 			mrSdrPathObject.GetModel()->TakeMetricStr(nLen, aMetr, sal_True);
992 			aStr += aMetr;
993 
994 			sal_Int32 nWink(GetAngle(aNow));
995 			aStr += sal_Unicode(' ');
996 			mrSdrPathObject.GetModel()->TakeWinkStr(nWink, aMetr);
997 			aStr += aMetr;
998 		}
999 
1000 		aStr += sal_Unicode(')');
1001 	}
1002 	else if(!mrSdrPathObject.GetModel() || !pHdl)
1003 	{
1004         // #i103058# fallback when no model and/or Handle, both needed
1005         // for else-path
1006 		mrSdrPathObject.ImpTakeDescriptionStr(STR_DragPathObj, aStr);
1007     }
1008 	else
1009 	{
1010         // #i103058# standard for modification; model and handle needed
1011         ImpSdrPathDragData* pDragData = mpSdrPathDragData;
1012 
1013         if(!pDragData)
1014         {
1015             // getSpecialDragComment is also used from create, so fallback to GetUser()
1016             // when mpSdrPathDragData is not set
1017             pDragData = (ImpSdrPathDragData*)rDrag.GetUser();
1018         }
1019 
1020         if(!pDragData)
1021         {
1022 	        DBG_ERROR("ImpPathForDragAndCreate::MovDrag(): ImpSdrPathDragData ist ungueltig");
1023 	        return String();
1024         }
1025 
1026 		if(!pDragData->IsMultiPointDrag() && pDragData->bEliminate)
1027 		{
1028 			// Punkt von ...
1029 			mrSdrPathObject.ImpTakeDescriptionStr(STR_ViewMarkedPoint, aStr);
1030 
1031 			// %O loeschen
1032 			XubString aStr2(ImpGetResStr(STR_EditDelete));
1033 
1034 			// UNICODE: Punkt von ... loeschen
1035 			aStr2.SearchAndReplaceAscii("%1", aStr);
1036 
1037 			return aStr2;
1038 		}
1039 
1040 		// dx=0.00 dy=0.00                // Beide Seiten Bezier
1041 		// dx=0.00 dy=0.00  l=0.00 0.00�  // Anfang oder Ende oder eine Seite Bezier bzw. Hebel
1042 		// dx=0.00 dy=0.00  l=0.00 0.00� / l=0.00 0.00�   // Mittendrin
1043 		XubString aMetr;
1044 		Point aBeg(rDrag.GetStart());
1045 		Point aNow(rDrag.GetNow());
1046 
1047 		aStr = String();
1048 		aStr.AppendAscii("dx=");
1049 		mrSdrPathObject.GetModel()->TakeMetricStr(aNow.X() - aBeg.X(), aMetr, sal_True);
1050 		aStr += aMetr;
1051 
1052 		aStr.AppendAscii(" dy=");
1053 		mrSdrPathObject.GetModel()->TakeMetricStr(aNow.Y() - aBeg.Y(), aMetr, sal_True);
1054 		aStr += aMetr;
1055 
1056 		if(!pDragData->IsMultiPointDrag())
1057 		{
1058 			sal_uInt16 nPntNum((sal_uInt16)pHdl->GetPointNum());
1059 			const XPolygon& rXPoly = aPathPolygon[(sal_uInt16)rDrag.GetHdl()->GetPolyNum()];
1060 			sal_uInt16 nPntAnz((sal_uInt16)rXPoly.GetPointCount());
1061 			sal_Bool bClose(IsClosed(meObjectKind));
1062 
1063 			if(bClose)
1064 				nPntAnz--;
1065 
1066 			if(pHdl->IsPlusHdl())
1067 			{
1068 				// Hebel
1069 				sal_uInt16 nRef(nPntNum);
1070 
1071 				if(rXPoly.IsControl(nPntNum + 1))
1072 					nRef--;
1073 				else
1074 					nRef++;
1075 
1076 				aNow -= rXPoly[nRef];
1077 
1078 				sal_Int32 nLen(GetLen(aNow));
1079 				aStr.AppendAscii("  l=");
1080 				mrSdrPathObject.GetModel()->TakeMetricStr(nLen, aMetr, sal_True);
1081 				aStr += aMetr;
1082 
1083 				sal_Int32 nWink(GetAngle(aNow));
1084 				aStr += sal_Unicode(' ');
1085 				mrSdrPathObject.GetModel()->TakeWinkStr(nWink, aMetr);
1086 				aStr += aMetr;
1087 			}
1088 			else if(nPntAnz > 1)
1089 			{
1090 				sal_uInt16 nPntMax(nPntAnz - 1);
1091 				Point aPt1,aPt2;
1092 				sal_Bool bIsClosed(IsClosed(meObjectKind));
1093 				sal_Bool bPt1(nPntNum > 0);
1094 				sal_Bool bPt2(nPntNum < nPntMax);
1095 
1096 				if(bIsClosed && nPntAnz > 2)
1097 				{
1098 					bPt1 = sal_True;
1099 					bPt2 = sal_True;
1100 				}
1101 
1102 				sal_uInt16 nPt1,nPt2;
1103 
1104 				if(nPntNum > 0)
1105 					nPt1 = nPntNum - 1;
1106 				else
1107 					nPt1 = nPntMax;
1108 
1109 				if(nPntNum < nPntMax)
1110 					nPt2 = nPntNum + 1;
1111 				else
1112 					nPt2 = 0;
1113 
1114 				if(bPt1 && rXPoly.IsControl(nPt1))
1115 					bPt1 = sal_False; // Keine Anzeige
1116 
1117 				if(bPt2 && rXPoly.IsControl(nPt2))
1118 					bPt2 = sal_False; // von Bezierdaten
1119 
1120 				if(bPt1)
1121 				{
1122 					Point aPt(aNow);
1123 					aPt -= rXPoly[nPt1];
1124 
1125 					sal_Int32 nLen(GetLen(aPt));
1126 					aStr.AppendAscii("  l=");
1127 					mrSdrPathObject.GetModel()->TakeMetricStr(nLen, aMetr, sal_True);
1128 					aStr += aMetr;
1129 
1130 					sal_Int32 nWink(GetAngle(aPt));
1131 					aStr += sal_Unicode(' ');
1132 					mrSdrPathObject.GetModel()->TakeWinkStr(nWink, aMetr);
1133 					aStr += aMetr;
1134 				}
1135 
1136 				if(bPt2)
1137 				{
1138 					if(bPt1)
1139 						aStr.AppendAscii(" / ");
1140 					else
1141 						aStr.AppendAscii("  ");
1142 
1143 					Point aPt(aNow);
1144 					aPt -= rXPoly[nPt2];
1145 
1146 					sal_Int32 nLen(GetLen(aPt));
1147 					aStr.AppendAscii("l=");
1148 					mrSdrPathObject.GetModel()->TakeMetricStr(nLen, aMetr, sal_True);
1149 					aStr += aMetr;
1150 
1151 					sal_Int32 nWink(GetAngle(aPt));
1152 					aStr += sal_Unicode(' ');
1153 					mrSdrPathObject.GetModel()->TakeWinkStr(nWink, aMetr);
1154 					aStr += aMetr;
1155 				}
1156 			}
1157 		}
1158 	}
1159 
1160 	return aStr;
1161 }
1162 
getSpecialDragPoly(const SdrDragStat & rDrag) const1163 basegfx::B2DPolyPolygon ImpPathForDragAndCreate::getSpecialDragPoly(const SdrDragStat& rDrag) const
1164 {
1165     if(!mpSdrPathDragData || !mpSdrPathDragData->bValid)
1166     {
1167 		DBG_ERROR("ImpPathForDragAndCreate::MovDrag(): ImpSdrPathDragData ist ungueltig");
1168 		return basegfx::B2DPolyPolygon();
1169 	}
1170 
1171 	XPolyPolygon aRetval;
1172 
1173     if(mpSdrPathDragData->IsMultiPointDrag())
1174 	{
1175 		aRetval.Insert(mpSdrPathDragData->maMove);
1176 	}
1177 	else
1178 	{
1179 		const XPolygon& rXP=aPathPolygon[(sal_uInt16)rDrag.GetHdl()->GetPolyNum()];
1180 		if (rXP.GetPointCount()<=2) { //|| rXPoly.GetFlags(1)==XPOLY_CONTROL && rXPoly.GetPointCount()<=4
1181 			XPolygon aXPoly(rXP);
1182 			aXPoly[(sal_uInt16)rDrag.GetHdl()->GetPointNum()]=rDrag.GetNow();
1183 			aRetval.Insert(aXPoly);
1184 			return aRetval.getB2DPolyPolygon();
1185 		}
1186 		// Div. Daten lokal Kopieren fuer weniger Code und schnelleren Zugriff
1187 		FASTBOOL bClosed       =mpSdrPathDragData->bClosed       ; // geschlossenes Objekt?
1188 		sal_uInt16   nPntAnz       =mpSdrPathDragData->nPntAnz       ; // Punktanzahl
1189 		sal_uInt16   nPnt          =mpSdrPathDragData->nPnt          ; // Punktnummer innerhalb des Polygons
1190 		FASTBOOL bBegPnt       =mpSdrPathDragData->bBegPnt       ; // Gedraggter Punkt ist der Anfangspunkt einer Polyline
1191 		FASTBOOL bEndPnt       =mpSdrPathDragData->bEndPnt       ; // Gedraggter Punkt ist der Endpunkt einer Polyline
1192 		sal_uInt16   nPrevPnt      =mpSdrPathDragData->nPrevPnt      ; // Index des vorherigen Punkts
1193 		sal_uInt16   nNextPnt      =mpSdrPathDragData->nNextPnt      ; // Index des naechsten Punkts
1194 		FASTBOOL bPrevIsBegPnt =mpSdrPathDragData->bPrevIsBegPnt ; // Vorheriger Punkt ist Anfangspunkt einer Polyline
1195 		FASTBOOL bNextIsEndPnt =mpSdrPathDragData->bNextIsEndPnt ; // Folgepunkt ist Endpunkt einer Polyline
1196 		sal_uInt16   nPrevPrevPnt  =mpSdrPathDragData->nPrevPrevPnt  ; // Index des vorvorherigen Punkts
1197 		sal_uInt16   nNextNextPnt  =mpSdrPathDragData->nNextNextPnt  ; // Index des uebernaechsten Punkts
1198 		FASTBOOL bControl      =mpSdrPathDragData->bControl      ; // Punkt ist ein Kontrollpunkt
1199 		//int bIsPrevControl=mpSdrPathDragData->bIsPrevControl; // Punkt ist Kontrollpunkt vor einem Stuetzpunkt
1200 		FASTBOOL bIsNextControl=mpSdrPathDragData->bIsNextControl; // Punkt ist Kontrollpunkt hinter einem Stuetzpunkt
1201 		FASTBOOL bPrevIsControl=mpSdrPathDragData->bPrevIsControl; // Falls nPnt ein StPnt: Davor ist ein Kontrollpunkt
1202 		FASTBOOL bNextIsControl=mpSdrPathDragData->bNextIsControl; // Falls nPnt ein StPnt: Dahinter ist ein Kontrollpunkt
1203 		XPolygon aXPoly(mpSdrPathDragData->aXP);
1204 		XPolygon aLine1(2);
1205 		XPolygon aLine2(2);
1206 		XPolygon aLine3(2);
1207 		XPolygon aLine4(2);
1208 		if (bControl) {
1209 			aLine1[1]=mpSdrPathDragData->aXP[nPnt];
1210 			if (bIsNextControl) { // bin ich Kontrollpunkt hinter der Stuetzstelle?
1211 				aLine1[0]=mpSdrPathDragData->aXP[nPrevPnt];
1212 				aLine2[0]=mpSdrPathDragData->aXP[nNextNextPnt];
1213 				aLine2[1]=mpSdrPathDragData->aXP[nNextPnt];
1214 				if (mpSdrPathDragData->aXP.IsSmooth(nPrevPnt) && !bPrevIsBegPnt && mpSdrPathDragData->aXP.IsControl(nPrevPrevPnt)) {
1215 					aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-1],XPOLY_CONTROL);
1216 					aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-2],XPOLY_NORMAL);
1217 					// Hebellienien fuer das gegenueberliegende Kurvensegment
1218 					aLine3[0]=mpSdrPathDragData->aXP[nPrevPnt];
1219 					aLine3[1]=mpSdrPathDragData->aXP[nPrevPrevPnt];
1220 					aLine4[0]=rXP[mpSdrPathDragData->nPrevPrevPnt0-2];
1221 					aLine4[1]=rXP[mpSdrPathDragData->nPrevPrevPnt0-1];
1222 				} else {
1223 					aXPoly.Remove(0,1);
1224 				}
1225 			} else { // ansonsten bin ich Kontrollpunkt vor der Stuetzstelle
1226 				aLine1[0]=mpSdrPathDragData->aXP[nNextPnt];
1227 				aLine2[0]=mpSdrPathDragData->aXP[nPrevPrevPnt];
1228 				aLine2[1]=mpSdrPathDragData->aXP[nPrevPnt];
1229 				if (mpSdrPathDragData->aXP.IsSmooth(nNextPnt) && !bNextIsEndPnt && mpSdrPathDragData->aXP.IsControl(nNextNextPnt)) {
1230 					aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+1],XPOLY_CONTROL);
1231 					aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+2],XPOLY_NORMAL);
1232 					// Hebellinien fuer das gegenueberliegende Kurvensegment
1233 					aLine3[0]=mpSdrPathDragData->aXP[nNextPnt];
1234 					aLine3[1]=mpSdrPathDragData->aXP[nNextNextPnt];
1235 					aLine4[0]=rXP[mpSdrPathDragData->nNextNextPnt0+2];
1236 					aLine4[1]=rXP[mpSdrPathDragData->nNextNextPnt0+1];
1237 				} else {
1238 					aXPoly.Remove(aXPoly.GetPointCount()-1,1);
1239 				}
1240 			}
1241 		} else { // ansonsten kein Kontrollpunkt
1242 			if (mpSdrPathDragData->bEliminate) {
1243 				aXPoly.Remove(2,1);
1244 			}
1245 			if (bPrevIsControl) aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-1],XPOLY_NORMAL);
1246 			else if (!bBegPnt && !bPrevIsBegPnt && mpSdrPathDragData->aXP.IsControl(nPrevPrevPnt)) {
1247 				aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-1],XPOLY_CONTROL);
1248 				aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-2],XPOLY_NORMAL);
1249 			} else {
1250 				aXPoly.Remove(0,1);
1251 				if (bBegPnt) aXPoly.Remove(0,1);
1252 			}
1253 			if (bNextIsControl) aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+1],XPOLY_NORMAL);
1254 			else if (!bEndPnt && !bNextIsEndPnt && mpSdrPathDragData->aXP.IsControl(nNextNextPnt)) {
1255 				aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+1],XPOLY_CONTROL);
1256 				aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+2],XPOLY_NORMAL);
1257 			} else {
1258 				aXPoly.Remove(aXPoly.GetPointCount()-1,1);
1259 				if (bEndPnt) aXPoly.Remove(aXPoly.GetPointCount()-1,1);
1260 			}
1261 			if (bClosed) { // "Birnenproblem": 2 Linien, 1 Kurve, alles Smooth, Punkt zw. beiden Linien wird gedraggt
1262 				if (aXPoly.GetPointCount()>nPntAnz && aXPoly.IsControl(1)) {
1263 					sal_uInt16 a=aXPoly.GetPointCount();
1264 					aXPoly[a-2]=aXPoly[2]; aXPoly.SetFlags(a-2,aXPoly.GetFlags(2));
1265 					aXPoly[a-1]=aXPoly[3]; aXPoly.SetFlags(a-1,aXPoly.GetFlags(3));
1266 					aXPoly.Remove(0,3);
1267 				}
1268 			}
1269 		}
1270 		aRetval.Insert(aXPoly);
1271 		if (aLine1.GetPointCount()>1) aRetval.Insert(aLine1);
1272 		if (aLine2.GetPointCount()>1) aRetval.Insert(aLine2);
1273 		if (aLine3.GetPointCount()>1) aRetval.Insert(aLine3);
1274 		if (aLine4.GetPointCount()>1) aRetval.Insert(aLine4);
1275 	}
1276 
1277 	return aRetval.getB2DPolyPolygon();
1278 }
1279 
BegCreate(SdrDragStat & rStat)1280 FASTBOOL ImpPathForDragAndCreate::BegCreate(SdrDragStat& rStat)
1281 {
1282 	bool bFreeHand(IsFreeHand(meObjectKind));
1283 	rStat.SetNoSnap(bFreeHand);
1284 	rStat.SetOrtho8Possible();
1285 	aPathPolygon.Clear();
1286 	mbCreating=sal_True;
1287 	FASTBOOL bMakeStartPoint=sal_True;
1288 	SdrView* pView=rStat.GetView();
1289 	if (pView!=NULL && pView->IsUseIncompatiblePathCreateInterface() &&
1290 		(meObjectKind==OBJ_POLY || meObjectKind==OBJ_PLIN || meObjectKind==OBJ_PATHLINE || meObjectKind==OBJ_PATHFILL)) {
1291 		bMakeStartPoint=sal_False;
1292 	}
1293 	aPathPolygon.Insert(XPolygon());
1294 	aPathPolygon[0][0]=rStat.GetStart();
1295 	if (bMakeStartPoint) {
1296 		aPathPolygon[0][1]=rStat.GetNow();
1297 	}
1298 	ImpPathCreateUser* pU=new ImpPathCreateUser;
1299 	pU->eStartKind=meObjectKind;
1300 	pU->eAktKind=meObjectKind;
1301 	rStat.SetUser(pU);
1302 	return sal_True;
1303 }
1304 
MovCreate(SdrDragStat & rStat)1305 FASTBOOL ImpPathForDragAndCreate::MovCreate(SdrDragStat& rStat)
1306 {
1307 	ImpPathCreateUser* pU=(ImpPathCreateUser*)rStat.GetUser();
1308 	SdrView* pView=rStat.GetView();
1309 	XPolygon& rXPoly=aPathPolygon[aPathPolygon.Count()-1];
1310 	if (pView!=NULL && pView->IsCreateMode()) {
1311 		// ggf. auf anderes CreateTool umschalten
1312 		sal_uInt16 nIdent;
1313 		sal_uInt32 nInvent;
1314 		pView->TakeCurrentObj(nIdent,nInvent);
1315 		if (nInvent==SdrInventor && pU->eAktKind!=(SdrObjKind)nIdent) {
1316 			SdrObjKind eNewKind=(SdrObjKind)nIdent;
1317 			switch (eNewKind) {
1318 				case OBJ_CARC: case OBJ_CIRC: case OBJ_CCUT: case OBJ_SECT: eNewKind=OBJ_CARC;
1319 				case OBJ_RECT:
1320 				case OBJ_LINE: case OBJ_PLIN: case OBJ_POLY:
1321 				case OBJ_PATHLINE: case OBJ_PATHFILL:
1322 				case OBJ_FREELINE: case OBJ_FREEFILL:
1323 				case OBJ_SPLNLINE: case OBJ_SPLNFILL: {
1324 					pU->eAktKind=eNewKind;
1325 					pU->bMixedCreate=sal_True;
1326 					pU->nBezierStartPoint=rXPoly.GetPointCount();
1327 					if (pU->nBezierStartPoint>0) pU->nBezierStartPoint--;
1328 				} break;
1329 				default: break;
1330 			} // switch
1331 		}
1332 	}
1333 	sal_uInt16 nActPoint=rXPoly.GetPointCount();
1334 	if (aPathPolygon.Count()>1 && rStat.IsMouseDown() && nActPoint<2) {
1335 		rXPoly[0]=rStat.GetPos0();
1336 		rXPoly[1]=rStat.GetNow();
1337 		nActPoint=2;
1338 	}
1339 	if (nActPoint==0) {
1340 		rXPoly[0]=rStat.GetPos0();
1341 	} else nActPoint--;
1342 	FASTBOOL bFreeHand=IsFreeHand(pU->eAktKind);
1343 	rStat.SetNoSnap(bFreeHand /*|| (pU->bMixed && pU->eAktKind==OBJ_LINE)*/);
1344 	rStat.SetOrtho8Possible(pU->eAktKind!=OBJ_CARC && pU->eAktKind!=OBJ_RECT && (!pU->bMixedCreate || pU->eAktKind!=OBJ_LINE));
1345 	Point aActMerk(rXPoly[nActPoint]);
1346 	rXPoly[nActPoint]=rStat.Now();
1347 	if (!pU->bMixedCreate && pU->eStartKind==OBJ_LINE && rXPoly.GetPointCount()>=1) {
1348 		Point aPt(rStat.Start());
1349 		if (pView!=NULL && pView->IsCreate1stPointAsCenter()) {
1350 			aPt+=aPt;
1351 			aPt-=rStat.Now();
1352 		}
1353 		rXPoly[0]=aPt;
1354 	}
1355 	OutputDevice* pOut=pView==NULL ? NULL : pView->GetFirstOutputDevice(); // GetWin(0);
1356 	if (bFreeHand) {
1357 		if (pU->nBezierStartPoint>nActPoint) pU->nBezierStartPoint=nActPoint;
1358 		if (rStat.IsMouseDown() && nActPoint>0) {
1359 			// keine aufeinanderfolgenden Punkte an zu Nahe gelegenen Positionen zulassen
1360 			long nMinDist=1;
1361 			if (pView!=NULL) nMinDist=pView->GetFreeHandMinDistPix();
1362 			if (pOut!=NULL) nMinDist=pOut->PixelToLogic(Size(nMinDist,0)).Width();
1363 			if (nMinDist<1) nMinDist=1;
1364 
1365 			Point aPt0(rXPoly[nActPoint-1]);
1366 			Point aPt1(rStat.Now());
1367 			long dx=aPt0.X()-aPt1.X(); if (dx<0) dx=-dx;
1368 			long dy=aPt0.Y()-aPt1.Y(); if (dy<0) dy=-dy;
1369 			if (dx<nMinDist && dy<nMinDist) return sal_False;
1370 
1371 			// folgendes ist aus EndCreate kopiert (nur kleine Modifikationen)
1372 			// und sollte dann mal in eine Methode zusammengefasst werden:
1373 
1374 			if (nActPoint-pU->nBezierStartPoint>=3 && ((nActPoint-pU->nBezierStartPoint)%3)==0) {
1375 				rXPoly.PointsToBezier(nActPoint-3);
1376 				rXPoly.SetFlags(nActPoint-1,XPOLY_CONTROL);
1377 				rXPoly.SetFlags(nActPoint-2,XPOLY_CONTROL);
1378 
1379 				if (nActPoint>=6 && rXPoly.IsControl(nActPoint-4)) {
1380 					rXPoly.CalcTangent(nActPoint-3,nActPoint-4,nActPoint-2);
1381 					rXPoly.SetFlags(nActPoint-3,XPOLY_SMOOTH);
1382 				}
1383 			}
1384 			rXPoly[nActPoint+1]=rStat.Now();
1385 			rStat.NextPoint();
1386 		} else {
1387 			pU->nBezierStartPoint=nActPoint;
1388 		}
1389 	}
1390 
1391 	pU->ResetFormFlags();
1392 	if (IsBezier(pU->eAktKind)) {
1393 		if (nActPoint>=2) {
1394 			pU->CalcBezier(rXPoly[nActPoint-1],rXPoly[nActPoint],rXPoly[nActPoint-1]-rXPoly[nActPoint-2],rStat.IsMouseDown());
1395 		} else if (pU->bBezHasCtrl0) {
1396 			pU->CalcBezier(rXPoly[nActPoint-1],rXPoly[nActPoint],pU->aBezControl0-rXPoly[nActPoint-1],rStat.IsMouseDown());
1397 		}
1398 	}
1399 	if (pU->eAktKind==OBJ_CARC && nActPoint>=2) {
1400 		pU->CalcCircle(rXPoly[nActPoint-1],rXPoly[nActPoint],rXPoly[nActPoint-1]-rXPoly[nActPoint-2],pView);
1401 	}
1402 	if (pU->eAktKind==OBJ_LINE && nActPoint>=2) {
1403 		pU->CalcLine(rXPoly[nActPoint-1],rXPoly[nActPoint],rXPoly[nActPoint-1]-rXPoly[nActPoint-2],pView);
1404 	}
1405 	if (pU->eAktKind==OBJ_RECT && nActPoint>=2) {
1406 		pU->CalcRect(rXPoly[nActPoint-1],rXPoly[nActPoint],rXPoly[nActPoint-1]-rXPoly[nActPoint-2],pView);
1407 	}
1408 
1409 	return sal_True;
1410 }
1411 
EndCreate(SdrDragStat & rStat,SdrCreateCmd eCmd)1412 FASTBOOL ImpPathForDragAndCreate::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
1413 {
1414 	ImpPathCreateUser* pU=(ImpPathCreateUser*)rStat.GetUser();
1415 	FASTBOOL bRet=sal_False;
1416 	SdrView* pView=rStat.GetView();
1417 	FASTBOOL bIncomp=pView!=NULL && pView->IsUseIncompatiblePathCreateInterface();
1418 	XPolygon& rXPoly=aPathPolygon[aPathPolygon.Count()-1];
1419 	sal_uInt16 nActPoint=rXPoly.GetPointCount()-1;
1420 	Point aAktMerk(rXPoly[nActPoint]);
1421 	rXPoly[nActPoint]=rStat.Now();
1422 	if (!pU->bMixedCreate && pU->eStartKind==OBJ_LINE) {
1423 		if (rStat.GetPointAnz()>=2) eCmd=SDRCREATE_FORCEEND;
1424 		bRet=eCmd==SDRCREATE_FORCEEND;
1425 		if (bRet) {
1426 			mbCreating=sal_False;
1427 			delete pU;
1428 			rStat.SetUser(NULL);
1429 		}
1430 		return bRet;
1431 	}
1432 
1433 	if (!pU->bMixedCreate && IsFreeHand(pU->eStartKind)) {
1434 		if (rStat.GetPointAnz()>=2) eCmd=SDRCREATE_FORCEEND;
1435 		bRet=eCmd==SDRCREATE_FORCEEND;
1436 		if (bRet) {
1437 			mbCreating=sal_False;
1438 			delete pU;
1439 			rStat.SetUser(NULL);
1440 		}
1441 		return bRet;
1442 	}
1443 	if (eCmd==SDRCREATE_NEXTPOINT || eCmd==SDRCREATE_NEXTOBJECT) {
1444 		// keine aufeinanderfolgenden Punkte an identischer Position zulassen
1445 		if (nActPoint==0 || rStat.Now()!=rXPoly[nActPoint-1]) {
1446 			if (bIncomp) {
1447 				if (pU->nBezierStartPoint>nActPoint) pU->nBezierStartPoint=nActPoint;
1448 				if (IsBezier(pU->eAktKind) && nActPoint-pU->nBezierStartPoint>=3 && ((nActPoint-pU->nBezierStartPoint)%3)==0) {
1449 					rXPoly.PointsToBezier(nActPoint-3);
1450 					rXPoly.SetFlags(nActPoint-1,XPOLY_CONTROL);
1451 					rXPoly.SetFlags(nActPoint-2,XPOLY_CONTROL);
1452 
1453 					if (nActPoint>=6 && rXPoly.IsControl(nActPoint-4)) {
1454 						rXPoly.CalcTangent(nActPoint-3,nActPoint-4,nActPoint-2);
1455 						rXPoly.SetFlags(nActPoint-3,XPOLY_SMOOTH);
1456 					}
1457 				}
1458 			} else {
1459 				if (nActPoint==1 && IsBezier(pU->eAktKind) && !pU->bBezHasCtrl0) {
1460 					pU->aBezControl0=rStat.GetNow();;
1461 					pU->bBezHasCtrl0=sal_True;
1462 					nActPoint--;
1463 				}
1464 				if (pU->IsFormFlag()) {
1465 					sal_uInt16 nPtAnz0=rXPoly.GetPointCount();
1466 					rXPoly.Remove(nActPoint-1,2); // die letzten beiden Punkte entfernen und durch die Form ersetzen
1467 					rXPoly.Insert(XPOLY_APPEND,pU->GetFormPoly());
1468 					sal_uInt16 nPtAnz1=rXPoly.GetPointCount();
1469 					for (sal_uInt16 i=nPtAnz0+1; i<nPtAnz1-1; i++) { // Damit BckAction richtig funktioniert
1470 						if (!rXPoly.IsControl(i)) rStat.NextPoint();
1471 					}
1472 					nActPoint=rXPoly.GetPointCount()-1;
1473 				}
1474 			}
1475 			nActPoint++;
1476 			rXPoly[nActPoint]=rStat.GetNow();
1477 		}
1478 		if (eCmd==SDRCREATE_NEXTOBJECT) {
1479 			if (rXPoly.GetPointCount()>=2) {
1480 				pU->bBezHasCtrl0=sal_False;
1481 				// nur einzelnes Polygon kann offen sein, deshalb schliessen
1482 				rXPoly[nActPoint]=rXPoly[0];
1483 				XPolygon aXP;
1484 				aXP[0]=rStat.GetNow();
1485 				aPathPolygon.Insert(aXP);
1486 			}
1487 		}
1488 	}
1489 
1490 	sal_uInt16 nPolyAnz=aPathPolygon.Count();
1491 	if (nPolyAnz!=0) {
1492 		// den letzten Punkt ggf. wieder loeschen
1493 		if (eCmd==SDRCREATE_FORCEEND) {
1494 			XPolygon& rXP=aPathPolygon[nPolyAnz-1];
1495 			sal_uInt16 nPtAnz=rXP.GetPointCount();
1496 			if (nPtAnz>=2) {
1497 				if (!rXP.IsControl(nPtAnz-2)) {
1498 					if (rXP[nPtAnz-1]==rXP[nPtAnz-2]) {
1499 						rXP.Remove(nPtAnz-1,1);
1500 					}
1501 				} else {
1502 					if (rXP[nPtAnz-3]==rXP[nPtAnz-2]) {
1503 						rXP.Remove(nPtAnz-3,3);
1504 					}
1505 				}
1506 			}
1507 		}
1508 		for (sal_uInt16 nPolyNum=nPolyAnz; nPolyNum>0;) {
1509 			nPolyNum--;
1510 			XPolygon& rXP=aPathPolygon[nPolyNum];
1511 			sal_uInt16 nPtAnz=rXP.GetPointCount();
1512 			// Polygone mit zu wenig Punkten werden geloescht
1513 			if (nPolyNum<nPolyAnz-1 || eCmd==SDRCREATE_FORCEEND) {
1514 				if (nPtAnz<2) aPathPolygon.Remove(nPolyNum);
1515 			}
1516 		}
1517 	}
1518 	pU->ResetFormFlags();
1519 	bRet=eCmd==SDRCREATE_FORCEEND;
1520 	if (bRet) {
1521 		mbCreating=sal_False;
1522 		delete pU;
1523 		rStat.SetUser(NULL);
1524 	}
1525 	return bRet;
1526 }
1527 
BckCreate(SdrDragStat & rStat)1528 FASTBOOL ImpPathForDragAndCreate::BckCreate(SdrDragStat& rStat)
1529 {
1530 	ImpPathCreateUser* pU=(ImpPathCreateUser*)rStat.GetUser();
1531 	if (aPathPolygon.Count()>0) {
1532 		XPolygon& rXPoly=aPathPolygon[aPathPolygon.Count()-1];
1533 		sal_uInt16 nActPoint=rXPoly.GetPointCount();
1534 		if (nActPoint>0) {
1535 			nActPoint--;
1536 			// Das letzte Stueck einer Bezierkurve wird erstmal zu 'ner Linie
1537 			rXPoly.Remove(nActPoint,1);
1538 			if (nActPoint>=3 && rXPoly.IsControl(nActPoint-1)) {
1539 				// Beziersegment am Ende sollte zwar nicht vorkommen, aber falls doch ...
1540 				rXPoly.Remove(nActPoint-1,1);
1541 				if (rXPoly.IsControl(nActPoint-2)) rXPoly.Remove(nActPoint-2,1);
1542 			}
1543 		}
1544 		nActPoint=rXPoly.GetPointCount();
1545 		if (nActPoint>=4) { // Kein Beziersegment am Ende
1546 			nActPoint--;
1547 			if (rXPoly.IsControl(nActPoint-1)) {
1548 				rXPoly.Remove(nActPoint-1,1);
1549 				if (rXPoly.IsControl(nActPoint-2)) rXPoly.Remove(nActPoint-2,1);
1550 			}
1551 		}
1552 		if (rXPoly.GetPointCount()<2) {
1553 			aPathPolygon.Remove(aPathPolygon.Count()-1);
1554 		}
1555 		if (aPathPolygon.Count()>0) {
1556 			XPolygon& rLocalXPoly=aPathPolygon[aPathPolygon.Count()-1];
1557 			sal_uInt16 nLocalActPoint=rLocalXPoly.GetPointCount();
1558 			if (nLocalActPoint>0) {
1559 				nLocalActPoint--;
1560 				rLocalXPoly[nLocalActPoint]=rStat.Now();
1561 			}
1562 		}
1563 	}
1564 	pU->ResetFormFlags();
1565 	return aPathPolygon.Count()!=0;
1566 }
1567 
BrkCreate(SdrDragStat & rStat)1568 void ImpPathForDragAndCreate::BrkCreate(SdrDragStat& rStat)
1569 {
1570 	ImpPathCreateUser* pU=(ImpPathCreateUser*)rStat.GetUser();
1571 	aPathPolygon.Clear();
1572 	mbCreating=sal_False;
1573 	delete pU;
1574 	rStat.SetUser(NULL);
1575 }
1576 
TakeObjectPolyPolygon(const SdrDragStat & rDrag) const1577 basegfx::B2DPolyPolygon ImpPathForDragAndCreate::TakeObjectPolyPolygon(const SdrDragStat& rDrag) const
1578 {
1579 	basegfx::B2DPolyPolygon aRetval(aPathPolygon.getB2DPolyPolygon());
1580 	SdrView* pView = rDrag.GetView();
1581 
1582 	if(pView && pView->IsUseIncompatiblePathCreateInterface())
1583 		return aRetval;
1584 
1585 	ImpPathCreateUser* pU = (ImpPathCreateUser*)rDrag.GetUser();
1586 	basegfx::B2DPolygon aNewPolygon(aRetval.count() ? aRetval.getB2DPolygon(aRetval.count() - 1L) : basegfx::B2DPolygon());
1587 
1588 	if(pU->IsFormFlag() && aNewPolygon.count() > 1L)
1589 	{
1590 		// remove last segment and replace with current
1591 		// do not forget to rescue the previous control point which will be lost when
1592 		// the point it's associated with is removed
1593 		const sal_uInt32 nChangeIndex(aNewPolygon.count() - 2);
1594 		const basegfx::B2DPoint aSavedPrevCtrlPoint(aNewPolygon.getPrevControlPoint(nChangeIndex));
1595 
1596 		aNewPolygon.remove(nChangeIndex, 2L);
1597 		aNewPolygon.append(pU->GetFormPoly().getB2DPolygon());
1598 
1599 		if(nChangeIndex < aNewPolygon.count())
1600 		{
1601 			// if really something was added, set the saved prev control point at the
1602 			// point where it belongs
1603 			aNewPolygon.setPrevControlPoint(nChangeIndex, aSavedPrevCtrlPoint);
1604 		}
1605 	}
1606 
1607 	if(aRetval.count())
1608 	{
1609 		aRetval.setB2DPolygon(aRetval.count() - 1L, aNewPolygon);
1610 	}
1611 	else
1612 	{
1613 		aRetval.append(aNewPolygon);
1614 	}
1615 
1616 	return aRetval;
1617 }
1618 
TakeDragPolyPolygon(const SdrDragStat & rDrag) const1619 basegfx::B2DPolyPolygon ImpPathForDragAndCreate::TakeDragPolyPolygon(const SdrDragStat& rDrag) const
1620 {
1621 	basegfx::B2DPolyPolygon aRetval;
1622 	SdrView* pView = rDrag.GetView();
1623 
1624 	if(pView && pView->IsUseIncompatiblePathCreateInterface())
1625 		return aRetval;
1626 
1627 	ImpPathCreateUser* pU = (ImpPathCreateUser*)rDrag.GetUser();
1628 
1629 	if(pU && pU->bBezier && rDrag.IsMouseDown())
1630 	{
1631 		// no more XOR, no need for complicated helplines
1632 		basegfx::B2DPolygon aHelpline;
1633 		aHelpline.append(basegfx::B2DPoint(pU->aBezCtrl2.X(), pU->aBezCtrl2.Y()));
1634 		aHelpline.append(basegfx::B2DPoint(pU->aBezEnd.X(), pU->aBezEnd.Y()));
1635 		aRetval.append(aHelpline);
1636 	}
1637 
1638 	return aRetval;
1639 }
1640 
GetCreatePointer() const1641 Pointer ImpPathForDragAndCreate::GetCreatePointer() const
1642 {
1643 	switch (meObjectKind) {
1644 		case OBJ_LINE    : return Pointer(POINTER_DRAW_LINE);
1645 		case OBJ_POLY    : return Pointer(POINTER_DRAW_POLYGON);
1646 		case OBJ_PLIN    : return Pointer(POINTER_DRAW_POLYGON);
1647 		case OBJ_PATHLINE: return Pointer(POINTER_DRAW_BEZIER);
1648 		case OBJ_PATHFILL: return Pointer(POINTER_DRAW_BEZIER);
1649 		case OBJ_FREELINE: return Pointer(POINTER_DRAW_FREEHAND);
1650 		case OBJ_FREEFILL: return Pointer(POINTER_DRAW_FREEHAND);
1651 		case OBJ_SPLNLINE: return Pointer(POINTER_DRAW_FREEHAND);
1652 		case OBJ_SPLNFILL: return Pointer(POINTER_DRAW_FREEHAND);
1653 		case OBJ_PATHPOLY: return Pointer(POINTER_DRAW_POLYGON);
1654 		case OBJ_PATHPLIN: return Pointer(POINTER_DRAW_POLYGON);
1655 		default: break;
1656 	} // switch
1657 	return Pointer(POINTER_CROSS);
1658 }
1659 
1660 /*************************************************************************/
1661 
SdrPathObjGeoData()1662 SdrPathObjGeoData::SdrPathObjGeoData()
1663 {
1664 }
1665 
~SdrPathObjGeoData()1666 SdrPathObjGeoData::~SdrPathObjGeoData()
1667 {
1668 }
1669 
1670 //////////////////////////////////////////////////////////////////////////////
1671 // DrawContact section
1672 
CreateObjectSpecificViewContact()1673 sdr::contact::ViewContact* SdrPathObj::CreateObjectSpecificViewContact()
1674 {
1675 	return new sdr::contact::ViewContactOfSdrPathObj(*this);
1676 }
1677 
1678 /*************************************************************************/
1679 
1680 TYPEINIT1(SdrPathObj,SdrTextObj);
1681 
SdrPathObj(SdrObjKind eNewKind)1682 SdrPathObj::SdrPathObj(SdrObjKind eNewKind)
1683 :	meKind(eNewKind),
1684 	mpDAC(0L)
1685 {
1686 	bClosedObj = IsClosed();
1687 }
1688 
SdrPathObj(SdrObjKind eNewKind,const basegfx::B2DPolyPolygon & rPathPoly)1689 SdrPathObj::SdrPathObj(SdrObjKind eNewKind, const basegfx::B2DPolyPolygon& rPathPoly)
1690 :	maPathPolygon(rPathPoly),
1691 	meKind(eNewKind),
1692 	mpDAC(0L)
1693 {
1694 	bClosedObj = IsClosed();
1695 	ImpForceKind();
1696 }
1697 
~SdrPathObj()1698 SdrPathObj::~SdrPathObj()
1699 {
1700 	impDeleteDAC();
1701 }
1702 
ImpIsLine(const basegfx::B2DPolyPolygon & rPolyPolygon)1703 sal_Bool ImpIsLine(const basegfx::B2DPolyPolygon& rPolyPolygon)
1704 {
1705 	return (1L == rPolyPolygon.count() && 2L == rPolyPolygon.getB2DPolygon(0L).count());
1706 }
1707 
ImpGetBoundRect(const basegfx::B2DPolyPolygon & rPolyPolygon)1708 Rectangle ImpGetBoundRect(const basegfx::B2DPolyPolygon& rPolyPolygon)
1709 {
1710 	basegfx::B2DRange aRange(basegfx::tools::getRange(rPolyPolygon));
1711 
1712 	return Rectangle(
1713 		FRound(aRange.getMinX()), FRound(aRange.getMinY()),
1714 		FRound(aRange.getMaxX()), FRound(aRange.getMaxY()));
1715 }
1716 
ImpForceLineWink()1717 void SdrPathObj::ImpForceLineWink()
1718 {
1719 	if(OBJ_LINE == meKind && ImpIsLine(GetPathPoly()))
1720 	{
1721 		const basegfx::B2DPolygon aPoly(GetPathPoly().getB2DPolygon(0L));
1722 		const basegfx::B2DPoint aB2DPoint0(aPoly.getB2DPoint(0L));
1723 		const basegfx::B2DPoint aB2DPoint1(aPoly.getB2DPoint(1L));
1724 		const Point aPoint0(FRound(aB2DPoint0.getX()), FRound(aB2DPoint0.getY()));
1725 		const Point aPoint1(FRound(aB2DPoint1.getX()), FRound(aB2DPoint1.getY()));
1726 		const Point aDelt(aPoint1 - aPoint0);
1727 
1728 		aGeo.nDrehWink=GetAngle(aDelt);
1729 		aGeo.nShearWink=0;
1730 		aGeo.RecalcSinCos();
1731 		aGeo.RecalcTan();
1732 
1733 		// #101412# for SdrTextObj, keep aRect up to date
1734 		aRect = Rectangle(aPoint0, aPoint1);
1735 		aRect.Justify();
1736 	}
1737 }
1738 
ImpForceKind()1739 void SdrPathObj::ImpForceKind()
1740 {
1741 	if (meKind==OBJ_PATHPLIN) meKind=OBJ_PLIN;
1742 	if (meKind==OBJ_PATHPOLY) meKind=OBJ_POLY;
1743 
1744 	if(GetPathPoly().areControlPointsUsed())
1745 	{
1746 		switch (meKind)
1747 		{
1748 			case OBJ_LINE: meKind=OBJ_PATHLINE; break;
1749 			case OBJ_PLIN: meKind=OBJ_PATHLINE; break;
1750 			case OBJ_POLY: meKind=OBJ_PATHFILL; break;
1751 			default: break;
1752 		}
1753 	}
1754 	else
1755 	{
1756 		switch (meKind)
1757 		{
1758 			case OBJ_PATHLINE: meKind=OBJ_PLIN; break;
1759 			case OBJ_FREELINE: meKind=OBJ_PLIN; break;
1760 			case OBJ_PATHFILL: meKind=OBJ_POLY; break;
1761 			case OBJ_FREEFILL: meKind=OBJ_POLY; break;
1762 			default: break;
1763 		}
1764 	}
1765 
1766 	if (meKind==OBJ_LINE && !ImpIsLine(GetPathPoly())) meKind=OBJ_PLIN;
1767 	if (meKind==OBJ_PLIN && ImpIsLine(GetPathPoly())) meKind=OBJ_LINE;
1768 
1769 	bClosedObj=IsClosed();
1770 
1771 	if (meKind==OBJ_LINE)
1772 	{
1773 		ImpForceLineWink();
1774 	}
1775 	else
1776 	{
1777 		// #i10659#, similar to #101412# but for polys with more than 2 points.
1778 		//
1779 		// Here i again need to fix something, because when Path-Polys are Copy-Pasted
1780 		// between Apps with different measurements (e.g. 100TH_MM and TWIPS) there is
1781 		// a scaling loop started from SdrExchangeView::Paste. This is principally nothing
1782 		// wrong, but aRect is wrong here and not even updated by RecalcSnapRect(). If
1783 		// this is the case, some size needs to be set here in aRect to avoid that the cyclus
1784 		// through Rect2Poly - Poly2Rect does something badly wrong since that cycle is
1785 		// BASED on aRect. That cycle is triggered in SdrTextObj::NbcResize() which is called
1786 		// from the local Resize() implementation.
1787 		//
1788 		// Basic problem is that the member aRect in SdrTextObj basically is a unrotated
1789 		// text rectangle for the text object itself and methods at SdrTextObj do handle it
1790 		// in that way. Many draw objects derived from SdrTextObj 'abuse' aRect as SnapRect
1791 		// which is basically wrong. To make the SdrText methods which deal with aRect directly
1792 		// work it is necessary to always keep aRect updated. This e.g. not done after a Clone()
1793 		// command for SdrPathObj. Since adding this update mechanism with #101412# to
1794 		// ImpForceLineWink() for lines was very successful, i add it to where ImpForceLineWink()
1795 		// was called, once here below and once on a 2nd place below.
1796 
1797 		// #i10659# for SdrTextObj, keep aRect up to date
1798 		if(GetPathPoly().count())
1799 		{
1800 			aRect = ImpGetBoundRect(GetPathPoly());
1801 		}
1802 
1803         // #116244# reset rotation
1804 		aGeo.nDrehWink = aGeo.nShearWink = 0;
1805 		aGeo.RecalcSinCos(); aGeo.RecalcTan();
1806 	}
1807 
1808 	// #i75974# adapt polygon state to object type. This may include a reinterpretation
1809 	// of a closed geometry as open one, but with identical first and last point
1810 	for(sal_uInt32 a(0); a < maPathPolygon.count(); a++)
1811 	{
1812 		basegfx::B2DPolygon aCandidate(maPathPolygon.getB2DPolygon(a));
1813 
1814 		if((bool)IsClosed() != aCandidate.isClosed())
1815 		{
1816             // #i80213# really change polygon geometry; else e.g. the last point which
1817             // needs to be identical with the first one will be missing when opening
1818             // due to OBJ_PATH type
1819             if(aCandidate.isClosed())
1820             {
1821                 basegfx::tools::openWithGeometryChange(aCandidate);
1822             }
1823             else
1824             {
1825                 basegfx::tools::closeWithGeometryChange(aCandidate);
1826             }
1827 
1828             maPathPolygon.setB2DPolygon(a, aCandidate);
1829 		}
1830 	}
1831 }
1832 
ImpSetClosed(sal_Bool bClose)1833 void SdrPathObj::ImpSetClosed(sal_Bool bClose)
1834 {
1835 	if(bClose)
1836 	{
1837 		switch (meKind)
1838 		{
1839 			case OBJ_LINE    : meKind=OBJ_POLY;     break;
1840 			case OBJ_PLIN    : meKind=OBJ_POLY;     break;
1841 			case OBJ_PATHLINE: meKind=OBJ_PATHFILL; break;
1842 			case OBJ_FREELINE: meKind=OBJ_FREEFILL; break;
1843 			case OBJ_SPLNLINE: meKind=OBJ_SPLNFILL; break;
1844 			default: break;
1845 		}
1846 
1847 		bClosedObj = sal_True;
1848 	}
1849 	else
1850 	{
1851 		switch (meKind)
1852 		{
1853 			case OBJ_POLY    : meKind=OBJ_PLIN;     break;
1854 			case OBJ_PATHFILL: meKind=OBJ_PATHLINE; break;
1855 			case OBJ_FREEFILL: meKind=OBJ_FREELINE; break;
1856 			case OBJ_SPLNFILL: meKind=OBJ_SPLNLINE; break;
1857 			default: break;
1858 		}
1859 
1860 		bClosedObj = sal_False;
1861 	}
1862 
1863 	ImpForceKind();
1864 }
1865 
TakeObjInfo(SdrObjTransformInfoRec & rInfo) const1866 void SdrPathObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
1867 {
1868 	rInfo.bNoContortion=sal_False;
1869 
1870 	FASTBOOL bCanConv = !HasText() || ImpCanConvTextToCurve();
1871 	FASTBOOL bIsPath = IsBezier() || IsSpline();
1872 
1873 	rInfo.bEdgeRadiusAllowed	= sal_False;
1874 	rInfo.bCanConvToPath = bCanConv && !bIsPath;
1875 	rInfo.bCanConvToPoly = bCanConv && bIsPath;
1876 	rInfo.bCanConvToContour = !IsFontwork() && (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary());
1877 }
1878 
GetObjIdentifier() const1879 sal_uInt16 SdrPathObj::GetObjIdentifier() const
1880 {
1881 	return sal_uInt16(meKind);
1882 }
1883 
operator =(const SdrObject & rObj)1884 void SdrPathObj::operator=(const SdrObject& rObj)
1885 {
1886 	SdrTextObj::operator=(rObj);
1887 	SdrPathObj& rPath=(SdrPathObj&)rObj;
1888 	maPathPolygon=rPath.GetPathPoly();
1889 }
1890 
TakeObjNameSingul(XubString & rName) const1891 void SdrPathObj::TakeObjNameSingul(XubString& rName) const
1892 {
1893 	if(OBJ_LINE == meKind)
1894 	{
1895 		sal_uInt16 nId(STR_ObjNameSingulLINE);
1896 
1897 		if(ImpIsLine(GetPathPoly()))
1898 		{
1899 			const basegfx::B2DPolygon aPoly(GetPathPoly().getB2DPolygon(0L));
1900 			const basegfx::B2DPoint aB2DPoint0(aPoly.getB2DPoint(0L));
1901 			const basegfx::B2DPoint aB2DPoint1(aPoly.getB2DPoint(1L));
1902 			const Point aPoint0(FRound(aB2DPoint0.getX()), FRound(aB2DPoint0.getY()));
1903 			const Point aPoint1(FRound(aB2DPoint0.getX()), FRound(aB2DPoint0.getY()));
1904 
1905 			if(aB2DPoint0 != aB2DPoint1)
1906 			{
1907 				if(aB2DPoint0.getY() == aB2DPoint1.getY())
1908 				{
1909 					nId = STR_ObjNameSingulLINE_Hori;
1910 				}
1911 				else if(aB2DPoint0.getX() == aB2DPoint1.getX())
1912 				{
1913 					nId = STR_ObjNameSingulLINE_Vert;
1914 				}
1915 				else
1916 				{
1917 					const double fDx(fabs(aB2DPoint0.getX() - aB2DPoint1.getX()));
1918 					const double fDy(fabs(aB2DPoint0.getY() - aB2DPoint1.getY()));
1919 
1920 					if(fDx == fDy)
1921 					{
1922 						nId = STR_ObjNameSingulLINE_Diag;
1923 					}
1924 				}
1925 			}
1926 		}
1927 
1928 		rName = ImpGetResStr(nId);
1929 	}
1930 	else if(OBJ_PLIN == meKind || OBJ_POLY == meKind)
1931 	{
1932 		const sal_Bool bClosed(OBJ_POLY == meKind);
1933 		sal_uInt16 nId(0);
1934 
1935 		if(mpDAC && mpDAC->IsCreating())
1936 		{
1937 			if(bClosed)
1938 			{
1939 				nId = STR_ObjNameSingulPOLY;
1940 			}
1941 			else
1942 			{
1943 				nId = STR_ObjNameSingulPLIN;
1944 			}
1945 
1946 			rName = ImpGetResStr(nId);
1947 		}
1948 		else
1949 		{
1950 			// get point count
1951 			sal_uInt32 nPointCount(0L);
1952 			const sal_uInt32 nPolyCount(GetPathPoly().count());
1953 
1954 			for(sal_uInt32 a(0L); a < nPolyCount; a++)
1955 			{
1956 				nPointCount += GetPathPoly().getB2DPolygon(a).count();
1957 			}
1958 
1959 			if(bClosed)
1960 			{
1961 				nId = STR_ObjNameSingulPOLY_PntAnz;
1962 			}
1963 			else
1964 			{
1965 				nId = STR_ObjNameSingulPLIN_PntAnz;
1966 			}
1967 
1968 			rName = ImpGetResStr(nId);
1969 			sal_uInt16 nPos(rName.SearchAscii("%2")); // #i96537#
1970 
1971 			if(STRING_NOTFOUND != nPos)
1972 			{
1973 				rName.Erase(nPos, 2);
1974 				rName.Insert(UniString::CreateFromInt32(nPointCount), nPos);
1975 			}
1976 		}
1977 	}
1978 	else
1979 	{
1980 		switch (meKind)
1981 		{
1982 			case OBJ_PATHLINE: rName=ImpGetResStr(STR_ObjNameSingulPATHLINE); break;
1983 			case OBJ_FREELINE: rName=ImpGetResStr(STR_ObjNameSingulFREELINE); break;
1984 			case OBJ_SPLNLINE: rName=ImpGetResStr(STR_ObjNameSingulNATSPLN); break;
1985 			case OBJ_PATHFILL: rName=ImpGetResStr(STR_ObjNameSingulPATHFILL); break;
1986 			case OBJ_FREEFILL: rName=ImpGetResStr(STR_ObjNameSingulFREEFILL); break;
1987 			case OBJ_SPLNFILL: rName=ImpGetResStr(STR_ObjNameSingulPERSPLN); break;
1988 			default: break;
1989 		}
1990 	}
1991 
1992 	String aName(GetName());
1993 	if(aName.Len())
1994 	{
1995 		rName += sal_Unicode(' ');
1996 		rName += sal_Unicode('\'');
1997 		rName += aName;
1998 		rName += sal_Unicode('\'');
1999 	}
2000 }
2001 
TakeObjNamePlural(XubString & rName) const2002 void SdrPathObj::TakeObjNamePlural(XubString& rName) const
2003 {
2004 	switch(meKind)
2005 	{
2006 		case OBJ_LINE    : rName=ImpGetResStr(STR_ObjNamePluralLINE    ); break;
2007 		case OBJ_PLIN    : rName=ImpGetResStr(STR_ObjNamePluralPLIN    ); break;
2008 		case OBJ_POLY    : rName=ImpGetResStr(STR_ObjNamePluralPOLY    ); break;
2009 		case OBJ_PATHLINE: rName=ImpGetResStr(STR_ObjNamePluralPATHLINE); break;
2010 		case OBJ_FREELINE: rName=ImpGetResStr(STR_ObjNamePluralFREELINE); break;
2011 		case OBJ_SPLNLINE: rName=ImpGetResStr(STR_ObjNamePluralNATSPLN); break;
2012 		case OBJ_PATHFILL: rName=ImpGetResStr(STR_ObjNamePluralPATHFILL); break;
2013 		case OBJ_FREEFILL: rName=ImpGetResStr(STR_ObjNamePluralFREEFILL); break;
2014 		case OBJ_SPLNFILL: rName=ImpGetResStr(STR_ObjNamePluralPERSPLN); break;
2015 		default: break;
2016 	}
2017 }
2018 
TakeXorPoly() const2019 basegfx::B2DPolyPolygon SdrPathObj::TakeXorPoly() const
2020 {
2021 	return GetPathPoly();
2022 }
2023 
GetHdlCount() const2024 sal_uInt32 SdrPathObj::GetHdlCount() const
2025 {
2026 	sal_uInt32 nRetval(0L);
2027 	const sal_uInt32 nPolyCount(GetPathPoly().count());
2028 
2029 	for(sal_uInt32 a(0L); a < nPolyCount; a++)
2030 	{
2031 		nRetval += GetPathPoly().getB2DPolygon(a).count();
2032 	}
2033 
2034 	return nRetval;
2035 }
2036 
GetHdl(sal_uInt32 nHdlNum) const2037 SdrHdl* SdrPathObj::GetHdl(sal_uInt32 nHdlNum) const
2038 {
2039 	// #i73248#
2040 	// Warn the user that this is ineffective and show alternatives. Should not be used at all.
2041 	OSL_ENSURE(false, "SdrPathObj::GetHdl(): ineffective, use AddToHdlList instead (!)");
2042 
2043 	// to have an alternative, get single handle using the ineffective way
2044 	SdrHdl* pRetval = 0;
2045 	SdrHdlList aLocalList(0);
2046 	AddToHdlList(aLocalList);
2047 	const sal_uInt32 nHdlCount(aLocalList.GetHdlCount());
2048 
2049 	if(nHdlCount && nHdlNum < nHdlCount)
2050 	{
2051 		// remove and remember. The other created handles will be deleted again with the
2052 		// destruction of the local list
2053 		pRetval = aLocalList.RemoveHdl(nHdlNum);
2054 	}
2055 
2056 	return pRetval;
2057 }
2058 
AddToHdlList(SdrHdlList & rHdlList) const2059 void SdrPathObj::AddToHdlList(SdrHdlList& rHdlList) const
2060 {
2061 	// keep old stuff to be able to keep old SdrHdl stuff, too
2062 	const XPolyPolygon aOldPathPolygon(GetPathPoly());
2063 	sal_uInt16 nPolyCnt=aOldPathPolygon.Count();
2064 	FASTBOOL bClosed=IsClosed();
2065 	sal_uInt16 nIdx=0;
2066 
2067 	for (sal_uInt16 i=0; i<nPolyCnt; i++) {
2068 		const XPolygon& rXPoly=aOldPathPolygon.GetObject(i);
2069 		sal_uInt16 nPntCnt=rXPoly.GetPointCount();
2070 		if (bClosed && nPntCnt>1) nPntCnt--;
2071 
2072 		for (sal_uInt16 j=0; j<nPntCnt; j++) {
2073 			if (rXPoly.GetFlags(j)!=XPOLY_CONTROL) {
2074 				const Point& rPnt=rXPoly[j];
2075 				SdrHdl* pHdl=new SdrHdl(rPnt,HDL_POLY);
2076 				pHdl->SetPolyNum(i);
2077 				pHdl->SetPointNum(j);
2078 				pHdl->Set1PixMore(j==0);
2079 				pHdl->SetSourceHdlNum(nIdx);
2080 				nIdx++;
2081 				rHdlList.AddHdl(pHdl);
2082 			}
2083 		}
2084 	}
2085 }
2086 
GetPlusHdlCount(const SdrHdl & rHdl) const2087 sal_uInt32 SdrPathObj::GetPlusHdlCount(const SdrHdl& rHdl) const
2088 {
2089 	// keep old stuff to be able to keep old SdrHdl stuff, too
2090 	const XPolyPolygon aOldPathPolygon(GetPathPoly());
2091 	sal_uInt16 nCnt = 0;
2092 	sal_uInt16 nPnt = (sal_uInt16)rHdl.GetPointNum();
2093 	sal_uInt16 nPolyNum = (sal_uInt16)rHdl.GetPolyNum();
2094 
2095 	if(nPolyNum < aOldPathPolygon.Count())
2096 	{
2097 		const XPolygon& rXPoly = aOldPathPolygon[nPolyNum];
2098 		sal_uInt16 nPntMax = rXPoly.GetPointCount();
2099 		if (nPntMax>0)
2100 		{
2101 			nPntMax--;
2102 			if (nPnt<=nPntMax)
2103 			{
2104 				if (rXPoly.GetFlags(nPnt)!=XPOLY_CONTROL)
2105 				{
2106 					if (nPnt==0 && IsClosed()) nPnt=nPntMax;
2107 					if (nPnt>0 && rXPoly.GetFlags(nPnt-1)==XPOLY_CONTROL) nCnt++;
2108 					if (nPnt==nPntMax && IsClosed()) nPnt=0;
2109 					if (nPnt<nPntMax && rXPoly.GetFlags(nPnt+1)==XPOLY_CONTROL) nCnt++;
2110 				}
2111 			}
2112 		}
2113 	}
2114 
2115 	return nCnt;
2116 }
2117 
GetPlusHdl(const SdrHdl & rHdl,sal_uInt32 nPlusNum) const2118 SdrHdl* SdrPathObj::GetPlusHdl(const SdrHdl& rHdl, sal_uInt32 nPlusNum) const
2119 {
2120 	// keep old stuff to be able to keep old SdrHdl stuff, too
2121 	const XPolyPolygon aOldPathPolygon(GetPathPoly());
2122 	SdrHdl* pHdl = 0L;
2123 	sal_uInt16 nPnt = (sal_uInt16)rHdl.GetPointNum();
2124 	sal_uInt16 nPolyNum = (sal_uInt16)rHdl.GetPolyNum();
2125 
2126 	if (nPolyNum<aOldPathPolygon.Count())
2127 	{
2128 		const XPolygon& rXPoly = aOldPathPolygon[nPolyNum];
2129 		sal_uInt16 nPntMax = rXPoly.GetPointCount();
2130 
2131 		if (nPntMax>0)
2132 		{
2133 			nPntMax--;
2134 			if (nPnt<=nPntMax)
2135 			{
2136 				pHdl=new SdrHdlBezWgt(&rHdl);
2137 				pHdl->SetPolyNum(rHdl.GetPolyNum());
2138 
2139 				if (nPnt==0 && IsClosed()) nPnt=nPntMax;
2140 				if (nPnt>0 && rXPoly.GetFlags(nPnt-1)==XPOLY_CONTROL && nPlusNum==0)
2141 				{
2142 					pHdl->SetPos(rXPoly[nPnt-1]);
2143 					pHdl->SetPointNum(nPnt-1);
2144 				}
2145 				else
2146 				{
2147 					if (nPnt==nPntMax && IsClosed()) nPnt=0;
2148 					if (nPnt<rXPoly.GetPointCount()-1 && rXPoly.GetFlags(nPnt+1)==XPOLY_CONTROL)
2149 					{
2150 						pHdl->SetPos(rXPoly[nPnt+1]);
2151 						pHdl->SetPointNum(nPnt+1);
2152 					}
2153 				}
2154 
2155 				pHdl->SetSourceHdlNum(rHdl.GetSourceHdlNum());
2156 				pHdl->SetPlusHdl(sal_True);
2157 			}
2158 		}
2159 	}
2160 	return pHdl;
2161 }
2162 
2163 ////////////////////////////////////////////////////////////////////////////////////////////////////
2164 
hasSpecialDrag() const2165 bool SdrPathObj::hasSpecialDrag() const
2166 {
2167 	return true;
2168 }
2169 
beginSpecialDrag(SdrDragStat & rDrag) const2170 bool SdrPathObj::beginSpecialDrag(SdrDragStat& rDrag) const
2171 {
2172 	ImpPathForDragAndCreate aDragAndCreate(*((SdrPathObj*)this));
2173 
2174     return aDragAndCreate.beginPathDrag(rDrag);
2175 }
2176 
applySpecialDrag(SdrDragStat & rDrag)2177 bool SdrPathObj::applySpecialDrag(SdrDragStat& rDrag)
2178 {
2179 	ImpPathForDragAndCreate aDragAndCreate(*this);
2180     bool bRetval(aDragAndCreate.beginPathDrag(rDrag));
2181 
2182     if(bRetval)
2183     {
2184     	bRetval = aDragAndCreate.movePathDrag(rDrag);
2185     }
2186 
2187     if(bRetval)
2188     {
2189     	bRetval = aDragAndCreate.endPathDrag(rDrag);
2190     }
2191 
2192 	if(bRetval)
2193 	{
2194    		NbcSetPathPoly(aDragAndCreate.getModifiedPolyPolygon());
2195 	}
2196 
2197 	return bRetval;
2198 }
2199 
getSpecialDragComment(const SdrDragStat & rDrag) const2200 String SdrPathObj::getSpecialDragComment(const SdrDragStat& rDrag) const
2201 {
2202     String aRetval;
2203 
2204     if(mpDAC)
2205     {
2206         // #i103058# also get a comment when in creation
2207         const bool bCreateComment(rDrag.GetView() && this == rDrag.GetView()->GetCreateObj());
2208 
2209         if(bCreateComment)
2210         {
2211         	aRetval = mpDAC->getSpecialDragComment(rDrag);
2212         }
2213     }
2214     else
2215     {
2216 	    ImpPathForDragAndCreate aDragAndCreate(*((SdrPathObj*)this));
2217         bool bDidWork(aDragAndCreate.beginPathDrag((SdrDragStat&)rDrag));
2218 
2219         if(bDidWork)
2220         {
2221     	    aRetval = aDragAndCreate.getSpecialDragComment(rDrag);
2222         }
2223     }
2224 
2225     return aRetval;
2226 }
2227 
getSpecialDragPoly(const SdrDragStat & rDrag) const2228 basegfx::B2DPolyPolygon SdrPathObj::getSpecialDragPoly(const SdrDragStat& rDrag) const
2229 {
2230     basegfx::B2DPolyPolygon aRetval;
2231 	ImpPathForDragAndCreate aDragAndCreate(*((SdrPathObj*)this));
2232     bool bDidWork(aDragAndCreate.beginPathDrag((SdrDragStat&)rDrag));
2233 
2234     if(bDidWork)
2235     {
2236         aRetval = aDragAndCreate.getSpecialDragPoly(rDrag);
2237     }
2238 
2239     return aRetval;
2240 }
2241 
2242 ////////////////////////////////////////////////////////////////////////////////////////////////////
2243 
BegCreate(SdrDragStat & rStat)2244 FASTBOOL SdrPathObj::BegCreate(SdrDragStat& rStat)
2245 {
2246 	impDeleteDAC();
2247 	return impGetDAC().BegCreate(rStat);
2248 }
2249 
MovCreate(SdrDragStat & rStat)2250 FASTBOOL SdrPathObj::MovCreate(SdrDragStat& rStat)
2251 {
2252 	return impGetDAC().MovCreate(rStat);
2253 }
2254 
EndCreate(SdrDragStat & rStat,SdrCreateCmd eCmd)2255 FASTBOOL SdrPathObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
2256 {
2257 	FASTBOOL bRetval(impGetDAC().EndCreate(rStat, eCmd));
2258 
2259 	if(bRetval && mpDAC)
2260 	{
2261 		SetPathPoly(mpDAC->getModifiedPolyPolygon());
2262 
2263 		// #i75974# Check for AutoClose feature. Moved here from ImpPathForDragAndCreate::EndCreate
2264 		// to be able to use the type-changing ImpSetClosed method
2265 		if(!IsClosedObj())
2266 		{
2267 			SdrView* pView = rStat.GetView();
2268 
2269 			if(pView && pView->IsAutoClosePolys() && !pView->IsUseIncompatiblePathCreateInterface())
2270 			{
2271 				OutputDevice* pOut = pView->GetFirstOutputDevice();
2272 
2273 				if(pOut)
2274 				{
2275 					if(GetPathPoly().count())
2276 					{
2277 						const basegfx::B2DPolygon aCandidate(GetPathPoly().getB2DPolygon(0));
2278 
2279 						if(aCandidate.count() > 2)
2280 						{
2281 							// check distance of first and last point
2282 							const sal_Int32 nCloseDist(pOut->PixelToLogic(Size(pView->GetAutoCloseDistPix(), 0)).Width());
2283 							const basegfx::B2DVector aDistVector(aCandidate.getB2DPoint(aCandidate.count() - 1) - aCandidate.getB2DPoint(0));
2284 
2285 							if(aDistVector.getLength() <= (double)nCloseDist)
2286 							{
2287 								// close it
2288 								ImpSetClosed(true);
2289 							}
2290 						}
2291 					}
2292 				}
2293 			}
2294 		}
2295 
2296 		impDeleteDAC();
2297 	}
2298 
2299 	return bRetval;
2300 }
2301 
BckCreate(SdrDragStat & rStat)2302 FASTBOOL SdrPathObj::BckCreate(SdrDragStat& rStat)
2303 {
2304 	return impGetDAC().BckCreate(rStat);
2305 }
2306 
BrkCreate(SdrDragStat & rStat)2307 void SdrPathObj::BrkCreate(SdrDragStat& rStat)
2308 {
2309 	impGetDAC().BrkCreate(rStat);
2310 	impDeleteDAC();
2311 }
2312 
TakeCreatePoly(const SdrDragStat & rDrag) const2313 basegfx::B2DPolyPolygon SdrPathObj::TakeCreatePoly(const SdrDragStat& rDrag) const
2314 {
2315 	basegfx::B2DPolyPolygon aRetval;
2316 
2317 	if(mpDAC)
2318 	{
2319 		aRetval = mpDAC->TakeObjectPolyPolygon(rDrag);
2320 		aRetval.append(mpDAC->TakeDragPolyPolygon(rDrag));
2321 	}
2322 
2323 	return aRetval;
2324 }
2325 
2326 // during drag or create, allow accessing the so-far created/modified polyPolygon
getObjectPolyPolygon(const SdrDragStat & rDrag) const2327 basegfx::B2DPolyPolygon SdrPathObj::getObjectPolyPolygon(const SdrDragStat& rDrag) const
2328 {
2329 	basegfx::B2DPolyPolygon aRetval;
2330 
2331 	if(mpDAC)
2332 	{
2333 		aRetval = mpDAC->TakeObjectPolyPolygon(rDrag);
2334 	}
2335 
2336 	return aRetval;
2337 }
2338 
getDragPolyPolygon(const SdrDragStat & rDrag) const2339 basegfx::B2DPolyPolygon SdrPathObj::getDragPolyPolygon(const SdrDragStat& rDrag) const
2340 {
2341 	basegfx::B2DPolyPolygon aRetval;
2342 
2343 	if(mpDAC)
2344 	{
2345 		aRetval = mpDAC->TakeDragPolyPolygon(rDrag);
2346 	}
2347 
2348 	return aRetval;
2349 }
2350 
GetCreatePointer() const2351 Pointer SdrPathObj::GetCreatePointer() const
2352 {
2353 	return impGetDAC().GetCreatePointer();
2354 }
2355 
NbcMove(const Size & rSiz)2356 void SdrPathObj::NbcMove(const Size& rSiz)
2357 {
2358     maPathPolygon.transform(basegfx::tools::createTranslateB2DHomMatrix(rSiz.Width(), rSiz.Height()));
2359 
2360 	// #i19871# first modify locally, then call parent (to get correct SnapRect with GluePoints)
2361 	SdrTextObj::NbcMove(rSiz);
2362 }
2363 
NbcResize(const Point & rRef,const Fraction & xFact,const Fraction & yFact)2364 void SdrPathObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
2365 {
2366     basegfx::B2DHomMatrix aTrans(basegfx::tools::createTranslateB2DHomMatrix(-rRef.X(), -rRef.Y()));
2367 	aTrans = basegfx::tools::createScaleTranslateB2DHomMatrix(
2368         double(xFact), double(yFact), rRef.X(), rRef.Y()) * aTrans;
2369 	maPathPolygon.transform(aTrans);
2370 
2371 	// #i19871# first modify locally, then call parent (to get correct SnapRect with GluePoints)
2372 	SdrTextObj::NbcResize(rRef,xFact,yFact);
2373 }
2374 
NbcRotate(const Point & rRef,long nWink,double sn,double cs)2375 void SdrPathObj::NbcRotate(const Point& rRef, long nWink, double sn, double cs)
2376 {
2377     // Thank JOE, the angles are defined mirrored to the mathematical meanings
2378     const basegfx::B2DHomMatrix aTrans(basegfx::tools::createRotateAroundPoint(rRef.X(), rRef.Y(), -nWink * nPi180));
2379 	maPathPolygon.transform(aTrans);
2380 
2381 	// #i19871# first modify locally, then call parent (to get correct SnapRect with GluePoints)
2382 	SdrTextObj::NbcRotate(rRef,nWink,sn,cs);
2383 }
2384 
NbcShear(const Point & rRefPnt,long nAngle,double fTan,FASTBOOL bVShear)2385 void SdrPathObj::NbcShear(const Point& rRefPnt, long nAngle, double fTan, FASTBOOL bVShear)
2386 {
2387     basegfx::B2DHomMatrix aTrans(basegfx::tools::createTranslateB2DHomMatrix(-rRefPnt.X(), -rRefPnt.Y()));
2388 
2389     if(bVShear)
2390     {
2391         // Thank JOE, the angles are defined mirrored to the mathematical meanings
2392         aTrans.shearY(-fTan);
2393     }
2394     else
2395     {
2396         aTrans.shearX(-fTan);
2397     }
2398 
2399     aTrans.translate(rRefPnt.X(), rRefPnt.Y());
2400 	maPathPolygon.transform(aTrans);
2401 
2402 	// #i19871# first modify locally, then call parent (to get correct SnapRect with GluePoints)
2403 	SdrTextObj::NbcShear(rRefPnt,nAngle,fTan,bVShear);
2404 }
2405 
NbcMirror(const Point & rRefPnt1,const Point & rRefPnt2)2406 void SdrPathObj::NbcMirror(const Point& rRefPnt1, const Point& rRefPnt2)
2407 {
2408 	const double fDiffX(rRefPnt2.X() - rRefPnt1.X());
2409 	const double fDiffY(rRefPnt2.Y() - rRefPnt1.Y());
2410 	const double fRot(atan2(fDiffY, fDiffX));
2411     basegfx::B2DHomMatrix aTrans(basegfx::tools::createTranslateB2DHomMatrix(-rRefPnt1.X(), -rRefPnt1.Y()));
2412 	aTrans.rotate(-fRot);
2413 	aTrans.scale(1.0, -1.0);
2414 	aTrans.rotate(fRot);
2415 	aTrans.translate(rRefPnt1.X(), rRefPnt1.Y());
2416 	maPathPolygon.transform(aTrans);
2417 
2418 	// #97538# Do Joe's special handling for lines when mirroring, too
2419 	ImpForceKind();
2420 
2421 	// #i19871# first modify locally, then call parent (to get correct SnapRect with GluePoints)
2422 	SdrTextObj::NbcMirror(rRefPnt1,rRefPnt2);
2423 }
2424 
TakeUnrotatedSnapRect(Rectangle & rRect) const2425 void SdrPathObj::TakeUnrotatedSnapRect(Rectangle& rRect) const
2426 {
2427 	if(!aGeo.nDrehWink)
2428 	{
2429 		rRect = GetSnapRect();
2430 	}
2431 	else
2432 	{
2433 		XPolyPolygon aXPP(GetPathPoly());
2434 		RotateXPoly(aXPP,Point(),-aGeo.nSin,aGeo.nCos);
2435 		rRect=aXPP.GetBoundRect();
2436 		Point aTmp(rRect.TopLeft());
2437 		RotatePoint(aTmp,Point(),aGeo.nSin,aGeo.nCos);
2438 		aTmp-=rRect.TopLeft();
2439 		rRect.Move(aTmp.X(),aTmp.Y());
2440 	}
2441 }
2442 
RecalcSnapRect()2443 void SdrPathObj::RecalcSnapRect()
2444 {
2445 	if(GetPathPoly().count())
2446 	{
2447 		maSnapRect = ImpGetBoundRect(GetPathPoly());
2448 	}
2449 }
2450 
NbcSetSnapRect(const Rectangle & rRect)2451 void SdrPathObj::NbcSetSnapRect(const Rectangle& rRect)
2452 {
2453 	Rectangle aOld(GetSnapRect());
2454 
2455 	// #95736# Take RECT_EMPTY into account when calculating scale factors
2456 	long nMulX = (RECT_EMPTY == rRect.Right()) ? 0 : rRect.Right()  - rRect.Left();
2457 
2458 	long nDivX = aOld.Right()   - aOld.Left();
2459 
2460 	// #95736# Take RECT_EMPTY into account when calculating scale factors
2461 	long nMulY = (RECT_EMPTY == rRect.Bottom()) ? 0 : rRect.Bottom() - rRect.Top();
2462 
2463 	long nDivY = aOld.Bottom()  - aOld.Top();
2464 	if ( nDivX == 0 ) { nMulX = 1; nDivX = 1; }
2465 	if ( nDivY == 0 ) { nMulY = 1; nDivY = 1; }
2466 	Fraction aX(nMulX,nDivX);
2467 	Fraction aY(nMulY,nDivY);
2468 	NbcResize(aOld.TopLeft(), aX, aY);
2469 	NbcMove(Size(rRect.Left() - aOld.Left(), rRect.Top() - aOld.Top()));
2470 }
2471 
GetSnapPointCount() const2472 sal_uInt32 SdrPathObj::GetSnapPointCount() const
2473 {
2474 	return GetHdlCount();
2475 }
2476 
GetSnapPoint(sal_uInt32 nSnapPnt) const2477 Point SdrPathObj::GetSnapPoint(sal_uInt32 nSnapPnt) const
2478 {
2479 	sal_uInt32 nPoly,nPnt;
2480 	if(!PolyPolygonEditor::GetRelativePolyPoint(GetPathPoly(), nSnapPnt, nPoly, nPnt))
2481 	{
2482 		DBG_ASSERT(sal_False,"SdrPathObj::GetSnapPoint: Punkt nSnapPnt nicht vorhanden!");
2483 	}
2484 
2485 	const basegfx::B2DPoint aB2DPoint(GetPathPoly().getB2DPolygon(nPoly).getB2DPoint(nPnt));
2486 	return Point(FRound(aB2DPoint.getX()), FRound(aB2DPoint.getY()));
2487 }
2488 
IsPolyObj() const2489 sal_Bool SdrPathObj::IsPolyObj() const
2490 {
2491 	return sal_True;
2492 }
2493 
GetPointCount() const2494 sal_uInt32 SdrPathObj::GetPointCount() const
2495 {
2496 	const sal_uInt32 nPolyCount(GetPathPoly().count());
2497 	sal_uInt32 nRetval(0L);
2498 
2499 	for(sal_uInt32 a(0L); a < nPolyCount; a++)
2500 	{
2501 		nRetval += GetPathPoly().getB2DPolygon(a).count();
2502 	}
2503 
2504 	return nRetval;
2505 }
2506 
GetPoint(sal_uInt32 nHdlNum) const2507 Point SdrPathObj::GetPoint(sal_uInt32 nHdlNum) const
2508 {
2509 	Point aRetval;
2510 	sal_uInt32 nPoly,nPnt;
2511 
2512 	if(PolyPolygonEditor::GetRelativePolyPoint(GetPathPoly(), nHdlNum, nPoly, nPnt))
2513 	{
2514 		const basegfx::B2DPolygon aPoly(GetPathPoly().getB2DPolygon(nPoly));
2515 		const basegfx::B2DPoint aPoint(aPoly.getB2DPoint(nPnt));
2516 		aRetval = Point(FRound(aPoint.getX()), FRound(aPoint.getY()));
2517 	}
2518 
2519 	return aRetval;
2520 }
2521 
NbcSetPoint(const Point & rPnt,sal_uInt32 nHdlNum)2522 void SdrPathObj::NbcSetPoint(const Point& rPnt, sal_uInt32 nHdlNum)
2523 {
2524 	sal_uInt32 nPoly,nPnt;
2525 
2526 	if(PolyPolygonEditor::GetRelativePolyPoint(GetPathPoly(), nHdlNum, nPoly, nPnt))
2527 	{
2528 		basegfx::B2DPolygon aNewPolygon(GetPathPoly().getB2DPolygon(nPoly));
2529 		aNewPolygon.setB2DPoint(nPnt, basegfx::B2DPoint(rPnt.X(), rPnt.Y()));
2530 		maPathPolygon.setB2DPolygon(nPoly, aNewPolygon);
2531 
2532 		if(meKind==OBJ_LINE)
2533 		{
2534 			ImpForceLineWink();
2535 		}
2536 		else
2537 		{
2538 			if(GetPathPoly().count())
2539 			{
2540 				// #i10659# for SdrTextObj, keep aRect up to date
2541 				aRect = ImpGetBoundRect(GetPathPoly()); // fuer SdrTextObj#
2542 			}
2543 		}
2544 
2545 		SetRectsDirty();
2546 	}
2547 }
2548 
NbcInsPointOld(const Point & rPos,sal_Bool bNewObj,sal_Bool bHideHim)2549 sal_uInt32 SdrPathObj::NbcInsPointOld(const Point& rPos, sal_Bool bNewObj, sal_Bool bHideHim)
2550 {
2551 	sal_uInt32 nNewHdl;
2552 
2553 	if(bNewObj)
2554 	{
2555 		nNewHdl = NbcInsPoint(0L, rPos, sal_True, bHideHim);
2556 	}
2557 	else
2558 	{
2559 		// look for smallest distance data
2560 		const basegfx::B2DPoint aTestPoint(rPos.X(), rPos.Y());
2561 		sal_uInt32 nSmallestPolyIndex(0L);
2562 		sal_uInt32 nSmallestEdgeIndex(0L);
2563 		double fSmallestCut;
2564 		basegfx::tools::getSmallestDistancePointToPolyPolygon(GetPathPoly(), aTestPoint, nSmallestPolyIndex, nSmallestEdgeIndex, fSmallestCut);
2565 
2566 		// create old polygon index from it
2567 		sal_uInt32 nPolyIndex(nSmallestEdgeIndex);
2568 
2569 		for(sal_uInt32 a(0L); a < nSmallestPolyIndex; a++)
2570 		{
2571 			nPolyIndex += GetPathPoly().getB2DPolygon(a).count();
2572 		}
2573 
2574 		nNewHdl = NbcInsPoint(nPolyIndex, rPos, sal_False, bHideHim);
2575 	}
2576 
2577 	ImpForceKind();
2578 	return nNewHdl;
2579 }
2580 
NbcInsPoint(sal_uInt32,const Point & rPos,sal_Bool bNewObj,sal_Bool)2581 sal_uInt32 SdrPathObj::NbcInsPoint(sal_uInt32 /*nHdlNum*/, const Point& rPos, sal_Bool bNewObj, sal_Bool /*bHideHim*/)
2582 {
2583 	sal_uInt32 nNewHdl;
2584 
2585 	if(bNewObj)
2586 	{
2587 		basegfx::B2DPolygon aNewPoly;
2588 		const basegfx::B2DPoint aPoint(rPos.X(), rPos.Y());
2589 		aNewPoly.append(aPoint);
2590 		aNewPoly.setClosed(IsClosed());
2591 		maPathPolygon.append(aNewPoly);
2592 		SetRectsDirty();
2593 		nNewHdl = GetHdlCount();
2594 	}
2595 	else
2596 	{
2597 		// look for smallest distance data
2598 		const basegfx::B2DPoint aTestPoint(rPos.X(), rPos.Y());
2599 		sal_uInt32 nSmallestPolyIndex(0L);
2600 		sal_uInt32 nSmallestEdgeIndex(0L);
2601 		double fSmallestCut;
2602 		basegfx::tools::getSmallestDistancePointToPolyPolygon(GetPathPoly(), aTestPoint, nSmallestPolyIndex, nSmallestEdgeIndex, fSmallestCut);
2603 		basegfx::B2DPolygon aCandidate(GetPathPoly().getB2DPolygon(nSmallestPolyIndex));
2604 		const bool bBefore(!aCandidate.isClosed() && 0L == nSmallestEdgeIndex && 0.0 == fSmallestCut);
2605 		const bool bAfter(!aCandidate.isClosed() && aCandidate.count() == nSmallestEdgeIndex + 2L && 1.0 == fSmallestCut);
2606 
2607 		if(bBefore)
2608 		{
2609 			// before first point
2610 			aCandidate.insert(0L, aTestPoint);
2611 
2612 			if(aCandidate.areControlPointsUsed())
2613 			{
2614 				if(aCandidate.isNextControlPointUsed(1))
2615 				{
2616 					aCandidate.setNextControlPoint(0, interpolate(aTestPoint, aCandidate.getB2DPoint(1), (1.0 / 3.0)));
2617 					aCandidate.setPrevControlPoint(1, interpolate(aTestPoint, aCandidate.getB2DPoint(1), (2.0 / 3.0)));
2618 				}
2619 			}
2620 
2621 			nNewHdl = 0L;
2622 		}
2623 		else if(bAfter)
2624 		{
2625 			// after last point
2626 			aCandidate.append(aTestPoint);
2627 
2628 			if(aCandidate.areControlPointsUsed())
2629 			{
2630 				if(aCandidate.isPrevControlPointUsed(aCandidate.count() - 2))
2631 				{
2632 					aCandidate.setNextControlPoint(aCandidate.count() - 2, interpolate(aCandidate.getB2DPoint(aCandidate.count() - 2), aTestPoint, (1.0 / 3.0)));
2633 					aCandidate.setPrevControlPoint(aCandidate.count() - 1, interpolate(aCandidate.getB2DPoint(aCandidate.count() - 2), aTestPoint, (2.0 / 3.0)));
2634 				}
2635 			}
2636 
2637 			nNewHdl = aCandidate.count() - 1L;
2638 		}
2639 		else
2640 		{
2641 			// in between
2642 			bool bSegmentSplit(false);
2643 			const sal_uInt32 nNextIndex((nSmallestEdgeIndex + 1) % aCandidate.count());
2644 
2645 			if(aCandidate.areControlPointsUsed())
2646 			{
2647 				if(aCandidate.isNextControlPointUsed(nSmallestEdgeIndex) || aCandidate.isPrevControlPointUsed(nNextIndex))
2648 				{
2649 					bSegmentSplit = true;
2650 				}
2651 			}
2652 
2653 			if(bSegmentSplit)
2654 			{
2655 				// rebuild original segment to get the split data
2656 				basegfx::B2DCubicBezier aBezierA, aBezierB;
2657 				const basegfx::B2DCubicBezier aBezier(
2658 					aCandidate.getB2DPoint(nSmallestEdgeIndex),
2659 					aCandidate.getNextControlPoint(nSmallestEdgeIndex),
2660 					aCandidate.getPrevControlPoint(nNextIndex),
2661 					aCandidate.getB2DPoint(nNextIndex));
2662 
2663 				// split and insert hit point
2664 				aBezier.split(fSmallestCut, &aBezierA, &aBezierB);
2665 				aCandidate.insert(nSmallestEdgeIndex + 1, aTestPoint);
2666 
2667 				// since we inserted hit point and not split point, we need to add an offset
2668 				// to the control points to get the C1 continuity we want to achieve
2669 				const basegfx::B2DVector aOffset(aTestPoint - aBezierA.getEndPoint());
2670 				aCandidate.setNextControlPoint(nSmallestEdgeIndex, aBezierA.getControlPointA() + aOffset);
2671 				aCandidate.setPrevControlPoint(nSmallestEdgeIndex + 1, aBezierA.getControlPointB() + aOffset);
2672 				aCandidate.setNextControlPoint(nSmallestEdgeIndex + 1, aBezierB.getControlPointA() + aOffset);
2673 				aCandidate.setPrevControlPoint((nSmallestEdgeIndex + 2) % aCandidate.count(), aBezierB.getControlPointB() + aOffset);
2674 			}
2675 			else
2676 			{
2677 				aCandidate.insert(nSmallestEdgeIndex + 1L, aTestPoint);
2678 			}
2679 
2680 			nNewHdl = nSmallestEdgeIndex + 1L;
2681 		}
2682 
2683 		maPathPolygon.setB2DPolygon(nSmallestPolyIndex, aCandidate);
2684 
2685 		// create old polygon index from it
2686 		for(sal_uInt32 a(0L); a < nSmallestPolyIndex; a++)
2687 		{
2688 			nNewHdl += GetPathPoly().getB2DPolygon(a).count();
2689 		}
2690 	}
2691 
2692 	ImpForceKind();
2693 	return nNewHdl;
2694 }
2695 
RipPoint(sal_uInt32 nHdlNum,sal_uInt32 & rNewPt0Index)2696 SdrObject* SdrPathObj::RipPoint(sal_uInt32 nHdlNum, sal_uInt32& rNewPt0Index)
2697 {
2698 	SdrPathObj* pNewObj = 0L;
2699 	const basegfx::B2DPolyPolygon aLocalPolyPolygon(GetPathPoly());
2700 	sal_uInt32 nPoly, nPnt;
2701 
2702 	if(PolyPolygonEditor::GetRelativePolyPoint(aLocalPolyPolygon, nHdlNum, nPoly, nPnt))
2703 	{
2704 		if(0L == nPoly)
2705 		{
2706 			const basegfx::B2DPolygon aCandidate(aLocalPolyPolygon.getB2DPolygon(nPoly));
2707 			const sal_uInt32 nPointCount(aCandidate.count());
2708 
2709 			if(nPointCount)
2710 			{
2711 				if(IsClosed())
2712 				{
2713 					// when closed, RipPoint means to open the polygon at the selected point. To
2714 					// be able to do that, it is necessary to make the selected point the first one
2715 					basegfx::B2DPolygon aNewPolygon(basegfx::tools::makeStartPoint(aCandidate, nPnt));
2716 					SetPathPoly(basegfx::B2DPolyPolygon(aNewPolygon));
2717 					ToggleClosed();
2718 
2719 					// give back new position of old start point (historical reasons)
2720 					rNewPt0Index = (nPointCount - nPnt) % nPointCount;
2721 				}
2722 				else
2723 				{
2724 					if(nPointCount >= 3L && nPnt != 0L && nPnt + 1L < nPointCount)
2725 					{
2726 						// split in two objects at point nPnt
2727 						basegfx::B2DPolygon aSplitPolyA(aCandidate, 0L, nPnt + 1L);
2728 						SetPathPoly(basegfx::B2DPolyPolygon(aSplitPolyA));
2729 
2730 						pNewObj = (SdrPathObj*)Clone();
2731 						basegfx::B2DPolygon aSplitPolyB(aCandidate, nPnt, nPointCount - nPnt);
2732 						pNewObj->SetPathPoly(basegfx::B2DPolyPolygon(aSplitPolyB));
2733 					}
2734 				}
2735 			}
2736 		}
2737 	}
2738 
2739 	return pNewObj;
2740 }
2741 
DoConvertToPolyObj(sal_Bool bBezier,bool bAddText) const2742 SdrObject* SdrPathObj::DoConvertToPolyObj(sal_Bool bBezier, bool bAddText) const
2743 {
2744     // #i89784# check for FontWork with activated HideContour
2745     const drawinglayer::attribute::SdrTextAttribute aText(
2746 		drawinglayer::primitive2d::createNewSdrTextAttribute(GetObjectItemSet(), *getText(0)));
2747     const bool bHideContour(
2748 		!aText.isDefault() && !aText.getSdrFormTextAttribute().isDefault() && aText.isHideContour());
2749 
2750     SdrObject* pRet = bHideContour ?
2751         0 :
2752         ImpConvertMakeObj(GetPathPoly(), IsClosed(), bBezier);
2753 
2754     SdrPathObj* pPath = PTR_CAST(SdrPathObj, pRet);
2755 
2756 	if(pPath)
2757 	{
2758 		if(pPath->GetPathPoly().areControlPointsUsed())
2759 		{
2760 			if(!bBezier)
2761 			{
2762 				// reduce all bezier curves
2763 				pPath->SetPathPoly(basegfx::tools::adaptiveSubdivideByAngle(pPath->GetPathPoly()));
2764 			}
2765 		}
2766 		else
2767 		{
2768 			if(bBezier)
2769 			{
2770 				// create bezier curves
2771 				pPath->SetPathPoly(basegfx::tools::expandToCurve(pPath->GetPathPoly()));
2772 			}
2773 		}
2774 	}
2775 
2776     if(bAddText)
2777     {
2778     	pRet = ImpConvertAddText(pRet, bBezier);
2779     }
2780 
2781 	return pRet;
2782 }
2783 
NewGeoData() const2784 SdrObjGeoData* SdrPathObj::NewGeoData() const
2785 {
2786 	return new SdrPathObjGeoData;
2787 }
2788 
SaveGeoData(SdrObjGeoData & rGeo) const2789 void SdrPathObj::SaveGeoData(SdrObjGeoData& rGeo) const
2790 {
2791 	SdrTextObj::SaveGeoData(rGeo);
2792 	SdrPathObjGeoData& rPGeo = (SdrPathObjGeoData&) rGeo;
2793 	rPGeo.maPathPolygon=GetPathPoly();
2794 	rPGeo.meKind=meKind;
2795 }
2796 
RestGeoData(const SdrObjGeoData & rGeo)2797 void SdrPathObj::RestGeoData(const SdrObjGeoData& rGeo)
2798 {
2799 	SdrTextObj::RestGeoData(rGeo);
2800 	SdrPathObjGeoData& rPGeo=(SdrPathObjGeoData&)rGeo;
2801 	maPathPolygon=rPGeo.maPathPolygon;
2802 	meKind=rPGeo.meKind;
2803 	ImpForceKind(); // damit u.a. bClosed gesetzt wird
2804 }
2805 
NbcSetPathPoly(const basegfx::B2DPolyPolygon & rPathPoly)2806 void SdrPathObj::NbcSetPathPoly(const basegfx::B2DPolyPolygon& rPathPoly)
2807 {
2808 	if(GetPathPoly() != rPathPoly)
2809 	{
2810 		maPathPolygon=rPathPoly;
2811 		ImpForceKind();
2812 		SetRectsDirty();
2813 	}
2814 }
2815 
SetPathPoly(const basegfx::B2DPolyPolygon & rPathPoly)2816 void SdrPathObj::SetPathPoly(const basegfx::B2DPolyPolygon& rPathPoly)
2817 {
2818 	if(GetPathPoly() != rPathPoly)
2819 	{
2820 		Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
2821 		NbcSetPathPoly(rPathPoly);
2822 		SetChanged();
2823 		BroadcastObjectChange();
2824 		SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
2825 	}
2826 }
2827 
ToggleClosed()2828 void SdrPathObj::ToggleClosed() // long nOpenDistance)
2829 {
2830 	Rectangle aBoundRect0;
2831 	if(pUserCall != NULL)
2832 		aBoundRect0 = GetLastBoundRect();
2833 	ImpSetClosed(!IsClosed()); // neuen ObjKind setzen
2834 	ImpForceKind(); // wg. Line->Poly->PolyLine statt Line->Poly->Line
2835 	SetRectsDirty();
2836 	SetChanged();
2837 	BroadcastObjectChange();
2838 	SendUserCall(SDRUSERCALL_RESIZE, aBoundRect0);
2839 }
2840 
2841 // fuer friend class SdrPolyEditView auf einigen Compilern:
SetRectsDirty(sal_Bool bNotMyself)2842 void SdrPathObj::SetRectsDirty(sal_Bool bNotMyself)
2843 {
2844 	SdrTextObj::SetRectsDirty(bNotMyself);
2845 }
2846 
impGetDAC() const2847 ImpPathForDragAndCreate& SdrPathObj::impGetDAC() const
2848 {
2849 	if(!mpDAC)
2850 	{
2851 		((SdrPathObj*)this)->mpDAC = new ImpPathForDragAndCreate(*((SdrPathObj*)this));
2852 	}
2853 
2854 	return *mpDAC;
2855 }
2856 
impDeleteDAC() const2857 void SdrPathObj::impDeleteDAC() const
2858 {
2859 	if(mpDAC)
2860 	{
2861 		delete mpDAC;
2862 		((SdrPathObj*)this)->mpDAC = 0L;
2863 	}
2864 }
2865 
2866 ////////////////////////////////////////////////////////////////////////////////////////////////////
2867 //
2868 // transformation interface for StarOfficeAPI. This implements support for
2869 // homogen 3x3 matrices containing the transformation of the SdrObject. At the
2870 // moment it contains a shearX, rotation and translation, but for setting all linear
2871 // transforms like Scale, ShearX, ShearY, Rotate and Translate are supported.
2872 //
2873 ////////////////////////////////////////////////////////////////////////////////////////////////////
2874 // gets base transformation and rectangle of object. If it's an SdrPathObj it fills the PolyPolygon
2875 // with the base geometry and returns TRUE. Otherwise it returns FALSE.
TRGetBaseGeometry(basegfx::B2DHomMatrix & rMatrix,basegfx::B2DPolyPolygon & rPolyPolygon) const2876 sal_Bool SdrPathObj::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& rPolyPolygon) const
2877 {
2878 	double fRotate(0.0);
2879 	double fShearX(0.0);
2880 	basegfx::B2DTuple aScale(1.0, 1.0);
2881 	basegfx::B2DTuple aTranslate(0.0, 0.0);
2882 
2883 	if(GetPathPoly().count())
2884 	{
2885 		// copy geometry
2886 		basegfx::B2DHomMatrix aMoveToZeroMatrix;
2887 		rPolyPolygon = GetPathPoly();
2888 
2889 		if(OBJ_LINE == meKind)
2890 		{
2891 			// ignore shear and rotate, just use scale and translate
2892 			OSL_ENSURE(GetPathPoly().count() > 0L && GetPathPoly().getB2DPolygon(0L).count() > 1L, "OBJ_LINE with too less polygons (!)");
2893 			// #i72287# use polygon without control points for range calculation. Do not change rPolyPolygon
2894 			// itself, else this method will no longer return the full polygon information (curve will
2895 			// be lost)
2896 			const basegfx::B2DRange aPolyRangeNoCurve(basegfx::tools::getRange(rPolyPolygon));
2897 			aScale = aPolyRangeNoCurve.getRange();
2898 			aTranslate = aPolyRangeNoCurve.getMinimum();
2899 
2900 			// define matrix for move polygon to zero point
2901 			aMoveToZeroMatrix.translate(-aTranslate.getX(), -aTranslate.getY());
2902 		}
2903 		else
2904 		{
2905 			if(aGeo.nShearWink || aGeo.nDrehWink)
2906 			{
2907 				// get rotate and shear in drawingLayer notation
2908 				fRotate = aGeo.nDrehWink * F_PI18000;
2909 				fShearX = aGeo.nShearWink * F_PI18000;
2910 
2911 				// build mathematically correct (negative shear and rotate) object transform
2912 				// containing shear and rotate to extract unsheared, unrotated polygon
2913 				basegfx::B2DHomMatrix aObjectMatrix;
2914 				aObjectMatrix.shearX(tan((36000 - aGeo.nShearWink) * F_PI18000));
2915 				aObjectMatrix.rotate((36000 - aGeo.nDrehWink) * F_PI18000);
2916 
2917 				// create inverse from it and back-transform polygon
2918 				basegfx::B2DHomMatrix aInvObjectMatrix(aObjectMatrix);
2919 				aInvObjectMatrix.invert();
2920 				rPolyPolygon.transform(aInvObjectMatrix);
2921 
2922 				// get range from unsheared, unrotated polygon and extract scale and translate.
2923 				// transform topLeft from it back to transformed state to get original
2924 				// topLeft (rotation center)
2925 				// #i72287# use polygon without control points for range calculation. Do not change rPolyPolygon
2926 				// itself, else this method will no longer return the full polygon information (curve will
2927 				// be lost)
2928 				const basegfx::B2DRange aCorrectedRangeNoCurve(basegfx::tools::getRange(rPolyPolygon));
2929 				aTranslate = aObjectMatrix * aCorrectedRangeNoCurve.getMinimum();
2930 				aScale = aCorrectedRangeNoCurve.getRange();
2931 
2932 				// define matrix for move polygon to zero point
2933                 // #i112280# Added missing minus for Y-Translation
2934 				aMoveToZeroMatrix.translate(-aCorrectedRangeNoCurve.getMinX(), -aCorrectedRangeNoCurve.getMinY());
2935 			}
2936 			else
2937 			{
2938 				// get scale and translate from unsheared, unrotated polygon
2939 				// #i72287# use polygon without control points for range calculation. Do not change rPolyPolygon
2940 				// itself, else this method will no longer return the full polygon information (curve will
2941 				// be lost)
2942 				const basegfx::B2DRange aPolyRangeNoCurve(basegfx::tools::getRange(rPolyPolygon));
2943 				aScale = aPolyRangeNoCurve.getRange();
2944 				aTranslate = aPolyRangeNoCurve.getMinimum();
2945 
2946 				// define matrix for move polygon to zero point
2947 				aMoveToZeroMatrix.translate(-aTranslate.getX(), -aTranslate.getY());
2948 			}
2949 		}
2950 
2951 		// move polygon to zero point with pre-defined matrix
2952 		rPolyPolygon.transform(aMoveToZeroMatrix);
2953 	}
2954 
2955 	// position maybe relative to anchorpos, convert
2956 	if( pModel && pModel->IsWriter() )
2957 	{
2958 		if(GetAnchorPos().X() || GetAnchorPos().Y())
2959 		{
2960 			aTranslate -= basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
2961 		}
2962 	}
2963 
2964 	// force MapUnit to 100th mm
2965 	const SfxMapUnit eMapUnit(GetObjectMapUnit());
2966 	if(eMapUnit != SFX_MAPUNIT_100TH_MM)
2967 	{
2968 		switch(eMapUnit)
2969 		{
2970 			case SFX_MAPUNIT_TWIP :
2971 			{
2972 				// postion
2973 				aTranslate.setX(ImplTwipsToMM(aTranslate.getX()));
2974 				aTranslate.setY(ImplTwipsToMM(aTranslate.getY()));
2975 
2976 				// size
2977 				aScale.setX(ImplTwipsToMM(aScale.getX()));
2978 				aScale.setY(ImplTwipsToMM(aScale.getY()));
2979 
2980 				// polygon
2981 				basegfx::B2DHomMatrix aTwipsToMM;
2982 				const double fFactorTwipsToMM(127.0 / 72.0);
2983 				aTwipsToMM.scale(fFactorTwipsToMM, fFactorTwipsToMM);
2984 				rPolyPolygon.transform(aTwipsToMM);
2985 
2986 				break;
2987 			}
2988 			default:
2989 			{
2990 				DBG_ERROR("TRGetBaseGeometry: Missing unit translation to 100th mm!");
2991 			}
2992 		}
2993 	}
2994 
2995 	// build return value matrix
2996 	rMatrix = basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
2997 		aScale,
2998 		basegfx::fTools::equalZero(fShearX) ? 0.0 : tan(fShearX),
2999 		basegfx::fTools::equalZero(fRotate) ? 0.0 : -fRotate,
3000 		aTranslate);
3001 
3002 	return sal_True;
3003 }
3004 
3005 // sets the base geometry of the object using infos contained in the homogen 3x3 matrix.
3006 // If it's an SdrPathObj it will use the provided geometry information. The Polygon has
3007 // to use (0,0) as upper left and will be scaled to the given size in the matrix.
TRSetBaseGeometry(const basegfx::B2DHomMatrix & rMatrix,const basegfx::B2DPolyPolygon & rPolyPolygon)3008 void SdrPathObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& rPolyPolygon)
3009 {
3010 	// break up matrix
3011 	basegfx::B2DTuple aScale;
3012 	basegfx::B2DTuple aTranslate;
3013 	double fRotate, fShearX;
3014 	rMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
3015 
3016 	// #i75086# Old DrawingLayer (GeoStat and geometry) does not support holding negative scalings
3017 	// in X and Y which equal a 180 degree rotation. Recognize it and react accordingly
3018 	if(basegfx::fTools::less(aScale.getX(), 0.0) && basegfx::fTools::less(aScale.getY(), 0.0))
3019 	{
3020 		aScale.setX(fabs(aScale.getX()));
3021 		aScale.setY(fabs(aScale.getY()));
3022 		fRotate = fmod(fRotate + F_PI, F_2PI);
3023 	}
3024 
3025 	// copy poly
3026 	basegfx::B2DPolyPolygon aNewPolyPolygon(rPolyPolygon);
3027 
3028 	// reset object shear and rotations
3029 	aGeo.nDrehWink = 0;
3030 	aGeo.RecalcSinCos();
3031 	aGeo.nShearWink = 0;
3032 	aGeo.RecalcTan();
3033 
3034 	// force metric to pool metric
3035 	const SfxMapUnit eMapUnit(GetObjectMapUnit());
3036 	if(eMapUnit != SFX_MAPUNIT_100TH_MM)
3037 	{
3038 		switch(eMapUnit)
3039 		{
3040 			case SFX_MAPUNIT_TWIP :
3041 			{
3042 				// position
3043 				aTranslate.setX(ImplMMToTwips(aTranslate.getX()));
3044 				aTranslate.setY(ImplMMToTwips(aTranslate.getY()));
3045 
3046 				// size
3047 				aScale.setX(ImplMMToTwips(aScale.getX()));
3048 				aScale.setY(ImplMMToTwips(aScale.getY()));
3049 
3050 				// polygon
3051 				basegfx::B2DHomMatrix aMMToTwips;
3052 				const double fFactorMMToTwips(72.0 / 127.0);
3053 				aMMToTwips.scale(fFactorMMToTwips, fFactorMMToTwips);
3054 				aNewPolyPolygon.transform(aMMToTwips);
3055 
3056 				break;
3057 			}
3058 			default:
3059 			{
3060 				DBG_ERROR("TRSetBaseGeometry: Missing unit translation to PoolMetric!");
3061 			}
3062 		}
3063 	}
3064 
3065 	if( pModel && pModel->IsWriter() )
3066 	{
3067 		// if anchor is used, make position relative to it
3068 		if(GetAnchorPos().X() || GetAnchorPos().Y())
3069 		{
3070 			aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
3071 		}
3072 	}
3073 
3074 	// create transformation for polygon, set values at aGeo direct
3075 	basegfx::B2DHomMatrix aTransform;
3076 
3077 	// #i75086#
3078 	// Given polygon is already scaled (for historical reasons), but not mirrored yet.
3079 	// Thus, when scale is negative in X or Y, apply the needed mirroring accordingly.
3080 	if(basegfx::fTools::less(aScale.getX(), 0.0) || basegfx::fTools::less(aScale.getY(), 0.0))
3081 	{
3082 		aTransform.scale(
3083 			basegfx::fTools::less(aScale.getX(), 0.0) ? -1.0 : 1.0,
3084 			basegfx::fTools::less(aScale.getY(), 0.0) ? -1.0 : 1.0);
3085 	}
3086 
3087 	if(!basegfx::fTools::equalZero(fShearX))
3088 	{
3089 		aTransform.shearX(tan(-atan(fShearX)));
3090 		aGeo.nShearWink = FRound(atan(fShearX) / F_PI18000);
3091 		aGeo.RecalcTan();
3092 	}
3093 
3094 	if(!basegfx::fTools::equalZero(fRotate))
3095 	{
3096         // #i78696#
3097         // fRotate is matematically correct for linear transformations, so it's
3098         // the one to use for the geometry change
3099 		aTransform.rotate(fRotate);
3100 
3101         // #i78696#
3102         // fRotate is matematically correct, but aGeoStat.nDrehWink is
3103         // mirrored -> mirror value here
3104 		aGeo.nDrehWink = NormAngle360(FRound(-fRotate / F_PI18000));
3105 		aGeo.RecalcSinCos();
3106 	}
3107 
3108     if(!aTranslate.equalZero())
3109 	{
3110 		// #i39529# absolute positioning, so get current position (without control points (!))
3111 		const basegfx::B2DRange aCurrentRange(basegfx::tools::getRange(aNewPolyPolygon));
3112 		aTransform.translate(aTranslate.getX() - aCurrentRange.getMinX(), aTranslate.getY() - aCurrentRange.getMinY());
3113 	}
3114 
3115 	// transform polygon and trigger change
3116 	aNewPolyPolygon.transform(aTransform);
3117 	SetPathPoly(aNewPolyPolygon);
3118 }
3119 
3120 //////////////////////////////////////////////////////////////////////////////
3121 // eof
3122