xref: /aoo41x/main/svx/source/svdraw/svdoedge.cxx (revision dc87ec34)
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 <svx/svdoedge.hxx>
28 #include <svx/xpool.hxx>
29 #include <svx/xpoly.hxx>
30 #include <svx/svdattrx.hxx>
31 #include <svx/svdpool.hxx>
32 #include <svx/svdmodel.hxx>
33 #include <svx/svdpage.hxx>
34 #include <svx/svdpagv.hxx>
35 #include <svx/svdview.hxx>
36 #include <svx/svddrag.hxx>
37 #include <svx/svddrgv.hxx>
38 #include "svddrgm1.hxx"
39 #include <svx/svdhdl.hxx>
40 #include <svx/svdtrans.hxx>
41 #include <svx/svdetc.hxx>
42 #include "svx/svdglob.hxx"   // StringCache
43 #include "svx/svdstr.hrc"    // Objektname
44 #include <svl/style.hxx>
45 #include <svl/smplhint.hxx>
46 #include <editeng/eeitem.hxx>
47 #include "svdoimp.hxx"
48 #include <svx/sdr/properties/connectorproperties.hxx>
49 #include <svx/sdr/contact/viewcontactofsdredgeobj.hxx>
50 #include <basegfx/polygon/b2dpolygon.hxx>
51 #include <basegfx/polygon/b2dpolygontools.hxx>
52 #include <basegfx/matrix/b2dhommatrix.hxx>
53 #include <svx/sdrhittesthelper.hxx>
54 
55 ////////////////////////////////////////////////////////////////////////////////////////////////////
56 
57 SdrObjConnection::~SdrObjConnection()
58 {
59 }
60 
61 void SdrObjConnection::ResetVars()
62 {
63 	pObj=NULL;
64 	nConId=0;
65 	nXDist=0;
66 	nYDist=0;
67 	bBestConn=sal_True;
68 	bBestVertex=sal_True;
69 	bXDistOvr=sal_False;
70 	bYDistOvr=sal_False;
71 	bAutoVertex=sal_False;
72 	bAutoCorner=sal_False;
73 }
74 
75 FASTBOOL SdrObjConnection::TakeGluePoint(SdrGluePoint& rGP, FASTBOOL bSetAbsPos) const
76 {
77 	FASTBOOL bRet=sal_False;
78 	if (pObj!=NULL) { // Ein Obj muss schon angedockt sein!
79 		if (bAutoVertex) {
80 			rGP=pObj->GetVertexGluePoint(nConId);
81 			bRet=sal_True;
82 		} else if (bAutoCorner) {
83 			rGP=pObj->GetCornerGluePoint(nConId);
84 			bRet=sal_True;
85 		} else {
86 			const SdrGluePointList* pGPL=pObj->GetGluePointList();
87 			if (pGPL!=NULL) {
88 				sal_uInt16 nNum=pGPL->FindGluePoint(nConId);
89 				if (nNum!=SDRGLUEPOINT_NOTFOUND) {
90 					rGP=(*pGPL)[nNum];
91 					bRet=sal_True;
92 				}
93 			}
94 		}
95 	}
96 	if (bRet && bSetAbsPos) {
97 		Point aPt(rGP.GetAbsolutePos(*pObj));
98 		aPt+=aObjOfs;
99 		rGP.SetPos(aPt);
100 	}
101 	return bRet;
102 }
103 
104 Point& SdrEdgeInfoRec::ImpGetLineVersatzPoint(SdrEdgeLineCode eLineCode)
105 {
106 	switch (eLineCode) {
107 		case OBJ1LINE2 : return aObj1Line2;
108 		case OBJ1LINE3 : return aObj1Line3;
109 		case OBJ2LINE2 : return aObj2Line2;
110 		case OBJ2LINE3 : return aObj2Line3;
111 		case MIDDLELINE: return aMiddleLine;
112 	} // switch
113 	return aMiddleLine;
114 }
115 
116 sal_uInt16 SdrEdgeInfoRec::ImpGetPolyIdx(SdrEdgeLineCode eLineCode, const XPolygon& rXP) const
117 {
118 	switch (eLineCode) {
119 		case OBJ1LINE2 : return 1;
120 		case OBJ1LINE3 : return 2;
121 		case OBJ2LINE2 : return rXP.GetPointCount()-3;
122 		case OBJ2LINE3 : return rXP.GetPointCount()-4;
123 		case MIDDLELINE: return nMiddleLine;
124 	} // switch
125 	return 0;
126 }
127 
128 FASTBOOL SdrEdgeInfoRec::ImpIsHorzLine(SdrEdgeLineCode eLineCode, const XPolygon& rXP) const
129 {
130 	sal_uInt16 nIdx=ImpGetPolyIdx(eLineCode,rXP);
131 	FASTBOOL bHorz=nAngle1==0 || nAngle1==18000;
132 	if (eLineCode==OBJ2LINE2 || eLineCode==OBJ2LINE3) {
133 		nIdx=rXP.GetPointCount()-nIdx; // #36314#
134 		bHorz=nAngle2==0 || nAngle2==18000; // #52000#
135 	}
136 	if ((nIdx & 1)==1) bHorz=!bHorz;
137 	return bHorz;
138 }
139 
140 void SdrEdgeInfoRec::ImpSetLineVersatz(SdrEdgeLineCode eLineCode, const XPolygon& rXP, long nVal)
141 {
142 	Point& rPt=ImpGetLineVersatzPoint(eLineCode);
143 	if (ImpIsHorzLine(eLineCode,rXP)) rPt.Y()=nVal;
144 	else rPt.X()=nVal;
145 }
146 
147 long SdrEdgeInfoRec::ImpGetLineVersatz(SdrEdgeLineCode eLineCode, const XPolygon& rXP) const
148 {
149 	const Point& rPt=ImpGetLineVersatzPoint(eLineCode);
150 	if (ImpIsHorzLine(eLineCode,rXP)) return rPt.Y();
151 	else return rPt.X();
152 }
153 
154 //////////////////////////////////////////////////////////////////////////////
155 // BaseProperties section
156 
157 sdr::properties::BaseProperties* SdrEdgeObj::CreateObjectSpecificProperties()
158 {
159 	return new sdr::properties::ConnectorProperties(*this);
160 }
161 
162 //////////////////////////////////////////////////////////////////////////////
163 // DrawContact section
164 
165 sdr::contact::ViewContact* SdrEdgeObj::CreateObjectSpecificViewContact()
166 {
167 	return new sdr::contact::ViewContactOfSdrEdgeObj(*this);
168 }
169 
170 //////////////////////////////////////////////////////////////////////////////
171 
172 TYPEINIT1(SdrEdgeObj,SdrTextObj);
173 
174 SdrEdgeObj::SdrEdgeObj()
175 :	SdrTextObj(),
176 	nNotifyingCount(0),
177 	bEdgeTrackDirty(sal_False),
178 	bEdgeTrackUserDefined(sal_False),
179 	// #109007# Default is to allow default connects
180 	mbSuppressDefaultConnect(sal_False),
181 	// #110649#
182 	mbBoundRectCalculationRunning(sal_False),
183     mbSuppressed(false)
184 {
185 	bClosedObj=sal_False;
186 	bIsEdge=sal_True;
187 	pEdgeTrack=new XPolygon;
188 
189 }
190 
191 SdrEdgeObj::~SdrEdgeObj()
192 {
193 	DisconnectFromNode(sal_True);
194 	DisconnectFromNode(sal_False);
195 	delete pEdgeTrack;
196 }
197 
198 void SdrEdgeObj::ImpSetAttrToEdgeInfo()
199 {
200 	const SfxItemSet& rSet = GetObjectItemSet();
201 	SdrEdgeKind eKind = ((SdrEdgeKindItem&)(rSet.Get(SDRATTR_EDGEKIND))).GetValue();
202 	sal_Int32 nVal1 = ((SdrEdgeLine1DeltaItem&)rSet.Get(SDRATTR_EDGELINE1DELTA)).GetValue();
203 	sal_Int32 nVal2 = ((SdrEdgeLine2DeltaItem&)rSet.Get(SDRATTR_EDGELINE2DELTA)).GetValue();
204 	sal_Int32 nVal3 = ((SdrEdgeLine3DeltaItem&)rSet.Get(SDRATTR_EDGELINE3DELTA)).GetValue();
205 
206 	if(eKind == SDREDGE_ORTHOLINES || eKind == SDREDGE_BEZIER)
207 	{
208 		sal_Int32 nVals[3] = { nVal1, nVal2, nVal3 };
209 		sal_uInt16 n = 0;
210 
211 		if(aEdgeInfo.nObj1Lines >= 2 && n < 3)
212 		{
213 			aEdgeInfo.ImpSetLineVersatz(OBJ1LINE2, *pEdgeTrack, nVals[n]);
214 			n++;
215 		}
216 
217 		if(aEdgeInfo.nObj1Lines >= 3 && n < 3)
218 		{
219 			aEdgeInfo.ImpSetLineVersatz(OBJ1LINE3, *pEdgeTrack, nVals[n]);
220 			n++;
221 		}
222 
223 		if(aEdgeInfo.nMiddleLine != 0xFFFF && n < 3)
224 		{
225 			aEdgeInfo.ImpSetLineVersatz(MIDDLELINE, *pEdgeTrack, nVals[n]);
226 			n++;
227 		}
228 
229 		if(aEdgeInfo.nObj2Lines >= 3 && n < 3)
230 		{
231 			aEdgeInfo.ImpSetLineVersatz(OBJ2LINE3, *pEdgeTrack, nVals[n]);
232 			n++;
233 		}
234 
235 		if(aEdgeInfo.nObj2Lines >= 2 && n < 3)
236 		{
237 			aEdgeInfo.ImpSetLineVersatz(OBJ2LINE2, *pEdgeTrack, nVals[n]);
238 			n++;
239 		}
240 	}
241 	else if(eKind == SDREDGE_THREELINES)
242 	{
243 		sal_Bool bHor1 = aEdgeInfo.nAngle1 == 0 || aEdgeInfo.nAngle1 == 18000;
244 		sal_Bool bHor2 = aEdgeInfo.nAngle2 == 0 || aEdgeInfo.nAngle2 == 18000;
245 
246 		if(bHor1)
247 		{
248 			aEdgeInfo.aObj1Line2.X() = nVal1;
249 		}
250 		else
251 		{
252 			aEdgeInfo.aObj1Line2.Y() = nVal1;
253 		}
254 
255 		if(bHor2)
256 		{
257 			aEdgeInfo.aObj2Line2.X() = nVal2;
258 		}
259 		else
260 		{
261 			aEdgeInfo.aObj2Line2.Y() = nVal2;
262 		}
263 	}
264 
265 	// #84649#
266 	ImpDirtyEdgeTrack();
267 }
268 
269 void SdrEdgeObj::ImpSetEdgeInfoToAttr()
270 {
271 	const SfxItemSet& rSet = GetObjectItemSet();
272 	SdrEdgeKind eKind = ((SdrEdgeKindItem&)(rSet.Get(SDRATTR_EDGEKIND))).GetValue();
273 	sal_Int32 nValAnz = ((SdrEdgeLineDeltaAnzItem&)rSet.Get(SDRATTR_EDGELINEDELTAANZ)).GetValue();
274 	sal_Int32 nVal1 = ((SdrEdgeLine1DeltaItem&)rSet.Get(SDRATTR_EDGELINE1DELTA)).GetValue();
275 	sal_Int32 nVal2 = ((SdrEdgeLine2DeltaItem&)rSet.Get(SDRATTR_EDGELINE2DELTA)).GetValue();
276 	sal_Int32 nVal3 = ((SdrEdgeLine3DeltaItem&)rSet.Get(SDRATTR_EDGELINE3DELTA)).GetValue();
277 	sal_Int32 nVals[3] = { nVal1, nVal2, nVal3 };
278 	sal_uInt16 n = 0;
279 
280 	if(eKind == SDREDGE_ORTHOLINES || eKind == SDREDGE_BEZIER)
281 	{
282 		if(aEdgeInfo.nObj1Lines >= 2 && n < 3)
283 		{
284 			nVals[n] = aEdgeInfo.ImpGetLineVersatz(OBJ1LINE2, *pEdgeTrack);
285 			n++;
286 		}
287 
288 		if(aEdgeInfo.nObj1Lines >= 3 && n < 3)
289 		{
290 			nVals[n] = aEdgeInfo.ImpGetLineVersatz(OBJ1LINE3, *pEdgeTrack);
291 			n++;
292 		}
293 
294 		if(aEdgeInfo.nMiddleLine != 0xFFFF && n < 3)
295 		{
296 			nVals[n] = aEdgeInfo.ImpGetLineVersatz(MIDDLELINE, *pEdgeTrack);
297 			n++;
298 		}
299 
300 		if(aEdgeInfo.nObj2Lines >= 3 && n < 3)
301 		{
302 			nVals[n] = aEdgeInfo.ImpGetLineVersatz(OBJ2LINE3, *pEdgeTrack);
303 			n++;
304 		}
305 
306 		if(aEdgeInfo.nObj2Lines >= 2 && n < 3)
307 		{
308 			nVals[n] = aEdgeInfo.ImpGetLineVersatz(OBJ2LINE2, *pEdgeTrack);
309 			n++;
310 		}
311 	}
312 	else if(eKind == SDREDGE_THREELINES)
313 	{
314 		sal_Bool bHor1 = aEdgeInfo.nAngle1 == 0 || aEdgeInfo.nAngle1 == 18000;
315 		sal_Bool bHor2 = aEdgeInfo.nAngle2 == 0 || aEdgeInfo.nAngle2 == 18000;
316 
317 		n = 2;
318 		nVals[0] = bHor1 ? aEdgeInfo.aObj1Line2.X() : aEdgeInfo.aObj1Line2.Y();
319 		nVals[1] = bHor2 ? aEdgeInfo.aObj2Line2.X() : aEdgeInfo.aObj2Line2.Y();
320 	}
321 
322 	if(n != nValAnz || nVals[0] != nVal1 || nVals[1] != nVal2 || nVals[2] != nVal3)
323 	{
324 		// #75371# Here no more notifying is necessary, just local changes are OK.
325 		if(n != nValAnz)
326 		{
327 			GetProperties().SetObjectItemDirect(SdrEdgeLineDeltaAnzItem(n));
328 		}
329 
330 		if(nVals[0] != nVal1)
331 		{
332 			GetProperties().SetObjectItemDirect(SdrEdgeLine1DeltaItem(nVals[0]));
333 		}
334 
335 		if(nVals[1] != nVal2)
336 		{
337 			GetProperties().SetObjectItemDirect(SdrEdgeLine2DeltaItem(nVals[1]));
338 		}
339 
340 		if(nVals[2] != nVal3)
341 		{
342 			GetProperties().SetObjectItemDirect(SdrEdgeLine3DeltaItem(nVals[2]));
343 		}
344 
345 		if(n < 3)
346 		{
347 			GetProperties().ClearObjectItemDirect(SDRATTR_EDGELINE3DELTA);
348 		}
349 
350 		if(n < 2)
351 		{
352 			GetProperties().ClearObjectItemDirect(SDRATTR_EDGELINE2DELTA);
353 		}
354 
355 		if(n < 1)
356 		{
357 			GetProperties().ClearObjectItemDirect(SDRATTR_EDGELINE1DELTA);
358 		}
359 	}
360 }
361 
362 void SdrEdgeObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
363 {
364     // #54102# allow rotation, mirror and shear
365 	rInfo.bRotateFreeAllowed = true;
366 	rInfo.bRotate90Allowed = true;
367 	rInfo.bMirrorFreeAllowed = true;
368 	rInfo.bMirror45Allowed = true;
369 	rInfo.bMirror90Allowed = true;
370 	rInfo.bTransparenceAllowed = sal_False;
371 	rInfo.bGradientAllowed = sal_False;
372 	rInfo.bShearAllowed = true;
373 	rInfo.bEdgeRadiusAllowed = sal_False;
374 	FASTBOOL bCanConv=!HasText() || ImpCanConvTextToCurve();
375 	rInfo.bCanConvToPath=bCanConv;
376 	rInfo.bCanConvToPoly=bCanConv;
377 	rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary());
378 }
379 
380 sal_uInt16 SdrEdgeObj::GetObjIdentifier() const
381 {
382 	return sal_uInt16(OBJ_EDGE);
383 }
384 
385 const Rectangle& SdrEdgeObj::GetCurrentBoundRect() const
386 {
387 	if(bEdgeTrackDirty)
388 	{
389 		((SdrEdgeObj*)this)->ImpRecalcEdgeTrack();
390 	}
391 
392 	return SdrTextObj::GetCurrentBoundRect();
393 }
394 
395 const Rectangle& SdrEdgeObj::GetSnapRect() const
396 {
397 	if(bEdgeTrackDirty)
398 	{
399 		((SdrEdgeObj*)this)->ImpRecalcEdgeTrack();
400 	}
401 
402 	return SdrTextObj::GetSnapRect();
403 }
404 
405 void SdrEdgeObj::RecalcSnapRect()
406 {
407 	maSnapRect=pEdgeTrack->GetBoundRect();
408 }
409 
410 void SdrEdgeObj::TakeUnrotatedSnapRect(Rectangle& rRect) const
411 {
412 	rRect=GetSnapRect();
413 }
414 
415 FASTBOOL SdrEdgeObj::IsNode() const
416 {
417 	return sal_True;
418 }
419 
420 SdrGluePoint SdrEdgeObj::GetVertexGluePoint(sal_uInt16 nNum) const
421 {
422 	Point aPt;
423 	sal_uInt16 nPntAnz=pEdgeTrack->GetPointCount();
424 	if (nPntAnz>0)
425 	{
426 		Point aOfs = GetSnapRect().Center();
427 		if (nNum==2 && GetConnectedNode(sal_True)==NULL) aPt=(*pEdgeTrack)[0];
428 		else if (nNum==3 && GetConnectedNode(sal_False)==NULL) aPt=(*pEdgeTrack)[nPntAnz-1];
429 		else {
430 			if ((nPntAnz & 1) ==1) {
431 				aPt=(*pEdgeTrack)[nPntAnz/2];
432 			} else {
433 				Point aPt1((*pEdgeTrack)[nPntAnz/2-1]);
434 				Point aPt2((*pEdgeTrack)[nPntAnz/2]);
435 				aPt1+=aPt2;
436 				aPt1.X()/=2;
437 				aPt1.Y()/=2;
438 				aPt=aPt1;
439 			}
440 		}
441 		aPt-=aOfs;
442 	}
443 	SdrGluePoint aGP(aPt);
444 	aGP.SetPercent(sal_False);
445 	return aGP;
446 }
447 
448 SdrGluePoint SdrEdgeObj::GetCornerGluePoint(sal_uInt16 nNum) const
449 {
450 	return GetVertexGluePoint(nNum);
451 }
452 
453 const SdrGluePointList* SdrEdgeObj::GetGluePointList() const
454 {
455 	return NULL; // Keine benutzerdefinierten Klebepunkte fuer Verbinder #31671#
456 }
457 
458 SdrGluePointList* SdrEdgeObj::ForceGluePointList()
459 {
460 	return NULL; // Keine benutzerdefinierten Klebepunkte fuer Verbinder #31671#
461 }
462 
463 FASTBOOL SdrEdgeObj::IsEdge() const
464 {
465 	return sal_True;
466 }
467 
468 void SdrEdgeObj::ConnectToNode(FASTBOOL bTail1, SdrObject* pObj)
469 {
470 	SdrObjConnection& rCon=GetConnection(bTail1);
471 	DisconnectFromNode(bTail1);
472 	if (pObj!=NULL) {
473 		pObj->AddListener(*this);
474 		rCon.pObj=pObj;
475 
476         // #120437# If connection is set, reset bEdgeTrackUserDefined
477 	    bEdgeTrackUserDefined = false;
478 
479         ImpDirtyEdgeTrack();
480 	}
481 }
482 
483 void SdrEdgeObj::DisconnectFromNode(FASTBOOL bTail1)
484 {
485 	SdrObjConnection& rCon=GetConnection(bTail1);
486 	if (rCon.pObj!=NULL) {
487 		rCon.pObj->RemoveListener(*this);
488 		rCon.pObj=NULL;
489 	}
490 }
491 
492 SdrObject* SdrEdgeObj::GetConnectedNode(FASTBOOL bTail1) const
493 {
494 	SdrObject* pObj=GetConnection(bTail1).pObj;
495 	if (pObj!=NULL && (pObj->GetPage()!=pPage || !pObj->IsInserted())) pObj=NULL;
496 	return pObj;
497 }
498 
499 FASTBOOL SdrEdgeObj::CheckNodeConnection(FASTBOOL bTail1) const
500 {
501 	FASTBOOL bRet=sal_False;
502 	const SdrObjConnection& rCon=GetConnection(bTail1);
503 	sal_uInt16 nPtAnz=pEdgeTrack->GetPointCount();
504 	if (rCon.pObj!=NULL && rCon.pObj->GetPage()==pPage && nPtAnz!=0) {
505 		const SdrGluePointList* pGPL=rCon.pObj->GetGluePointList();
506 		sal_uInt16 nConAnz=pGPL==NULL ? 0 : pGPL->GetCount();
507 		sal_uInt16 nGesAnz=nConAnz+8;
508 		Point aTail(bTail1 ? (*pEdgeTrack)[0] : (*pEdgeTrack)[sal_uInt16(nPtAnz-1)]);
509 		for (sal_uInt16 i=0; i<nGesAnz && !bRet; i++) {
510 			if (i<nConAnz) { // UserDefined
511 				bRet=aTail==(*pGPL)[i].GetAbsolutePos(*rCon.pObj);
512 			} else if (i<nConAnz+4) { // Vertex
513 				SdrGluePoint aPt(rCon.pObj->GetVertexGluePoint(i-nConAnz));
514 				bRet=aTail==aPt.GetAbsolutePos(*rCon.pObj);
515 			} else {                  // Corner
516 				SdrGluePoint aPt(rCon.pObj->GetCornerGluePoint(i-nConAnz-4));
517 				bRet=aTail==aPt.GetAbsolutePos(*rCon.pObj);
518 			}
519 		}
520 	}
521 	return bRet;
522 }
523 
524 void SdrEdgeObj::ImpSetTailPoint(FASTBOOL bTail1, const Point& rPt)
525 {
526 	sal_uInt16 nPtAnz=pEdgeTrack->GetPointCount();
527 	if (nPtAnz==0) {
528 		(*pEdgeTrack)[0]=rPt;
529 		(*pEdgeTrack)[1]=rPt;
530 	} else if (nPtAnz==1) {
531 		if (!bTail1) (*pEdgeTrack)[1]=rPt;
532 		else { (*pEdgeTrack)[1]=(*pEdgeTrack)[0]; (*pEdgeTrack)[0]=rPt; }
533 	} else {
534 		if (!bTail1) (*pEdgeTrack)[sal_uInt16(nPtAnz-1)]=rPt;
535 		else (*pEdgeTrack)[0]=rPt;
536 	}
537 	ImpRecalcEdgeTrack();
538 	SetRectsDirty();
539 }
540 
541 void SdrEdgeObj::ImpDirtyEdgeTrack()
542 {
543 	if ( !bEdgeTrackUserDefined || !(GetModel() && GetModel()->isLocked()) )
544 		bEdgeTrackDirty = sal_True;
545 }
546 
547 void SdrEdgeObj::ImpUndirtyEdgeTrack()
548 {
549 	if (bEdgeTrackDirty && (GetModel() && GetModel()->isLocked()) ) {
550 		ImpRecalcEdgeTrack();
551 	}
552 }
553 
554 void SdrEdgeObj::ImpRecalcEdgeTrack()
555 {
556     // #120437# if bEdgeTrackUserDefined, do not recalculate
557     if(bEdgeTrackUserDefined)
558     {
559         return;
560     }
561 
562     // #120437# also not when model locked during import, but remember
563     if(!GetModel() || GetModel()->isLocked())
564     {
565         mbSuppressed = true;
566         return;
567     }
568 
569 	// #110649#
570 	if(IsBoundRectCalculationRunning())
571 	{
572 		// this object is involved into another ImpRecalcEdgeTrack() call
573 		// from another SdrEdgeObj. Do not calculate again to avoid loop.
574 		// Also, do not change bEdgeTrackDirty so that it gets recalculated
575 		// later at the first non-looping call.
576 	}
577 	else
578 	{
579         if(mbSuppressed)
580         {
581             // #123048# If layouting was ever suppressed, it needs to be done once
582             // and the attr need to be set at EdgeInfo, else these attr *will be lost*
583             // in the following call to ImpSetEdgeInfoToAttr() sice they were never
584             // set before (!)
585             *pEdgeTrack=ImpCalcEdgeTrack(*pEdgeTrack,aCon1,aCon2,&aEdgeInfo);
586             ImpSetAttrToEdgeInfo();
587             mbSuppressed = false;
588         }
589 
590 		// To not run in a depth loop, use a coloring algorythm on
591 		// SdrEdgeObj BoundRect calculations
592 		mbBoundRectCalculationRunning = sal_True;
593 
594 		Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetCurrentBoundRect();
595 		SetRectsDirty();
596 		// #110094#-14 if (!bEdgeTrackDirty) SendRepaintBroadcast();
597 		*pEdgeTrack=ImpCalcEdgeTrack(*pEdgeTrack,aCon1,aCon2,&aEdgeInfo);
598 		ImpSetEdgeInfoToAttr(); // Die Werte aus aEdgeInfo in den Pool kopieren
599 		bEdgeTrackDirty=sal_False;
600 
601 		// Only redraw here, no object change
602 		ActionChanged();
603 		// BroadcastObjectChange();
604 
605 		SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
606 
607 		// #110649#
608 		mbBoundRectCalculationRunning = sal_False;
609 	}
610 }
611 
612 sal_uInt16 SdrEdgeObj::ImpCalcEscAngle(SdrObject* pObj, const Point& rPt) const
613 {
614 	if (pObj==NULL) return SDRESC_ALL;
615 	Rectangle aR(pObj->GetSnapRect());
616 	long dxl=rPt.X()-aR.Left();
617 	long dyo=rPt.Y()-aR.Top();
618 	long dxr=aR.Right()-rPt.X();
619 	long dyu=aR.Bottom()-rPt.Y();
620 	FASTBOOL bxMitt=Abs(dxl-dxr)<2;
621 	FASTBOOL byMitt=Abs(dyo-dyu)<2;
622 	long dx=Min(dxl,dxr);
623 	long dy=Min(dyo,dyu);
624 	FASTBOOL bDiag=Abs(dx-dy)<2;
625 	if (bxMitt && byMitt) return SDRESC_ALL; // In der Mitte
626 	if (bDiag) {  // diagonal
627 		sal_uInt16 nRet=0;
628 		if (byMitt) nRet|=SDRESC_VERT;
629 		if (bxMitt) nRet|=SDRESC_HORZ;
630 		if (dxl<dxr) { // Links
631 			if (dyo<dyu) nRet|=SDRESC_LEFT | SDRESC_TOP;
632 			else nRet|=SDRESC_LEFT | SDRESC_BOTTOM;
633 		} else {       // Rechts
634 			if (dyo<dyu) nRet|=SDRESC_RIGHT | SDRESC_TOP;
635 			else nRet|=SDRESC_RIGHT | SDRESC_BOTTOM;
636 		}
637 		return nRet;
638 	}
639 	if (dx<dy) { // waagerecht
640 		if (bxMitt) return SDRESC_HORZ;
641 		if (dxl<dxr) return SDRESC_LEFT;
642 		else return SDRESC_RIGHT;
643 	} else {     // senkrecht
644 		if (byMitt) return SDRESC_VERT;
645 		if (dyo<dyu) return SDRESC_TOP;
646 		else return SDRESC_BOTTOM;
647 	}
648 }
649 
650 FASTBOOL SdrEdgeObj::ImpStripPolyPoints(XPolygon& /*rXP*/) const
651 {
652 	// fehlende Implementation !!!
653 	return sal_False;
654 }
655 
656 XPolygon SdrEdgeObj::ImpCalcObjToCenter(const Point& rStPt, long nEscAngle, const Rectangle& rRect, const Point& rMeeting) const
657 {
658 	XPolygon aXP;
659 	aXP.Insert(XPOLY_APPEND,rStPt,XPOLY_NORMAL);
660 	FASTBOOL bRts=nEscAngle==0;
661 	FASTBOOL bObn=nEscAngle==9000;
662 	FASTBOOL bLks=nEscAngle==18000;
663 	FASTBOOL bUnt=nEscAngle==27000;
664 
665 	Point aP1(rStPt); // erstmal den Pflichtabstand
666 	if (bLks) aP1.X()=rRect.Left();
667 	if (bRts) aP1.X()=rRect.Right();
668 	if (bObn) aP1.Y()=rRect.Top();
669 	if (bUnt) aP1.Y()=rRect.Bottom();
670 
671 	FASTBOOL bFinish=sal_False;
672 	if (!bFinish) {
673 		Point aP2(aP1); // Und nun den Pflichtabstand ggf. bis auf Meetinghoehe erweitern
674 		if (bLks && rMeeting.X()<=aP2.X()) aP2.X()=rMeeting.X();
675 		if (bRts && rMeeting.X()>=aP2.X()) aP2.X()=rMeeting.X();
676 		if (bObn && rMeeting.Y()<=aP2.Y()) aP2.Y()=rMeeting.Y();
677 		if (bUnt && rMeeting.Y()>=aP2.Y()) aP2.Y()=rMeeting.Y();
678 		aXP.Insert(XPOLY_APPEND,aP2,XPOLY_NORMAL);
679 
680 		Point aP3(aP2);
681 		if ((bLks && rMeeting.X()>aP2.X()) || (bRts && rMeeting.X()<aP2.X())) { // Aussenrum
682 			if (rMeeting.Y()<aP2.Y()) {
683 				aP3.Y()=rRect.Top();
684 				if (rMeeting.Y()<aP3.Y()) aP3.Y()=rMeeting.Y();
685 			} else {
686 				aP3.Y()=rRect.Bottom();
687 				if (rMeeting.Y()>aP3.Y()) aP3.Y()=rMeeting.Y();
688 			}
689 			aXP.Insert(XPOLY_APPEND,aP3,XPOLY_NORMAL);
690 			if (aP3.Y()!=rMeeting.Y()) {
691 				aP3.X()=rMeeting.X();
692 				aXP.Insert(XPOLY_APPEND,aP3,XPOLY_NORMAL);
693 			}
694 		}
695 		if ((bObn && rMeeting.Y()>aP2.Y()) || (bUnt && rMeeting.Y()<aP2.Y())) { // Aussenrum
696 			if (rMeeting.X()<aP2.X()) {
697 				aP3.X()=rRect.Left();
698 				if (rMeeting.X()<aP3.X()) aP3.X()=rMeeting.X();
699 			} else {
700 				aP3.X()=rRect.Right();
701 				if (rMeeting.X()>aP3.X()) aP3.X()=rMeeting.X();
702 			}
703 			aXP.Insert(XPOLY_APPEND,aP3,XPOLY_NORMAL);
704 			if (aP3.X()!=rMeeting.X()) {
705 				aP3.Y()=rMeeting.Y();
706 				aXP.Insert(XPOLY_APPEND,aP3,XPOLY_NORMAL);
707 			}
708 		}
709 	}
710 #ifdef DBG_UTIL
711 	if (aXP.GetPointCount()>4) {
712 		DBG_ERROR("SdrEdgeObj::ImpCalcObjToCenter(): Polygon hat mehr als 4 Punkte!");
713 	}
714 #endif
715 	return aXP;
716 }
717 
718 XPolygon SdrEdgeObj::ImpCalcEdgeTrack(const XPolygon& rTrack0, SdrObjConnection& rCon1, SdrObjConnection& rCon2, SdrEdgeInfoRec* pInfo) const
719 {
720 	Point aPt1,aPt2;
721 	SdrGluePoint aGP1,aGP2;
722 	sal_uInt16 nEsc1=SDRESC_ALL,nEsc2=SDRESC_ALL;
723 	Rectangle aBoundRect1;
724 	Rectangle aBoundRect2;
725 	Rectangle aBewareRect1;
726 	Rectangle aBewareRect2;
727 	// Erstmal die alten Endpunkte wiederholen
728 	if (rTrack0.GetPointCount()!=0) {
729 		aPt1=rTrack0[0];
730 		sal_uInt16 nSiz=rTrack0.GetPointCount();
731 		nSiz--;
732 		aPt2=rTrack0[nSiz];
733 	} else {
734 		if (!aOutRect.IsEmpty()) {
735 			aPt1=aOutRect.TopLeft();
736 			aPt2=aOutRect.BottomRight();
737 		}
738 	}
739 
740     // #54102# To allow interactive preview, do also if not inserted
741 	FASTBOOL bCon1=rCon1.pObj!=NULL && rCon1.pObj->GetPage()==pPage; // && rCon1.pObj->IsInserted();
742 	FASTBOOL bCon2=rCon2.pObj!=NULL && rCon2.pObj->GetPage()==pPage; // && rCon2.pObj->IsInserted();
743 	const SfxItemSet& rSet = GetObjectItemSet();
744 
745 	if (bCon1) {
746 		if (rCon1.pObj==(SdrObject*)this)
747 		{
748 			// sicherheitshalber Abfragen #44515#
749 			aBoundRect1=aOutRect;
750 		}
751 		else
752 		{
753 			aBoundRect1 = rCon1.pObj->GetCurrentBoundRect();
754 		}
755 		aBoundRect1.Move(rCon1.aObjOfs.X(),rCon1.aObjOfs.Y());
756 		aBewareRect1=aBoundRect1;
757 
758 		sal_Int32 nH = ((SdrEdgeNode1HorzDistItem&)rSet.Get(SDRATTR_EDGENODE1HORZDIST)).GetValue();
759 		sal_Int32 nV = ((SdrEdgeNode1VertDistItem&)rSet.Get(SDRATTR_EDGENODE1VERTDIST)).GetValue();
760 
761 		aBewareRect1.Left()-=nH;
762 		aBewareRect1.Right()+=nH;
763 		aBewareRect1.Top()-=nV;
764 		aBewareRect1.Bottom()+=nV;
765 	} else {
766 		aBoundRect1=Rectangle(aPt1,aPt1);
767 		aBoundRect1.Move(rCon1.aObjOfs.X(),rCon1.aObjOfs.Y());
768 		aBewareRect1=aBoundRect1;
769 	}
770 	if (bCon2) {
771 		if (rCon2.pObj==(SdrObject*)this) { // sicherheitshalber Abfragen #44515#
772 			aBoundRect2=aOutRect;
773 		}
774 		else
775 		{
776 			aBoundRect2 = rCon2.pObj->GetCurrentBoundRect();
777 		}
778 		aBoundRect2.Move(rCon2.aObjOfs.X(),rCon2.aObjOfs.Y());
779 		aBewareRect2=aBoundRect2;
780 
781 		sal_Int32 nH = ((SdrEdgeNode2HorzDistItem&)rSet.Get(SDRATTR_EDGENODE2HORZDIST)).GetValue();
782 		sal_Int32 nV = ((SdrEdgeNode2VertDistItem&)rSet.Get(SDRATTR_EDGENODE2VERTDIST)).GetValue();
783 
784 		aBewareRect2.Left()-=nH;
785 		aBewareRect2.Right()+=nH;
786 		aBewareRect2.Top()-=nV;
787 		aBewareRect2.Bottom()+=nV;
788 	} else {
789 		aBoundRect2=Rectangle(aPt2,aPt2);
790 		aBoundRect2.Move(rCon2.aObjOfs.X(),rCon2.aObjOfs.Y());
791 		aBewareRect2=aBoundRect2;
792 	}
793 	XPolygon aBestXP;
794 	sal_uIntPtr nBestQual=0xFFFFFFFF;
795 	SdrEdgeInfoRec aBestInfo;
796 	FASTBOOL bAuto1=bCon1 && rCon1.bBestVertex;
797 	FASTBOOL bAuto2=bCon2 && rCon2.bBestVertex;
798 	if (bAuto1) rCon1.bAutoVertex=sal_True;
799 	if (bAuto2) rCon2.bAutoVertex=sal_True;
800 	sal_uInt16 nBestAuto1=0;
801 	sal_uInt16 nBestAuto2=0;
802 	sal_uInt16 nAnz1=bAuto1 ? 4 : 1;
803 	sal_uInt16 nAnz2=bAuto2 ? 4 : 1;
804 	for (sal_uInt16 nNum1=0; nNum1<nAnz1; nNum1++) {
805 		if (bAuto1) rCon1.nConId=nNum1;
806 		if (bCon1 && rCon1.TakeGluePoint(aGP1,sal_True)) {
807 			aPt1=aGP1.GetPos();
808 			nEsc1=aGP1.GetEscDir();
809 			if (nEsc1==SDRESC_SMART) nEsc1=ImpCalcEscAngle(rCon1.pObj,aPt1-rCon1.aObjOfs);
810 		}
811 		for (sal_uInt16 nNum2=0; nNum2<nAnz2; nNum2++) {
812 			if (bAuto2) rCon2.nConId=nNum2;
813 			if (bCon2 && rCon2.TakeGluePoint(aGP2,sal_True)) {
814 				aPt2=aGP2.GetPos();
815 				nEsc2=aGP2.GetEscDir();
816 				if (nEsc2==SDRESC_SMART) nEsc2=ImpCalcEscAngle(rCon2.pObj,aPt2-rCon2.aObjOfs);
817 			}
818 			for (long nA1=0; nA1<36000; nA1+=9000) {
819 				sal_uInt16 nE1=nA1==0 ? SDRESC_RIGHT : nA1==9000 ? SDRESC_TOP : nA1==18000 ? SDRESC_LEFT : nA1==27000 ? SDRESC_BOTTOM : 0;
820 				for (long nA2=0; nA2<36000; nA2+=9000) {
821 					sal_uInt16 nE2=nA2==0 ? SDRESC_RIGHT : nA2==9000 ? SDRESC_TOP : nA2==18000 ? SDRESC_LEFT : nA2==27000 ? SDRESC_BOTTOM : 0;
822 					if ((nEsc1&nE1)!=0 && (nEsc2&nE2)!=0) {
823 						sal_uIntPtr nQual=0;
824 						SdrEdgeInfoRec aInfo;
825 						if (pInfo!=NULL) aInfo=*pInfo;
826 						XPolygon aXP(ImpCalcEdgeTrack(aPt1,nA1,aBoundRect1,aBewareRect1,aPt2,nA2,aBoundRect2,aBewareRect2,&nQual,&aInfo));
827 						if (nQual<nBestQual) {
828 							aBestXP=aXP;
829 							nBestQual=nQual;
830 							aBestInfo=aInfo;
831 							nBestAuto1=nNum1;
832 							nBestAuto2=nNum2;
833 						}
834 					}
835 				}
836 			}
837 		}
838 	}
839 	if (bAuto1) rCon1.nConId=nBestAuto1;
840 	if (bAuto2) rCon2.nConId=nBestAuto2;
841 	if (pInfo!=NULL) *pInfo=aBestInfo;
842 	return aBestXP;
843 }
844 
845 XPolygon SdrEdgeObj::ImpCalcEdgeTrack(const Point& rPt1, long nAngle1, const Rectangle& rBoundRect1, const Rectangle& rBewareRect1,
846 	const Point& rPt2, long nAngle2, const Rectangle& rBoundRect2, const Rectangle& rBewareRect2,
847 	sal_uIntPtr* pnQuality, SdrEdgeInfoRec* pInfo) const
848 {
849 	SdrEdgeKind eKind=((SdrEdgeKindItem&)(GetObjectItem(SDRATTR_EDGEKIND))).GetValue();
850 	FASTBOOL bRts1=nAngle1==0;
851 	FASTBOOL bObn1=nAngle1==9000;
852 	FASTBOOL bLks1=nAngle1==18000;
853 	FASTBOOL bUnt1=nAngle1==27000;
854 	FASTBOOL bHor1=bLks1 || bRts1;
855 	FASTBOOL bVer1=bObn1 || bUnt1;
856 	FASTBOOL bRts2=nAngle2==0;
857 	FASTBOOL bObn2=nAngle2==9000;
858 	FASTBOOL bLks2=nAngle2==18000;
859 	FASTBOOL bUnt2=nAngle2==27000;
860 	FASTBOOL bHor2=bLks2 || bRts2;
861 	FASTBOOL bVer2=bObn2 || bUnt2;
862 	FASTBOOL bInfo=pInfo!=NULL;
863 	if (bInfo) {
864 		pInfo->cOrthoForm=0;
865 		pInfo->nAngle1=nAngle1;
866 		pInfo->nAngle2=nAngle2;
867 		pInfo->nObj1Lines=1;
868 		pInfo->nObj2Lines=1;
869 		pInfo->nMiddleLine=0xFFFF;
870 	}
871 	Point aPt1(rPt1);
872 	Point aPt2(rPt2);
873 	Rectangle aBoundRect1 (rBoundRect1 );
874 	Rectangle aBoundRect2 (rBoundRect2 );
875 	Rectangle aBewareRect1(rBewareRect1);
876 	Rectangle aBewareRect2(rBewareRect2);
877 	Point aMeeting((aPt1.X()+aPt2.X()+1)/2,(aPt1.Y()+aPt2.Y()+1)/2);
878 	FASTBOOL bMeetingXMid=sal_True;
879 	FASTBOOL bMeetingYMid=sal_True;
880 	if (eKind==SDREDGE_ONELINE) {
881 		XPolygon aXP(2);
882 		aXP[0]=rPt1;
883 		aXP[1]=rPt2;
884 		if (pnQuality!=NULL) {
885 			*pnQuality=Abs(rPt1.X()-rPt2.X())+Abs(rPt1.Y()-rPt2.Y());
886 		}
887 		return aXP;
888 	} else if (eKind==SDREDGE_THREELINES) {
889 		XPolygon aXP(4);
890 		aXP[0]=rPt1;
891 		aXP[1]=rPt1;
892 		aXP[2]=rPt2;
893 		aXP[3]=rPt2;
894 		if (bRts1) aXP[1].X()=aBewareRect1.Right();  //+=500;
895 		if (bObn1) aXP[1].Y()=aBewareRect1.Top();    //-=500;
896 		if (bLks1) aXP[1].X()=aBewareRect1.Left();   //-=500;
897 		if (bUnt1) aXP[1].Y()=aBewareRect1.Bottom(); //+=500;
898 		if (bRts2) aXP[2].X()=aBewareRect2.Right();  //+=500;
899 		if (bObn2) aXP[2].Y()=aBewareRect2.Top();    //-=500;
900 		if (bLks2) aXP[2].X()=aBewareRect2.Left();   //-=500;
901 		if (bUnt2) aXP[2].Y()=aBewareRect2.Bottom(); //+=500;
902 		if (pnQuality!=NULL) {
903 			long nQ=Abs(aXP[1].X()-aXP[0].X())+Abs(aXP[1].Y()-aXP[0].Y());
904 				nQ+=Abs(aXP[2].X()-aXP[1].X())+Abs(aXP[2].Y()-aXP[1].Y());
905 				nQ+=Abs(aXP[3].X()-aXP[2].X())+Abs(aXP[3].Y()-aXP[2].Y());
906 			*pnQuality=nQ;
907 		}
908 		if (bInfo) {
909 			pInfo->nObj1Lines=2;
910 			pInfo->nObj2Lines=2;
911 			if (bHor1) {
912 				aXP[1].X()+=pInfo->aObj1Line2.X();
913 			} else {
914 				aXP[1].Y()+=pInfo->aObj1Line2.Y();
915 			}
916 			if (bHor2) {
917 				aXP[2].X()+=pInfo->aObj2Line2.X();
918 			} else {
919 				aXP[2].Y()+=pInfo->aObj2Line2.Y();
920 			}
921 		}
922 		return aXP;
923 	}
924 	sal_uInt16 nIntersections=0;
925 	FASTBOOL bForceMeeting=sal_False; // Muss die Linie durch den MeetingPoint laufen?
926 	{
927 		Point aC1(aBewareRect1.Center());
928 		Point aC2(aBewareRect2.Center());
929 		if (aBewareRect1.Left()<=aBewareRect2.Right() && aBewareRect1.Right()>=aBewareRect2.Left()) {
930 			// Ueberschneidung auf der X-Achse
931 			long n1=Max(aBewareRect1.Left(),aBewareRect2.Left());
932 			long n2=Min(aBewareRect1.Right(),aBewareRect2.Right());
933 			aMeeting.X()=(n1+n2+1)/2;
934 		} else {
935 			// Ansonsten den Mittelpunkt des Freiraums
936 			if (aC1.X()<aC2.X()) {
937 				aMeeting.X()=(aBewareRect1.Right()+aBewareRect2.Left()+1)/2;
938 			} else {
939 				aMeeting.X()=(aBewareRect1.Left()+aBewareRect2.Right()+1)/2;
940 			}
941 		}
942 		if (aBewareRect1.Top()<=aBewareRect2.Bottom() && aBewareRect1.Bottom()>=aBewareRect2.Top()) {
943 			// Ueberschneidung auf der Y-Achse
944 			long n1=Max(aBewareRect1.Top(),aBewareRect2.Top());
945 			long n2=Min(aBewareRect1.Bottom(),aBewareRect2.Bottom());
946 			aMeeting.Y()=(n1+n2+1)/2;
947 		} else {
948 			// Ansonsten den Mittelpunkt des Freiraums
949 			if (aC1.Y()<aC2.Y()) {
950 				aMeeting.Y()=(aBewareRect1.Bottom()+aBewareRect2.Top()+1)/2;
951 			} else {
952 				aMeeting.Y()=(aBewareRect1.Top()+aBewareRect2.Bottom()+1)/2;
953 			}
954 		}
955 		// Im Prinzip gibt es 3 zu unterscheidene Faelle:
956 		//   1. Beide in die selbe Richtung
957 		//   2. Beide in genau entgegengesetzte Richtungen
958 		//   3. Einer waagerecht und der andere senkrecht
959 		long nXMin=Min(aBewareRect1.Left(),aBewareRect2.Left());
960 		long nXMax=Max(aBewareRect1.Right(),aBewareRect2.Right());
961 		long nYMin=Min(aBewareRect1.Top(),aBewareRect2.Top());
962 		long nYMax=Max(aBewareRect1.Bottom(),aBewareRect2.Bottom());
963 		FASTBOOL bBewareOverlap=aBewareRect1.Right()>aBewareRect2.Left() && aBewareRect1.Left()<aBewareRect2.Right() &&
964 								aBewareRect1.Bottom()>aBewareRect2.Top() && aBewareRect1.Top()<aBewareRect2.Bottom();
965 		unsigned nMainCase=3;
966 		if (nAngle1==nAngle2) nMainCase=1;
967 		else if ((bHor1 && bHor2) || (bVer1 && bVer2)) nMainCase=2;
968 		if (nMainCase==1) { // Fall 1: Beide in eine Richtung moeglich.
969 			if (bVer1) aMeeting.X()=(aPt1.X()+aPt2.X()+1)/2; // ist hier besser, als der
970 			if (bHor1) aMeeting.Y()=(aPt1.Y()+aPt2.Y()+1)/2; // Mittelpunkt des Freiraums
971 			// bX1Ok bedeutet, dass die Vertikale, die aus Obj1 austritt, keinen Konflikt mit Obj2 bildet, ...
972 			FASTBOOL bX1Ok=aPt1.X()<=aBewareRect2.Left() || aPt1.X()>=aBewareRect2.Right();
973 			FASTBOOL bX2Ok=aPt2.X()<=aBewareRect1.Left() || aPt2.X()>=aBewareRect1.Right();
974 			FASTBOOL bY1Ok=aPt1.Y()<=aBewareRect2.Top() || aPt1.Y()>=aBewareRect2.Bottom();
975 			FASTBOOL bY2Ok=aPt2.Y()<=aBewareRect1.Top() || aPt2.Y()>=aBewareRect1.Bottom();
976 			if (bLks1 && (bY1Ok || aBewareRect1.Left()<aBewareRect2.Right()) && (bY2Ok || aBewareRect2.Left()<aBewareRect1.Right())) {
977 				aMeeting.X()=nXMin;
978 				bMeetingXMid=sal_False;
979 			}
980 			if (bRts1 && (bY1Ok || aBewareRect1.Right()>aBewareRect2.Left()) && (bY2Ok || aBewareRect2.Right()>aBewareRect1.Left())) {
981 				aMeeting.X()=nXMax;
982 				bMeetingXMid=sal_False;
983 			}
984 			if (bObn1 && (bX1Ok || aBewareRect1.Top()<aBewareRect2.Bottom()) && (bX2Ok || aBewareRect2.Top()<aBewareRect1.Bottom())) {
985 				aMeeting.Y()=nYMin;
986 				bMeetingYMid=sal_False;
987 			}
988 			if (bUnt1 && (bX1Ok || aBewareRect1.Bottom()>aBewareRect2.Top()) && (bX2Ok || aBewareRect2.Bottom()>aBewareRect1.Top())) {
989 				aMeeting.Y()=nYMax;
990 				bMeetingYMid=sal_False;
991 			}
992 		} else if (nMainCase==2) {
993 			// Fall 2:
994 			bForceMeeting=sal_True;
995 			if (bHor1) { // beide waagerecht
996                 /* 9 Moeglichkeiten:                   � � �                    */
997                 /*   2.1 Gegenueber, Ueberschneidung   � � �                    */
998                 /*       nur auf der Y-Achse           � � �                    */
999                 /*   2.2, 2.3 Gegenueber, vertikal versetzt. � � �   � � �      */
1000                 /*            Ueberschneidung weder auf der  � � �   � � �      */
1001                 /*            X- noch auf der Y-Achse        � � �   � � �      */
1002                 /*   2.4, 2.5 Untereinander,   � � �   � � �                    */
1003                 /*            Ueberschneidung  � � �   � � �                    */
1004                 /*            nur auf X-Achse  � � �   � � �                    */
1005                 /*   2.6, 2.7 Gegeneinander, vertikal versetzt. � � �   � � �   */
1006                 /*            Ueberschneidung weder auf der     � � �   � � �   */
1007                 /*            X- noch auf der Y-Achse.          � � �   � � �   */
1008                 /*   2.8 Gegeneinander.       � � �                             */
1009                 /*       Ueberschneidung nur  � � �                             */
1010                 /*       auf der Y-Achse.     � � �                             */
1011                 /*   2.9 Die BewareRects der Objekte ueberschneiden             */
1012                 /*       sich auf X- und Y-Achse.                               */
1013                 /* Die Faelle gelten entsprechend umgesetzt auch fuer           */
1014                 /* senkrechte Linienaustritte.                                  */
1015                 /* Die Faelle 2.1-2.7 werden mit dem Default-Meeting ausreichend*/
1016                 /* gut behandelt. Spezielle MeetingPoints werden hier also nur  */
1017                 /* fuer 2.8 und 2.9 bestimmt.                                   */
1018 
1019 				// Normalisierung. aR1 soll der nach rechts und
1020 				// aR2 der nach links austretende sein.
1021 				Rectangle aBewR1(bRts1 ? aBewareRect1 : aBewareRect2);
1022 				Rectangle aBewR2(bRts1 ? aBewareRect2 : aBewareRect1);
1023 				Rectangle aBndR1(bRts1 ? aBoundRect1 : aBoundRect2);
1024 				Rectangle aBndR2(bRts1 ? aBoundRect2 : aBoundRect1);
1025 				if (aBewR1.Bottom()>aBewR2.Top() && aBewR1.Top()<aBewR2.Bottom()) {
1026 					// Ueberschneidung auf der Y-Achse. Faelle 2.1, 2.8, 2.9
1027 					if (aBewR1.Right()>aBewR2.Left()) {
1028 						// Faelle 2.8, 2.9
1029 						// Fall 2.8 ist immer Aussenrumlauf (bDirect=sal_False).
1030 						// Fall 2.9 kann auch Direktverbindung sein (bei geringer
1031 						// Ueberschneidung der BewareRects ohne Ueberschneidung der
1032 						// Boundrects wenn die Linienaustritte sonst das BewareRect
1033 						// des jeweils anderen Objekts verletzen wuerden.
1034 						FASTBOOL bCase29Direct=sal_False;
1035 						FASTBOOL bCase29=aBewR1.Right()>aBewR2.Left();
1036 						if (aBndR1.Right()<=aBndR2.Left()) { // Fall 2.9 und keine Boundrectueberschneidung
1037 							if ((aPt1.Y()>aBewareRect2.Top() && aPt1.Y()<aBewareRect2.Bottom()) ||
1038 								(aPt2.Y()>aBewareRect1.Top() && aPt2.Y()<aBewareRect1.Bottom())) {
1039 							   bCase29Direct=sal_True;
1040 							}
1041 						}
1042 						if (!bCase29Direct) {
1043 							FASTBOOL bObenLang=Abs(nYMin-aMeeting.Y())<=Abs(nYMax-aMeeting.Y());
1044 							if (bObenLang) {
1045 								aMeeting.Y()=nYMin;
1046 							} else {
1047 								aMeeting.Y()=nYMax;
1048 							}
1049 							bMeetingYMid=sal_False;
1050 							if (bCase29) {
1051 								// und nun noch dafuer sorgen, dass das
1052 								// umzingelte Obj nicht durchquert wird
1053 								if ((aBewR1.Center().Y()<aBewR2.Center().Y()) != bObenLang) {
1054 									aMeeting.X()=aBewR2.Right();
1055 								} else {
1056 									aMeeting.X()=aBewR1.Left();
1057 								}
1058 								bMeetingXMid=sal_False;
1059 							}
1060 						} else {
1061 							// Direkte Verbindung (3-Linien Z-Verbindung), da
1062 							// Verletzung der BewareRects unvermeidlich ist.
1063 							// Via Dreisatz werden die BewareRects nun verkleinert.
1064 							long nWant1=aBewR1.Right()-aBndR1.Right(); // Abstand bei Obj1
1065 							long nWant2=aBndR2.Left()-aBewR2.Left();   // Abstand bei Obj2
1066 							long nSpace=aBndR2.Left()-aBndR1.Right(); // verfuegbarer Platz
1067 							long nGet1=BigMulDiv(nWant1,nSpace,nWant1+nWant2);
1068 							long nGet2=nSpace-nGet1;
1069 							if (bRts1) { // Normalisierung zurueckwandeln
1070 								aBewareRect1.Right()+=nGet1-nWant1;
1071 								aBewareRect2.Left()-=nGet2-nWant2;
1072 							} else {
1073 								aBewareRect2.Right()+=nGet1-nWant1;
1074 								aBewareRect1.Left()-=nGet2-nWant2;
1075 							}
1076 							nIntersections++; // Qualitaet herabsetzen
1077 						}
1078 					}
1079 				}
1080 			} else if (bVer1) { // beide senkrecht
1081 				Rectangle aBewR1(bUnt1 ? aBewareRect1 : aBewareRect2);
1082 				Rectangle aBewR2(bUnt1 ? aBewareRect2 : aBewareRect1);
1083 				Rectangle aBndR1(bUnt1 ? aBoundRect1 : aBoundRect2);
1084 				Rectangle aBndR2(bUnt1 ? aBoundRect2 : aBoundRect1);
1085 				if (aBewR1.Right()>aBewR2.Left() && aBewR1.Left()<aBewR2.Right()) {
1086 					// Ueberschneidung auf der Y-Achse. Faelle 2.1, 2.8, 2.9
1087 					if (aBewR1.Bottom()>aBewR2.Top()) {
1088 						// Faelle 2.8, 2.9
1089 						// Fall 2.8 ist immer Aussenrumlauf (bDirect=sal_False).
1090 						// Fall 2.9 kann auch Direktverbindung sein (bei geringer
1091 						// Ueberschneidung der BewareRects ohne Ueberschneidung der
1092 						// Boundrects wenn die Linienaustritte sonst das BewareRect
1093 						// des jeweils anderen Objekts verletzen wuerden.
1094 						FASTBOOL bCase29Direct=sal_False;
1095 						FASTBOOL bCase29=aBewR1.Bottom()>aBewR2.Top();
1096 						if (aBndR1.Bottom()<=aBndR2.Top()) { // Fall 2.9 und keine Boundrectueberschneidung
1097 							if ((aPt1.X()>aBewareRect2.Left() && aPt1.X()<aBewareRect2.Right()) ||
1098 								(aPt2.X()>aBewareRect1.Left() && aPt2.X()<aBewareRect1.Right())) {
1099 							   bCase29Direct=sal_True;
1100 							}
1101 						}
1102 						if (!bCase29Direct) {
1103 							FASTBOOL bLinksLang=Abs(nXMin-aMeeting.X())<=Abs(nXMax-aMeeting.X());
1104 							if (bLinksLang) {
1105 								aMeeting.X()=nXMin;
1106 							} else {
1107 								aMeeting.X()=nXMax;
1108 							}
1109 							bMeetingXMid=sal_False;
1110 							if (bCase29) {
1111 								// und nun noch dafuer sorgen, dass das
1112 								// umzingelte Obj nicht durchquert wird
1113 								if ((aBewR1.Center().X()<aBewR2.Center().X()) != bLinksLang) {
1114 									aMeeting.Y()=aBewR2.Bottom();
1115 								} else {
1116 									aMeeting.Y()=aBewR1.Top();
1117 								}
1118 								bMeetingYMid=sal_False;
1119 							}
1120 						} else {
1121 							// Direkte Verbindung (3-Linien Z-Verbindung), da
1122 							// Verletzung der BewareRects unvermeidlich ist.
1123 							// Via Dreisatz werden die BewareRects nun verkleinert.
1124 							long nWant1=aBewR1.Bottom()-aBndR1.Bottom(); // Abstand bei Obj1
1125 							long nWant2=aBndR2.Top()-aBewR2.Top();   // Abstand bei Obj2
1126 							long nSpace=aBndR2.Top()-aBndR1.Bottom(); // verfuegbarer Platz
1127 							long nGet1=BigMulDiv(nWant1,nSpace,nWant1+nWant2);
1128 							long nGet2=nSpace-nGet1;
1129 							if (bUnt1) { // Normalisierung zurueckwandeln
1130 								aBewareRect1.Bottom()+=nGet1-nWant1;
1131 								aBewareRect2.Top()-=nGet2-nWant2;
1132 							} else {
1133 								aBewareRect2.Bottom()+=nGet1-nWant1;
1134 								aBewareRect1.Top()-=nGet2-nWant2;
1135 							}
1136 							nIntersections++; // Qualitaet herabsetzen
1137 						}
1138 					}
1139 				}
1140 			}
1141 		} else if (nMainCase==3) { // Fall 3: Einer waagerecht und der andere senkrecht. Sehr viele Fallunterscheidungen
1142             /* Kleine Legende: � � � � � -> Ohne Ueberschneidung, maximal Beruehrung.                   */
1143             /*                 � � � � � -> Ueberschneidung                                             */
1144             /*                 � � � � � -> Selbe Hoehe                                                 */
1145             /*                 � � � � � -> Ueberschneidung                                             */
1146             /*                 � � � � � -> Ohne Ueberschneidung, maximal Beruehrung.                   */
1147             /* Linienaustritte links �, rechts �, oben � und unten �.                                   */
1148             /* Insgesamt sind 96 Konstellationen moeglich, wobei einige nicht einmal                    */
1149             /* eindeutig einem Fall und damit einer Behandlungsmethode zugeordnet werden                */
1150             /* koennen.                                                                                 */
1151             /* 3.1: Hierzu moegen alle Konstellationen zaehlen, die durch den                           */
1152             /*      Default-MeetingPoint zufriedenstellend abgedeckt sind (20+12).                      */
1153             /*   � � � � �    � � � � �   Diese 12  � � � � �    � � � � �    � � � � �    � � � � �    */
1154             /*   � � � � �    � � � � �   Konstel.  � � � � �    � � � � �    � � � � �    � � � � �    */
1155             /*   � � � � �    � � � � �   jedoch    � � � � �    � � � � �    � � � � �    � � � � �    */
1156             /*   � � � � �    � � � � �   nur zum   � � � � �    � � � � �    � � � � �    � � � � �    */
1157             /*   � � � � �    � � � � �   Teil:     � � � � �    � � � � �    � � � � �    � � � � �    */
1158             /*   Letztere 16 Faelle scheiden aus, sobald sich die Objekte offen                         */
1159             /*   gegenueberstehen (siehe Fall 3.2).                                                     */
1160             /* 3.2: Die Objekte stehen sich offen gegenueber und somit ist eine                         */
1161             /*      Verbindung mit lediglich 2 Linien moeglich (4+20).                                  */
1162             /*      Dieser Fall hat 1. Prioritaet.                                                      */
1163             /*   � � � � �   � � � � �   Diese 20  � � � � �   � � � � �   � � � � �   � � � � �        */
1164             /*   � � � � �   � � � � �   Konstel.  � � � � �   � � � � �   � � � � �   � � � � �        */
1165             /*   � � � � �   � � � � �   jedoch    � � � � �   � � � � �   � � � � �   � � � � �        */
1166             /*   � � � � �   � � � � �   nur zum   � � � � �   � � � � �   � � � � �   � � � � �        */
1167             /*   � � � � �   � � � � �   Teil:     � � � � �   � � � � �   � � � � �   � � � � �        */
1168             /* 3.3: Die Linienaustritte zeigen vom anderen Objekt weg bzw. hinter                       */
1169             /*      dessen Ruecken vorbei (52+4).                                                       */
1170             /*   � � � � �   � � � � �   � � � � �   � � � � �   Diese 4   � � � � �   � � � � �        */
1171             /*   � � � � �   � � � � �   � � � � �   � � � � �   Konstel.  � � � � �   � � � � �        */
1172             /*   � � � � �   � � � � �   � � � � �   � � � � �   jedoch    � � � � �   � � � � �        */
1173             /*   � � � � �   � � � � �   � � � � �   � � � � �   nur zum   � � � � �   � � � � �        */
1174             /*   � � � � �   � � � � �   � � � � �   � � � � �   Teil:     � � � � �   � � � � �        */
1175 
1176 			// Fall 3.2
1177 			Rectangle aTmpR1(aBewareRect1);
1178 			Rectangle aTmpR2(aBewareRect2);
1179 			if (bBewareOverlap) {
1180 				// Ueberschneidung der BewareRects: BoundRects fuer Check auf Fall 3.2 verwenden.
1181 				aTmpR1=aBoundRect1;
1182 				aTmpR2=aBoundRect2;
1183 			}
1184 			if ((((bRts1 && aTmpR1.Right ()<=aPt2.X()) || (bLks1 && aTmpR1.Left()>=aPt2.X())) &&
1185 				 ((bUnt2 && aTmpR2.Bottom()<=aPt1.Y()) || (bObn2 && aTmpR2.Top ()>=aPt1.Y()))) ||
1186 				(((bRts2 && aTmpR2.Right ()<=aPt1.X()) || (bLks2 && aTmpR2.Left()>=aPt1.X())) &&
1187 				 ((bUnt1 && aTmpR1.Bottom()<=aPt2.Y()) || (bObn1 && aTmpR1.Top ()>=aPt2.Y())))) {
1188 				// Fall 3.2 trifft zu: Verbindung mit lediglich 2 Linien
1189 				bForceMeeting=sal_True;
1190 				bMeetingXMid=sal_False;
1191 				bMeetingYMid=sal_False;
1192 				if (bHor1) {
1193 					aMeeting.X()=aPt2.X();
1194 					aMeeting.Y()=aPt1.Y();
1195 				} else {
1196 					aMeeting.X()=aPt1.X();
1197 					aMeeting.Y()=aPt2.Y();
1198 				}
1199 				// Falls Ueberschneidung der BewareRects:
1200 				aBewareRect1=aTmpR1;
1201 				aBewareRect2=aTmpR2;
1202 			} else if ((((bRts1 && aBewareRect1.Right ()>aBewareRect2.Left  ()) ||
1203 						 (bLks1 && aBewareRect1.Left  ()<aBewareRect2.Right ())) &&
1204 						((bUnt2 && aBewareRect2.Bottom()>aBewareRect1.Top   ()) ||
1205 						 (bObn2 && aBewareRect2.Top   ()<aBewareRect1.Bottom()))) ||
1206 					   (((bRts2 && aBewareRect2.Right ()>aBewareRect1.Left  ()) ||
1207 						 (bLks2 && aBewareRect2.Left  ()<aBewareRect1.Right ())) &&
1208 						((bUnt1 && aBewareRect1.Bottom()>aBewareRect2.Top   ()) ||
1209 						 (bObn1 && aBewareRect1.Top   ()<aBewareRect2.Bottom())))) {
1210 				// Fall 3.3
1211 				bForceMeeting=sal_True;
1212 				if (bRts1 || bRts2) { aMeeting.X()=nXMax; bMeetingXMid=sal_False; }
1213 				if (bLks1 || bLks2) { aMeeting.X()=nXMin; bMeetingXMid=sal_False; }
1214 				if (bUnt1 || bUnt2) { aMeeting.Y()=nYMax; bMeetingYMid=sal_False; }
1215 				if (bObn1 || bObn2) { aMeeting.Y()=nYMin; bMeetingYMid=sal_False; }
1216 			}
1217 		}
1218 	}
1219 
1220 	XPolygon aXP1(ImpCalcObjToCenter(aPt1,nAngle1,aBewareRect1,aMeeting));
1221 	XPolygon aXP2(ImpCalcObjToCenter(aPt2,nAngle2,aBewareRect2,aMeeting));
1222 	sal_uInt16 nXP1Anz=aXP1.GetPointCount();
1223 	sal_uInt16 nXP2Anz=aXP2.GetPointCount();
1224 	if (bInfo) {
1225 		pInfo->nObj1Lines=nXP1Anz; if (nXP1Anz>1) pInfo->nObj1Lines--;
1226 		pInfo->nObj2Lines=nXP2Anz; if (nXP2Anz>1) pInfo->nObj2Lines--;
1227 	}
1228 	Point aEP1(aXP1[nXP1Anz-1]);
1229 	Point aEP2(aXP2[nXP2Anz-1]);
1230 	FASTBOOL bInsMeetingPoint=aEP1.X()!=aEP2.X() && aEP1.Y()!=aEP2.Y();
1231 	FASTBOOL bHorzE1=aEP1.Y()==aXP1[nXP1Anz-2].Y(); // letzte Linie von XP1 horizontal?
1232 	FASTBOOL bHorzE2=aEP2.Y()==aXP2[nXP2Anz-2].Y(); // letzte Linie von XP2 horizontal?
1233 	if (aEP1==aEP2 && (bHorzE1 && bHorzE2 && aEP1.Y()==aEP2.Y()) || (!bHorzE1 && !bHorzE2 && aEP1.X()==aEP2.X())) {
1234 		// Sonderbehandlung fuer 'I'-Verbinder
1235 		nXP1Anz--; aXP1.Remove(nXP1Anz,1);
1236 		nXP2Anz--; aXP2.Remove(nXP2Anz,1);
1237 		bMeetingXMid=sal_False;
1238 		bMeetingYMid=sal_False;
1239 	}
1240 	if (bInsMeetingPoint) {
1241 		aXP1.Insert(XPOLY_APPEND,aMeeting,XPOLY_NORMAL);
1242 		if (bInfo) {
1243 			// Durch einfuegen des MeetingPoints kommen 2 weitere Linie hinzu.
1244 			// Evtl. wird eine von diesen die Mittellinie.
1245 			if (pInfo->nObj1Lines==pInfo->nObj2Lines) {
1246 				pInfo->nObj1Lines++;
1247 				pInfo->nObj2Lines++;
1248 			} else {
1249 				if (pInfo->nObj1Lines>pInfo->nObj2Lines) {
1250 					pInfo->nObj2Lines++;
1251 					pInfo->nMiddleLine=nXP1Anz-1;
1252 				} else {
1253 					pInfo->nObj1Lines++;
1254 					pInfo->nMiddleLine=nXP1Anz;
1255 				}
1256 			}
1257 		}
1258 	} else if (bInfo && aEP1!=aEP2 && nXP1Anz+nXP2Anz>=4) {
1259 		// Durch Verbinden der beiden Enden kommt eine weitere Linie hinzu.
1260 		// Dies wird die Mittellinie.
1261 		pInfo->nMiddleLine=nXP1Anz-1;
1262 	}
1263 	sal_uInt16 nNum=aXP2.GetPointCount();
1264 	if (aXP1[nXP1Anz-1]==aXP2[nXP2Anz-1] && nXP1Anz>1 && nXP2Anz>1) nNum--;
1265 	while (nNum>0) {
1266 		nNum--;
1267 		aXP1.Insert(XPOLY_APPEND,aXP2[nNum],XPOLY_NORMAL);
1268 	}
1269 	sal_uInt16 nPntAnz=aXP1.GetPointCount();
1270 	char cForm=0;
1271 	if (bInfo || pnQuality!=NULL) {
1272 		cForm='?';
1273 		if (nPntAnz==2) cForm='I';
1274 		else if (nPntAnz==3) cForm='L';
1275 		else if (nPntAnz==4) { // Z oder U
1276 			if (nAngle1==nAngle2) cForm='U';
1277 			else cForm='Z';
1278         } else if (nPntAnz==4) { /* �-�  �-�  */
1279             /* ...                 -�     -�  */
1280 		} else if (nPntAnz==6) { // S oder C oder ...
1281 			if (nAngle1!=nAngle2) {
1282 				// Fuer Typ S hat Linie2 dieselbe Richtung wie Linie4.
1283 				// Bei Typ C sind die beiden genau entgegengesetzt.
1284 				Point aP1(aXP1[1]);
1285 				Point aP2(aXP1[2]);
1286 				Point aP3(aXP1[3]);
1287 				Point aP4(aXP1[4]);
1288 				if (aP1.Y()==aP2.Y()) { // beide Linien Horz
1289 					if ((aP1.X()<aP2.X())==(aP3.X()<aP4.X())) cForm='S';
1290 					else cForm='C';
1291 				} else { // sonst beide Linien Vert
1292 					if ((aP1.Y()<aP2.Y())==(aP3.Y()<aP4.Y())) cForm='S';
1293 					else cForm='C';
1294 				}
1295 			} else cForm='4'; // sonst der 3. Fall mit 5 Linien
1296 		} else cForm='?';  //
1297 		// Weitere Formen:
1298 		if (bInfo) {
1299 			pInfo->cOrthoForm=cForm;
1300 			if (cForm=='I' || cForm=='L' || cForm=='Z' || cForm=='U') {
1301 				pInfo->nObj1Lines=1;
1302 				pInfo->nObj2Lines=1;
1303 				if (cForm=='Z' || cForm=='U') {
1304 					pInfo->nMiddleLine=1;
1305 				} else {
1306 					pInfo->nMiddleLine=0xFFFF;
1307 				}
1308 			} else if (cForm=='S' || cForm=='C') {
1309 				pInfo->nObj1Lines=2;
1310 				pInfo->nObj2Lines=2;
1311 				pInfo->nMiddleLine=2;
1312 			}
1313 		}
1314 	}
1315 	if (pnQuality!=NULL) {
1316 		sal_uIntPtr nQual=0;
1317 		sal_uIntPtr nQual0=nQual; // Ueberlaeufe vorbeugen
1318 		FASTBOOL bOverflow=sal_False;
1319 		Point aPt0(aXP1[0]);
1320 		for (sal_uInt16 nPntNum=1; nPntNum<nPntAnz; nPntNum++) {
1321 			Point aPt1b(aXP1[nPntNum]);
1322 			nQual+=Abs(aPt1b.X()-aPt0.X())+Abs(aPt1b.Y()-aPt0.Y());
1323 			if (nQual<nQual0) bOverflow=sal_True;
1324 			nQual0=nQual;
1325 			aPt0=aPt1b;
1326 		}
1327 
1328 		sal_uInt16 nTmp=nPntAnz;
1329 		if (cForm=='Z') {
1330 			nTmp=2; // Z-Form hat gute Qualitaet (nTmp=2 statt 4)
1331 			sal_uIntPtr n1=Abs(aXP1[1].X()-aXP1[0].X())+Abs(aXP1[1].Y()-aXP1[0].Y());
1332 			sal_uIntPtr n2=Abs(aXP1[2].X()-aXP1[1].X())+Abs(aXP1[2].Y()-aXP1[1].Y());
1333 			sal_uIntPtr n3=Abs(aXP1[3].X()-aXP1[2].X())+Abs(aXP1[3].Y()-aXP1[2].Y());
1334 			// fuer moeglichst gleichlange Linien sorgen
1335 			sal_uIntPtr nBesser=0;
1336 			n1+=n3;
1337 			n3=n2/4;
1338 			if (n1>=n2) nBesser=6;
1339 			else if (n1>=3*n3) nBesser=4;
1340 			else if (n1>=2*n3) nBesser=2;
1341 			if (aXP1[0].Y()!=aXP1[1].Y()) nBesser++; // Senkrechte Startlinie kriegt auch noch einen Pluspunkt (fuer H/V-Prio)
1342 			if (nQual>nBesser) nQual-=nBesser; else nQual=0;
1343 		}
1344 		if (nTmp>=3) {
1345 			nQual0=nQual;
1346 			nQual+=(sal_uIntPtr)nTmp*0x01000000;
1347 			if (nQual<nQual0 || nTmp>15) bOverflow=sal_True;
1348 		}
1349 		if (nPntAnz>=2) { // Austrittswinkel nochmal pruefen
1350 			Point aP1(aXP1[1]); aP1-=aXP1[0];
1351 			Point aP2(aXP1[nPntAnz-2]); aP2-=aXP1[nPntAnz-1];
1352 			long nAng1=0; if (aP1.X()<0) nAng1=18000; if (aP1.Y()>0) nAng1=27000;
1353 			if (aP1.Y()<0) nAng1=9000; if (aP1.X()!=0 && aP1.Y()!=0) nAng1=1; // Schraeg!?!
1354 			long nAng2=0; if (aP2.X()<0) nAng2=18000; if (aP2.Y()>0) nAng2=27000;
1355 			if (aP2.Y()<0) nAng2=9000; if (aP2.X()!=0 && aP2.Y()!=0) nAng2=1; // Schraeg!?!
1356 			if (nAng1!=nAngle1) nIntersections++;
1357 			if (nAng2!=nAngle2) nIntersections++;
1358 		}
1359 
1360 		// Fuer den Qualitaetscheck wieder die Original-Rects verwenden und
1361 		// gleichzeitig checken, ob eins fuer die Edge-Berechnung verkleinert
1362 		// wurde (z.B. Fall 2.9)
1363 		aBewareRect1=rBewareRect1;
1364 		aBewareRect2=rBewareRect2;
1365 
1366 		for (sal_uInt16 i=0; i<nPntAnz; i++) {
1367 			Point aPt1b(aXP1[i]);
1368 			FASTBOOL b1=aPt1b.X()>aBewareRect1.Left() && aPt1b.X()<aBewareRect1.Right() &&
1369 						aPt1b.Y()>aBewareRect1.Top() && aPt1b.Y()<aBewareRect1.Bottom();
1370 			FASTBOOL b2=aPt1b.X()>aBewareRect2.Left() && aPt1b.X()<aBewareRect2.Right() &&
1371 						aPt1b.Y()>aBewareRect2.Top() && aPt1b.Y()<aBewareRect2.Bottom();
1372 			sal_uInt16 nInt0=nIntersections;
1373 			if (i==0 || i==nPntAnz-1) {
1374 				if (b1 && b2) nIntersections++;
1375 			} else {
1376 				if (b1) nIntersections++;
1377 				if (b2) nIntersections++;
1378 			}
1379 			// und nun noch auf Ueberschneidungen checken
1380 			if (i>0 && nInt0==nIntersections) {
1381 				if (aPt0.Y()==aPt1b.Y()) { // Horizontale Linie
1382 					if (aPt0.Y()>aBewareRect1.Top() && aPt0.Y()<aBewareRect1.Bottom() &&
1383 						((aPt0.X()<=aBewareRect1.Left() && aPt1b.X()>=aBewareRect1.Right()) ||
1384 						 (aPt1b.X()<=aBewareRect1.Left() && aPt0.X()>=aBewareRect1.Right()))) nIntersections++;
1385 					if (aPt0.Y()>aBewareRect2.Top() && aPt0.Y()<aBewareRect2.Bottom() &&
1386 						((aPt0.X()<=aBewareRect2.Left() && aPt1b.X()>=aBewareRect2.Right()) ||
1387 						 (aPt1b.X()<=aBewareRect2.Left() && aPt0.X()>=aBewareRect2.Right()))) nIntersections++;
1388 				} else { // Vertikale Linie
1389 					if (aPt0.X()>aBewareRect1.Left() && aPt0.X()<aBewareRect1.Right() &&
1390 						((aPt0.Y()<=aBewareRect1.Top() && aPt1b.Y()>=aBewareRect1.Bottom()) ||
1391 						 (aPt1b.Y()<=aBewareRect1.Top() && aPt0.Y()>=aBewareRect1.Bottom()))) nIntersections++;
1392 					if (aPt0.X()>aBewareRect2.Left() && aPt0.X()<aBewareRect2.Right() &&
1393 						((aPt0.Y()<=aBewareRect2.Top() && aPt1b.Y()>=aBewareRect2.Bottom()) ||
1394 						 (aPt1b.Y()<=aBewareRect2.Top() && aPt0.Y()>=aBewareRect2.Bottom()))) nIntersections++;
1395 				}
1396 			}
1397 			aPt0=aPt1b;
1398 		}
1399 		if (nPntAnz<=1) nIntersections++;
1400 		nQual0=nQual;
1401 		nQual+=(sal_uIntPtr)nIntersections*0x10000000;
1402 		if (nQual<nQual0 || nIntersections>15) bOverflow=sal_True;
1403 
1404 		if (bOverflow || nQual==0xFFFFFFFF) nQual=0xFFFFFFFE;
1405 		*pnQuality=nQual;
1406 	}
1407 	if (bInfo) { // nun die Linienversaetze auf aXP1 anwenden
1408 		if (pInfo->nMiddleLine!=0xFFFF) {
1409 			sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(MIDDLELINE,aXP1);
1410 			if (pInfo->ImpIsHorzLine(MIDDLELINE,aXP1)) {
1411 				aXP1[nIdx].Y()+=pInfo->aMiddleLine.Y();
1412 				aXP1[nIdx+1].Y()+=pInfo->aMiddleLine.Y();
1413 			} else {
1414 				aXP1[nIdx].X()+=pInfo->aMiddleLine.X();
1415 				aXP1[nIdx+1].X()+=pInfo->aMiddleLine.X();
1416 			}
1417 		}
1418 		if (pInfo->nObj1Lines>=2) {
1419 			sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(OBJ1LINE2,aXP1);
1420 			if (pInfo->ImpIsHorzLine(OBJ1LINE2,aXP1)) {
1421 				aXP1[nIdx].Y()+=pInfo->aObj1Line2.Y();
1422 				aXP1[nIdx+1].Y()+=pInfo->aObj1Line2.Y();
1423 			} else {
1424 				aXP1[nIdx].X()+=pInfo->aObj1Line2.X();
1425 				aXP1[nIdx+1].X()+=pInfo->aObj1Line2.X();
1426 			}
1427 		}
1428 		if (pInfo->nObj1Lines>=3) {
1429 			sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(OBJ1LINE3,aXP1);
1430 			if (pInfo->ImpIsHorzLine(OBJ1LINE3,aXP1)) {
1431 				aXP1[nIdx].Y()+=pInfo->aObj1Line3.Y();
1432 				aXP1[nIdx+1].Y()+=pInfo->aObj1Line3.Y();
1433 			} else {
1434 				aXP1[nIdx].X()+=pInfo->aObj1Line3.X();
1435 				aXP1[nIdx+1].X()+=pInfo->aObj1Line3.X();
1436 			}
1437 		}
1438 		if (pInfo->nObj2Lines>=2) {
1439 			sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(OBJ2LINE2,aXP1);
1440 			if (pInfo->ImpIsHorzLine(OBJ2LINE2,aXP1)) {
1441 				aXP1[nIdx].Y()+=pInfo->aObj2Line2.Y();
1442 				aXP1[nIdx+1].Y()+=pInfo->aObj2Line2.Y();
1443 			} else {
1444 				aXP1[nIdx].X()+=pInfo->aObj2Line2.X();
1445 				aXP1[nIdx+1].X()+=pInfo->aObj2Line2.X();
1446 			}
1447 		}
1448 		if (pInfo->nObj2Lines>=3) {
1449 			sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(OBJ2LINE3,aXP1);
1450 			if (pInfo->ImpIsHorzLine(OBJ2LINE3,aXP1)) {
1451 				aXP1[nIdx].Y()+=pInfo->aObj2Line3.Y();
1452 				aXP1[nIdx+1].Y()+=pInfo->aObj2Line3.Y();
1453 			} else {
1454 				aXP1[nIdx].X()+=pInfo->aObj2Line3.X();
1455 				aXP1[nIdx+1].X()+=pInfo->aObj2Line3.X();
1456 			}
1457 		}
1458 	}
1459 	// Nun mache ich ggf. aus dem Verbinder eine Bezierkurve
1460 	if (eKind==SDREDGE_BEZIER && nPntAnz>2) {
1461 		Point* pPt1=&aXP1[0];
1462 		Point* pPt2=&aXP1[1];
1463 		Point* pPt3=&aXP1[nPntAnz-2];
1464 		Point* pPt4=&aXP1[nPntAnz-1];
1465 		long dx1=pPt2->X()-pPt1->X();
1466 		long dy1=pPt2->Y()-pPt1->Y();
1467 		long dx2=pPt3->X()-pPt4->X();
1468 		long dy2=pPt3->Y()-pPt4->Y();
1469 		if (cForm=='L') { // nPntAnz==3
1470 			aXP1.SetFlags(1,XPOLY_CONTROL);
1471 			Point aPt3(*pPt2);
1472 			aXP1.Insert(2,aPt3,XPOLY_CONTROL);
1473 			nPntAnz=aXP1.GetPointCount();
1474 			pPt1=&aXP1[0];
1475 			pPt2=&aXP1[1];
1476 			pPt3=&aXP1[nPntAnz-2];
1477 			pPt4=&aXP1[nPntAnz-1];
1478 			pPt2->X()-=dx1/3;
1479 			pPt2->Y()-=dy1/3;
1480 			pPt3->X()-=dx2/3;
1481 			pPt3->Y()-=dy2/3;
1482 		} else if (nPntAnz>=4 && nPntAnz<=6) { // Z oder U oder ...
1483 			// fuer Alle Anderen werden die Endpunkte der Ausgangslinien
1484 			// erstmal zu Kontrollpunkten. Bei nPntAnz>4 ist also noch
1485 			// Nacharbeit erforderlich!
1486 			aXP1.SetFlags(1,XPOLY_CONTROL);
1487 			aXP1.SetFlags(nPntAnz-2,XPOLY_CONTROL);
1488 			// Distanz x1.5
1489 			pPt2->X()+=dx1/2;
1490 			pPt2->Y()+=dy1/2;
1491 			pPt3->X()+=dx2/2;
1492 			pPt3->Y()+=dy2/2;
1493 			if (nPntAnz==5) {
1494 				// Vor und hinter dem Mittelpunkt jeweils
1495 				// noch einen Kontrollpunkt einfuegen
1496 				Point aCenter(aXP1[2]);
1497 				long dx1b=aCenter.X()-aXP1[1].X();
1498 				long dy1b=aCenter.Y()-aXP1[1].Y();
1499 				long dx2b=aCenter.X()-aXP1[3].X();
1500 				long dy2b=aCenter.Y()-aXP1[3].Y();
1501 				aXP1.Insert(2,aCenter,XPOLY_CONTROL);
1502 				aXP1.SetFlags(3,XPOLY_SYMMTR);
1503 				aXP1.Insert(4,aCenter,XPOLY_CONTROL);
1504 				aXP1[2].X()-=dx1b/2;
1505 				aXP1[2].Y()-=dy1b/2;
1506 				aXP1[3].X()-=(dx1b+dx2b)/4;
1507 				aXP1[3].Y()-=(dy1b+dy2b)/4;
1508 				aXP1[4].X()-=dx2b/2;
1509 				aXP1[4].Y()-=dy2b/2;
1510 			}
1511 			if (nPntAnz==6) {
1512 				Point aPt1b(aXP1[2]);
1513 				Point aPt2b(aXP1[3]);
1514 				aXP1.Insert(2,aPt1b,XPOLY_CONTROL);
1515 				aXP1.Insert(5,aPt2b,XPOLY_CONTROL);
1516 				long dx=aPt1b.X()-aPt2b.X();
1517 				long dy=aPt1b.Y()-aPt2b.Y();
1518 				aXP1[3].X()-=dx/2;
1519 				aXP1[3].Y()-=dy/2;
1520 				aXP1.SetFlags(3,XPOLY_SYMMTR);
1521 				//aXP1[4].X()+=dx/2;
1522 				//aXP1[4].Y()+=dy/2;
1523 				aXP1.Remove(4,1); // weil identisch mit aXP1[3]
1524 			}
1525 		}
1526 	}
1527 	return aXP1;
1528 }
1529 
1530 /*
1531 Nach einer einfachen Rechnung koennte es max. 64 unterschiedliche Verlaeufe mit
1532 5 Linien, 32 mit 4 Linien, 16 mit 3, 8 mit 2 Linien und 4 mit 1 Linie geben=124.
1533 Normalisiert auf 1. Austrittswinkel nach rechts bleiben dann noch 31.
1534 Dann noch eine vertikale Spiegelung wegnormalisiert bleiben noch 16
1535 characteristische Verlaufszuege mit 1-5 Linien:
1536 Mit 1 Linie (Typ 'I'):  --
1537 Mit 2 Linien (Typ 'L'): -�
1538 Mit 3 Linien (Typ 'U'):  -�  (Typ 'Z'):  �-
1539 						 -�             -�
1540 Mit 4 Linien: 1 ist nicht plausibel, 3 ist=2 (90deg Drehung). Verbleibt 2,4
1541 	 �-�  ڿ  ��  ڿ                               ڿ  �-�
1542 	-�   -�   -�  -�                              -�    -�
1543 Mit 5 Linien: nicht plausibel sind 1,2,4,5. 7 ist identisch mit 3 (Richtungsumkehr)
1544 			  Bleibt also 3,6 und 8.              '4'  'S'  'C'
1545 	   �    �             -�   �-  �-�                  �-
1546 	 �-�  �-�  �-�   �-�   ��  �� -� � �-�         �-�  ��  �-�
1547 	-�   -�   -� �  -� �-  -�  -�  --� � �        -� �  -�  � �
1548 Insgesamt sind also 9 Grundtypen zu unterscheiden die den 400 Konstellationen
1549 aus Objektposition und Austrittswinkeln zuzuordnen sind.
1550 4 der 9 Grundtypen haben eine 'Mittellinie'. Die Anzahl der zu Objektabstaende
1551 je Objekt variiert von 0-3:
1552 	 Mi   O1   O2   Anmerkung
1553 'I':  n   0    0
1554 'L':  n   0    0
1555 'U':  n  0-1  0-1
1556 'Z':  j   0    0
1557 4.1:  j   0    1    = U+1 bzw. 1+U
1558 4.2:  n  0-2  0-2   = Z+1
1559 '4':  j   0    2    = Z+2
1560 'S':  j   1    1    = 1+Z+1
1561 'C':  n  0-3  0-3   = 1+U+1
1562 */
1563 
1564 void __EXPORT SdrEdgeObj::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
1565 {
1566 	SfxSimpleHint* pSimple=PTR_CAST(SfxSimpleHint,&rHint);
1567 	sal_uIntPtr nId=pSimple==0 ? 0 : pSimple->GetId();
1568 	FASTBOOL bDataChg=nId==SFX_HINT_DATACHANGED;
1569 	FASTBOOL bDying=nId==SFX_HINT_DYING;
1570 	FASTBOOL bObj1=aCon1.pObj!=NULL && aCon1.pObj->GetBroadcaster()==&rBC;
1571 	FASTBOOL bObj2=aCon2.pObj!=NULL && aCon2.pObj->GetBroadcaster()==&rBC;
1572 	if (bDying && (bObj1 || bObj2)) {
1573 		// #35605# Dying vorher abfangen, damit AttrObj nicht
1574 		// wg. vermeintlicher Vorlagenaenderung rumbroadcastet
1575 		if (bObj1) aCon1.pObj=NULL;
1576 		if (bObj2) aCon2.pObj=NULL;
1577 		return; // Und mehr braucht hier nicht getan werden.
1578 	}
1579 	if ( bObj1 || bObj2 )
1580 	{
1581 		bEdgeTrackUserDefined = sal_False;
1582 	}
1583     SdrTextObj::Notify(rBC,rHint);
1584 	if (nNotifyingCount==0) { // Hier nun auch ein VerriegelungsFlag
1585 		((SdrEdgeObj*)this)->nNotifyingCount++;
1586 		SdrHint* pSdrHint=PTR_CAST(SdrHint,&rHint);
1587 		if (bDataChg) { // StyleSheet geaendert
1588 			ImpSetAttrToEdgeInfo(); // Werte bei Vorlagenaenderung vom Pool nach aEdgeInfo kopieren
1589 		}
1590 		if (bDataChg                                ||
1591 			(bObj1 && aCon1.pObj->GetPage()==pPage) ||
1592 			(bObj2 && aCon2.pObj->GetPage()==pPage) ||
1593 			(pSdrHint && pSdrHint->GetKind()==HINT_OBJREMOVED))
1594 		{
1595 			// Broadcasting nur, wenn auf der selben Page
1596 			Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetCurrentBoundRect();
1597 			// #110094#-14 if (!bEdgeTrackDirty) SendRepaintBroadcast();
1598 			ImpDirtyEdgeTrack();
1599 
1600 			// only redraw here, no objectchange
1601 			ActionChanged();
1602 			// BroadcastObjectChange();
1603 
1604 			SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1605 		}
1606 		((SdrEdgeObj*)this)->nNotifyingCount--;
1607 	}
1608 }
1609 
1610 /** updates edges that are connected to the edges of this object
1611 	as if the connected objects send a repaint broadcast
1612 	#103122#
1613 */
1614 void SdrEdgeObj::Reformat()
1615 {
1616 	if( NULL != aCon1.pObj )
1617 	{
1618 		SfxSimpleHint aHint( SFX_HINT_DATACHANGED );
1619 		Notify( *const_cast<SfxBroadcaster*>(aCon1.pObj->GetBroadcaster()), aHint );
1620 	}
1621 
1622 	if( NULL != aCon2.pObj )
1623 	{
1624 		SfxSimpleHint aHint( SFX_HINT_DATACHANGED );
1625 		Notify( *const_cast<SfxBroadcaster*>(aCon2.pObj->GetBroadcaster()), aHint );
1626 	}
1627 }
1628 
1629 void SdrEdgeObj::operator=(const SdrObject& rObj)
1630 {
1631 	SdrTextObj::operator=(rObj);
1632 	*pEdgeTrack    =*((SdrEdgeObj&)rObj).pEdgeTrack;
1633 	bEdgeTrackDirty=((SdrEdgeObj&)rObj).bEdgeTrackDirty;
1634 	aCon1          =((SdrEdgeObj&)rObj).aCon1;
1635 	aCon2          =((SdrEdgeObj&)rObj).aCon2;
1636 	aCon1.pObj=NULL;
1637 	aCon2.pObj=NULL;
1638 	aEdgeInfo=((SdrEdgeObj&)rObj).aEdgeInfo;
1639 }
1640 
1641 void SdrEdgeObj::TakeObjNameSingul(XubString& rName) const
1642 {
1643 	rName=ImpGetResStr(STR_ObjNameSingulEDGE);
1644 
1645 	String aName( GetName() );
1646 	if(aName.Len())
1647 	{
1648 		rName += sal_Unicode(' ');
1649 		rName += sal_Unicode('\'');
1650 		rName += aName;
1651 		rName += sal_Unicode('\'');
1652 	}
1653 }
1654 
1655 void SdrEdgeObj::TakeObjNamePlural(XubString& rName) const
1656 {
1657 	rName=ImpGetResStr(STR_ObjNamePluralEDGE);
1658 }
1659 
1660 basegfx::B2DPolyPolygon SdrEdgeObj::TakeXorPoly() const
1661 {
1662 	basegfx::B2DPolyPolygon aPolyPolygon;
1663 
1664 	if (bEdgeTrackDirty)
1665 	{
1666 		((SdrEdgeObj*)this)->ImpRecalcEdgeTrack();
1667 	}
1668 
1669 	if(pEdgeTrack)
1670 	{
1671 		aPolyPolygon.append(pEdgeTrack->getB2DPolygon());
1672 	}
1673 
1674 	return aPolyPolygon;
1675 }
1676 
1677 void SdrEdgeObj::SetEdgeTrackPath( const basegfx::B2DPolyPolygon& rPoly )
1678 {
1679 	if ( !rPoly.count() )
1680 	{
1681 		bEdgeTrackDirty = sal_True;
1682 		bEdgeTrackUserDefined = sal_False;
1683 	}
1684 	else
1685 	{
1686 		*pEdgeTrack = XPolygon( rPoly.getB2DPolygon( 0 ) );
1687 		bEdgeTrackDirty = sal_False;
1688 		bEdgeTrackUserDefined = sal_True;
1689 
1690         // #i110629# also set aRect and maSnapeRect dependent from pEdgeTrack
1691         const Rectangle aPolygonBounds(pEdgeTrack->GetBoundRect());
1692         aRect = aPolygonBounds;
1693         maSnapRect = aPolygonBounds;
1694 	}
1695 }
1696 
1697 basegfx::B2DPolyPolygon SdrEdgeObj::GetEdgeTrackPath() const
1698 {
1699 	basegfx::B2DPolyPolygon aPolyPolygon;
1700 
1701 	if (bEdgeTrackDirty)
1702 		((SdrEdgeObj*)this)->ImpRecalcEdgeTrack();
1703 
1704 	aPolyPolygon.append( pEdgeTrack->getB2DPolygon() );
1705 
1706 	return aPolyPolygon;
1707 }
1708 
1709 sal_uInt32 SdrEdgeObj::GetHdlCount() const
1710 {
1711 	SdrEdgeKind eKind=((SdrEdgeKindItem&)(GetObjectItem(SDRATTR_EDGEKIND))).GetValue();
1712 	sal_uInt32 nHdlAnz(0L);
1713 	sal_uInt32 nPntAnz(pEdgeTrack->GetPointCount());
1714 
1715 	if(nPntAnz)
1716 	{
1717 		nHdlAnz = 2L;
1718 
1719 		if ((eKind==SDREDGE_ORTHOLINES || eKind==SDREDGE_BEZIER) && nPntAnz >= 4L)
1720 		{
1721 			sal_uInt32 nO1(aEdgeInfo.nObj1Lines > 0L ? aEdgeInfo.nObj1Lines - 1L : 0L);
1722 			sal_uInt32 nO2(aEdgeInfo.nObj2Lines > 0L ? aEdgeInfo.nObj2Lines - 1L : 0L);
1723 			sal_uInt32 nM(aEdgeInfo.nMiddleLine != 0xFFFF ? 1L : 0L);
1724 			nHdlAnz += nO1 + nO2 + nM;
1725 		}
1726 		else if (eKind==SDREDGE_THREELINES && nPntAnz == 4L)
1727 		{
1728 			if(GetConnectedNode(sal_True))
1729 				nHdlAnz++;
1730 
1731 			if(GetConnectedNode(sal_False))
1732 				nHdlAnz++;
1733 		}
1734 	}
1735 
1736 	return nHdlAnz;
1737 }
1738 
1739 SdrHdl* SdrEdgeObj::GetHdl(sal_uInt32 nHdlNum) const
1740 {
1741 	SdrHdl* pHdl=NULL;
1742 	sal_uInt32 nPntAnz(pEdgeTrack->GetPointCount());
1743 	if (nPntAnz!=0) {
1744 		if (nHdlNum==0) {
1745 			pHdl=new ImpEdgeHdl((*pEdgeTrack)[0],HDL_POLY);
1746 			if (aCon1.pObj!=NULL && aCon1.bBestVertex) pHdl->Set1PixMore(sal_True);
1747 		} else if (nHdlNum==1) {
1748 			pHdl=new ImpEdgeHdl((*pEdgeTrack)[sal_uInt16(nPntAnz-1)],HDL_POLY);
1749 			if (aCon2.pObj!=NULL && aCon2.bBestVertex) pHdl->Set1PixMore(sal_True);
1750 		} else {
1751 			SdrEdgeKind eKind=((SdrEdgeKindItem&)(GetObjectItem(SDRATTR_EDGEKIND))).GetValue();
1752 			if (eKind==SDREDGE_ORTHOLINES || eKind==SDREDGE_BEZIER) {
1753 				sal_uInt32 nO1(aEdgeInfo.nObj1Lines > 0L ? aEdgeInfo.nObj1Lines - 1L : 0L);
1754 				sal_uInt32 nO2(aEdgeInfo.nObj2Lines > 0L ? aEdgeInfo.nObj2Lines - 1L : 0L);
1755 				sal_uInt32 nM(aEdgeInfo.nMiddleLine != 0xFFFF ? 1L : 0L);
1756 				sal_uInt32 nNum(nHdlNum - 2L);
1757 				sal_Int32 nPt(0L);
1758 				pHdl=new ImpEdgeHdl(Point(),HDL_POLY);
1759 				if (nNum<nO1) {
1760 					nPt=nNum+1L;
1761 					if (nNum==0) ((ImpEdgeHdl*)pHdl)->SetLineCode(OBJ1LINE2);
1762 					if (nNum==1) ((ImpEdgeHdl*)pHdl)->SetLineCode(OBJ1LINE3);
1763 				} else {
1764 					nNum=nNum-nO1;
1765 					if (nNum<nO2) {
1766 						nPt=nPntAnz-3-nNum;
1767 						if (nNum==0) ((ImpEdgeHdl*)pHdl)->SetLineCode(OBJ2LINE2);
1768 						if (nNum==1) ((ImpEdgeHdl*)pHdl)->SetLineCode(OBJ2LINE3);
1769 					} else {
1770 						nNum=nNum-nO2;
1771 						if (nNum<nM) {
1772 							nPt=aEdgeInfo.nMiddleLine;
1773 							((ImpEdgeHdl*)pHdl)->SetLineCode(MIDDLELINE);
1774 						}
1775 					}
1776 				}
1777 				if (nPt>0) {
1778 					Point aPos((*pEdgeTrack)[(sal_uInt16)nPt]);
1779 					aPos+=(*pEdgeTrack)[(sal_uInt16)nPt+1];
1780 					aPos.X()/=2;
1781 					aPos.Y()/=2;
1782 					pHdl->SetPos(aPos);
1783 				} else {
1784 					delete pHdl;
1785 					pHdl=NULL;
1786 				}
1787 			} else if (eKind==SDREDGE_THREELINES) {
1788 				sal_uInt32 nNum(nHdlNum);
1789 				if (GetConnectedNode(sal_True)==NULL) nNum++;
1790 				Point aPos((*pEdgeTrack)[(sal_uInt16)nNum-1]);
1791 				pHdl=new ImpEdgeHdl(aPos,HDL_POLY);
1792 				if (nNum==2) ((ImpEdgeHdl*)pHdl)->SetLineCode(OBJ1LINE2);
1793 				if (nNum==3) ((ImpEdgeHdl*)pHdl)->SetLineCode(OBJ2LINE2);
1794 			}
1795 		}
1796 		if (pHdl!=NULL) {
1797 			pHdl->SetPointNum(nHdlNum);
1798 		}
1799 	}
1800 	return pHdl;
1801 }
1802 
1803 ////////////////////////////////////////////////////////////////////////////////////////////////////
1804 
1805 bool SdrEdgeObj::hasSpecialDrag() const
1806 {
1807 	return true;
1808 }
1809 
1810 SdrObject* SdrEdgeObj::getFullDragClone() const
1811 {
1812 	// use Clone operator
1813 	SdrEdgeObj* pRetval = (SdrEdgeObj*)Clone();
1814 
1815 	// copy connections for clone, SdrEdgeObj::operator= does not do this
1816     pRetval->ConnectToNode(true, GetConnectedNode(true));
1817     pRetval->ConnectToNode(false, GetConnectedNode(false));
1818 
1819 	return pRetval;
1820 }
1821 
1822 bool SdrEdgeObj::beginSpecialDrag(SdrDragStat& rDrag) const
1823 {
1824 	if(!rDrag.GetHdl())
1825         return false;
1826 
1827     rDrag.SetEndDragChangesAttributes(true);
1828 
1829     if(rDrag.GetHdl()->GetPointNum() < 2)
1830     {
1831         rDrag.SetNoSnap(true);
1832 	}
1833 
1834     return true;
1835 }
1836 
1837 bool SdrEdgeObj::applySpecialDrag(SdrDragStat& rDragStat)
1838 {
1839     SdrEdgeObj* pOriginalEdge = dynamic_cast< SdrEdgeObj* >(rDragStat.GetHdl()->GetObj());
1840     const bool bOriginalEdgeModified(pOriginalEdge == this);
1841 
1842 	if(!bOriginalEdgeModified && pOriginalEdge)
1843 	{
1844         // copy connections when clone is modified. This is needed because
1845 		// as preparation to this modification the data from the original object
1846 		// was copied to the clone using the operator=. As can be seen there,
1847 		// that operator does not copy the connections (for good reason)
1848 		ConnectToNode(true, pOriginalEdge->GetConnection(true).GetObject());
1849 		ConnectToNode(false, pOriginalEdge->GetConnection(false).GetObject());
1850 	}
1851 
1852     if(rDragStat.GetHdl()->GetPointNum() < 2)
1853     {
1854 		// start or end point connector drag
1855         const bool bDragA(0 == rDragStat.GetHdl()->GetPointNum());
1856         const Point aPointNow(rDragStat.GetNow());
1857 
1858         if(rDragStat.GetPageView())
1859         {
1860             SdrObjConnection* pDraggedOne(bDragA ? &aCon1 : &aCon2);
1861 
1862 			// clear connection
1863 			DisconnectFromNode(bDragA);
1864 
1865 			// look for new connection
1866 			ImpFindConnector(aPointNow, *rDragStat.GetPageView(), *pDraggedOne, pOriginalEdge);
1867 
1868 			if(pDraggedOne->pObj)
1869 			{
1870 				// if found, officially connect to it; ImpFindConnector only
1871 				// sets pObj hard
1872 				SdrObject* pNewConnection = pDraggedOne->pObj;
1873 				pDraggedOne->pObj = 0;
1874 				ConnectToNode(bDragA, pNewConnection);
1875 			}
1876 
1877             if(rDragStat.GetView() && !bOriginalEdgeModified)
1878             {
1879 				// show IA helper, but only do this during IA, so not when the original
1880 				// Edge gets modified in the last call
1881 			    rDragStat.GetView()->SetConnectMarker(*pDraggedOne, *rDragStat.GetPageView());
1882             }
1883         }
1884 
1885         if(pEdgeTrack)
1886         {
1887 			// change pEdgeTrack to modified position
1888             if(bDragA)
1889             {
1890                 (*pEdgeTrack)[0] = aPointNow;
1891             }
1892             else
1893             {
1894                 (*pEdgeTrack)[sal_uInt16(pEdgeTrack->GetPointCount()-1)] = aPointNow;
1895             }
1896         }
1897 
1898 		// reset edge info's offsets, this is a end point drag
1899         aEdgeInfo.aObj1Line2 = Point();
1900 		aEdgeInfo.aObj1Line3 = Point();
1901 		aEdgeInfo.aObj2Line2 = Point();
1902 		aEdgeInfo.aObj2Line3 = Point();
1903 		aEdgeInfo.aMiddleLine = Point();
1904 	}
1905     else
1906     {
1907 		// control point connector drag
1908 	    const ImpEdgeHdl* pEdgeHdl = (ImpEdgeHdl*)rDragStat.GetHdl();
1909 		const SdrEdgeLineCode eLineCode = pEdgeHdl->GetLineCode();
1910 		const Point aDist(rDragStat.GetNow() - rDragStat.GetStart());
1911         sal_Int32 nDist(pEdgeHdl->IsHorzDrag() ? aDist.X() : aDist.Y());
1912 
1913         nDist += aEdgeInfo.ImpGetLineVersatz(eLineCode, *pEdgeTrack);
1914 		aEdgeInfo.ImpSetLineVersatz(eLineCode, *pEdgeTrack, nDist);
1915 	}
1916 
1917 	// force recalc EdgeTrack
1918 	*pEdgeTrack = ImpCalcEdgeTrack(*pEdgeTrack, aCon1, aCon2, &aEdgeInfo);
1919 	bEdgeTrackDirty=sal_False;
1920 
1921 	// save EdgeInfos and mark object as user modified
1922 	ImpSetEdgeInfoToAttr();
1923 	bEdgeTrackUserDefined = false;
1924 	SetRectsDirty();
1925 	//SetChanged();
1926 
1927     if(bOriginalEdgeModified && rDragStat.GetView())
1928     {
1929 		// hide connect marker helper again when original gets changed.
1930 		// This happens at the end of the interaction
1931 		rDragStat.GetView()->HideConnectMarker();
1932 	}
1933 
1934    	return true;
1935 }
1936 
1937 String SdrEdgeObj::getSpecialDragComment(const SdrDragStat& rDrag) const
1938 {
1939     const bool bCreateComment(rDrag.GetView() && this == rDrag.GetView()->GetCreateObj());
1940 
1941     if(bCreateComment)
1942     {
1943         return String();
1944     }
1945     else
1946     {
1947 	    XubString aStr;
1948 	    ImpTakeDescriptionStr(STR_DragEdgeTail, aStr);
1949 
1950         return aStr;
1951     }
1952 }
1953 
1954 ////////////////////////////////////////////////////////////////////////////////////////////////////
1955 
1956 basegfx::B2DPolygon SdrEdgeObj::ImplAddConnectorOverlay(SdrDragMethod& rDragMethod, bool bTail1, bool bTail2, bool bDetail) const
1957 {
1958 	basegfx::B2DPolygon aResult;
1959 
1960 	if(bDetail)
1961 	{
1962 		SdrObjConnection aMyCon1(aCon1);
1963 		SdrObjConnection aMyCon2(aCon2);
1964 
1965 		if (bTail1)
1966 		{
1967 			const basegfx::B2DPoint aTemp(rDragMethod.getCurrentTransformation() * basegfx::B2DPoint(aMyCon1.aObjOfs.X(), aMyCon1.aObjOfs.Y()));
1968 			aMyCon1.aObjOfs.X() = basegfx::fround(aTemp.getX());
1969 			aMyCon1.aObjOfs.Y() = basegfx::fround(aTemp.getY());
1970 		}
1971 
1972 		if (bTail2)
1973 		{
1974 			const basegfx::B2DPoint aTemp(rDragMethod.getCurrentTransformation() * basegfx::B2DPoint(aMyCon2.aObjOfs.X(), aMyCon2.aObjOfs.Y()));
1975 			aMyCon2.aObjOfs.X() = basegfx::fround(aTemp.getX());
1976 			aMyCon2.aObjOfs.Y() = basegfx::fround(aTemp.getY());
1977 		}
1978 
1979 		SdrEdgeInfoRec aInfo(aEdgeInfo);
1980 		XPolygon aXP(ImpCalcEdgeTrack(*pEdgeTrack, aMyCon1, aMyCon2, &aInfo));
1981 
1982 		if(aXP.GetPointCount())
1983 		{
1984 			aResult = aXP.getB2DPolygon();
1985 		}
1986 	}
1987 	else
1988 	{
1989 		Point aPt1((*pEdgeTrack)[0]);
1990 		Point aPt2((*pEdgeTrack)[sal_uInt16(pEdgeTrack->GetPointCount() - 1)]);
1991 
1992 		if (aCon1.pObj && (aCon1.bBestConn || aCon1.bBestVertex))
1993 			aPt1 = aCon1.pObj->GetSnapRect().Center();
1994 
1995 		if (aCon2.pObj && (aCon2.bBestConn || aCon2.bBestVertex))
1996 			aPt2 = aCon2.pObj->GetSnapRect().Center();
1997 
1998 		if (bTail1)
1999 		{
2000 			const basegfx::B2DPoint aTemp(rDragMethod.getCurrentTransformation() * basegfx::B2DPoint(aPt1.X(), aPt1.Y()));
2001 			aPt1.X() = basegfx::fround(aTemp.getX());
2002 			aPt1.Y() = basegfx::fround(aTemp.getY());
2003 		}
2004 
2005 		if (bTail2)
2006 		{
2007 			const basegfx::B2DPoint aTemp(rDragMethod.getCurrentTransformation() * basegfx::B2DPoint(aPt2.X(), aPt2.Y()));
2008 			aPt2.X() = basegfx::fround(aTemp.getX());
2009 			aPt2.Y() = basegfx::fround(aTemp.getY());
2010 		}
2011 
2012 		aResult.append(basegfx::B2DPoint(aPt1.X(), aPt1.Y()));
2013 		aResult.append(basegfx::B2DPoint(aPt2.X(), aPt2.Y()));
2014 	}
2015 
2016 	return aResult;
2017 }
2018 
2019 FASTBOOL SdrEdgeObj::BegCreate(SdrDragStat& rDragStat)
2020 {
2021 	rDragStat.SetNoSnap(sal_True);
2022 	pEdgeTrack->SetPointCount(2);
2023 	(*pEdgeTrack)[0]=rDragStat.GetStart();
2024 	(*pEdgeTrack)[1]=rDragStat.GetNow();
2025 	if (rDragStat.GetPageView()!=NULL) {
2026 		ImpFindConnector(rDragStat.GetStart(),*rDragStat.GetPageView(),aCon1,this);
2027 		ConnectToNode(sal_True,aCon1.pObj);
2028 	}
2029 	*pEdgeTrack=ImpCalcEdgeTrack(*pEdgeTrack,aCon1,aCon2,&aEdgeInfo);
2030 	return sal_True;
2031 }
2032 
2033 FASTBOOL SdrEdgeObj::MovCreate(SdrDragStat& rDragStat)
2034 {
2035 	sal_uInt16 nMax=pEdgeTrack->GetPointCount();
2036 	(*pEdgeTrack)[nMax-1]=rDragStat.GetNow();
2037 	if (rDragStat.GetPageView()!=NULL) {
2038 		ImpFindConnector(rDragStat.GetNow(),*rDragStat.GetPageView(),aCon2,this);
2039 		rDragStat.GetView()->SetConnectMarker(aCon2,*rDragStat.GetPageView());
2040 	}
2041 	SetBoundRectDirty();
2042 	bSnapRectDirty=sal_True;
2043 	ConnectToNode(sal_False,aCon2.pObj);
2044 	*pEdgeTrack=ImpCalcEdgeTrack(*pEdgeTrack,aCon1,aCon2,&aEdgeInfo);
2045 	bEdgeTrackDirty=sal_False;
2046 	return sal_True;
2047 }
2048 
2049 FASTBOOL SdrEdgeObj::EndCreate(SdrDragStat& rDragStat, SdrCreateCmd eCmd)
2050 {
2051 	FASTBOOL bOk=(eCmd==SDRCREATE_FORCEEND || rDragStat.GetPointAnz()>=2);
2052 	if (bOk) {
2053 		ConnectToNode(sal_True,aCon1.pObj);
2054 		ConnectToNode(sal_False,aCon2.pObj);
2055 		if (rDragStat.GetView()!=NULL) {
2056 			rDragStat.GetView()->HideConnectMarker();
2057 		}
2058 		ImpSetEdgeInfoToAttr(); // Die Werte aus aEdgeInfo in den Pool kopieren
2059 	}
2060 	SetRectsDirty();
2061 	return bOk;
2062 }
2063 
2064 FASTBOOL SdrEdgeObj::BckCreate(SdrDragStat& rDragStat)
2065 {
2066 	if (rDragStat.GetView()!=NULL) {
2067 		rDragStat.GetView()->HideConnectMarker();
2068 	}
2069 	return sal_False;
2070 }
2071 
2072 void SdrEdgeObj::BrkCreate(SdrDragStat& rDragStat)
2073 {
2074 	if (rDragStat.GetView()!=NULL) {
2075 		rDragStat.GetView()->HideConnectMarker();
2076 	}
2077 }
2078 
2079 basegfx::B2DPolyPolygon SdrEdgeObj::TakeCreatePoly(const SdrDragStat& /*rStatDrag*/) const
2080 {
2081 	basegfx::B2DPolyPolygon aRetval;
2082 	aRetval.append(pEdgeTrack->getB2DPolygon());
2083 	return aRetval;
2084 }
2085 
2086 Pointer SdrEdgeObj::GetCreatePointer() const
2087 {
2088 	return Pointer(POINTER_DRAW_CONNECT);
2089 }
2090 
2091 FASTBOOL SdrEdgeObj::ImpFindConnector(const Point& rPt, const SdrPageView& rPV, SdrObjConnection& rCon, const SdrEdgeObj* pThis, OutputDevice* pOut)
2092 {
2093 	rCon.ResetVars();
2094 	if (pOut==NULL) pOut=rPV.GetView().GetFirstOutputDevice(); // GetWin(0);
2095 	if (pOut==NULL) return sal_False;
2096 	SdrObjList* pOL=rPV.GetObjList();
2097 	const SetOfByte& rVisLayer=rPV.GetVisibleLayers();
2098 	// Sensitiver Bereich der Konnektoren ist doppelt so gross wie die Handles:
2099 	sal_uInt16 nMarkHdSiz=rPV.GetView().GetMarkHdlSizePixel();
2100 	Size aHalfConSiz(nMarkHdSiz,nMarkHdSiz);
2101 	aHalfConSiz=pOut->PixelToLogic(aHalfConSiz);
2102 	Size aHalfCenterSiz(2*aHalfConSiz.Width(),2*aHalfConSiz.Height());
2103 	Rectangle aMouseRect(rPt,rPt);
2104 	aMouseRect.Left()  -=aHalfConSiz.Width();
2105 	aMouseRect.Top()   -=aHalfConSiz.Height();
2106 	aMouseRect.Right() +=aHalfConSiz.Width();
2107 	aMouseRect.Bottom()+=aHalfConSiz.Height();
2108 	sal_uInt16 nBoundHitTol=(sal_uInt16)aHalfConSiz.Width()/2; if (nBoundHitTol==0) nBoundHitTol=1;
2109 	sal_uIntPtr no=pOL->GetObjCount();
2110 	FASTBOOL bFnd=sal_False;
2111 	SdrObjConnection aTestCon;
2112 	SdrObjConnection aBestCon;
2113 	FASTBOOL bTestBoundHit=sal_False;
2114 	//int bBestBoundHit=sal_False;
2115 
2116 	while (no>0 && !bFnd) {
2117 		// Problem: Gruppenobjekt mit verschiedenen Layern liefert LayerID 0 !!!!
2118 		no--;
2119 		SdrObject* pObj=pOL->GetObj(no);
2120 		if (rVisLayer.IsSet(pObj->GetLayer()) && pObj->IsVisible() &&      // only visible objects
2121 			(pThis==NULL || pObj!=(SdrObject*)pThis) && // nicht an mich selbst connecten
2122 			pObj->IsNode())
2123 		{
2124 			Rectangle aObjBound(pObj->GetCurrentBoundRect());
2125 			if (aObjBound.IsOver(aMouseRect)) {
2126 				aTestCon.ResetVars();
2127 				bTestBoundHit=sal_False;
2128 				FASTBOOL bEdge=HAS_BASE(SdrEdgeObj,pObj); // kein BestCon fuer Edge
2129 				// Die Userdefined Konnektoren haben absolute Prioritaet.
2130 				// Danach kommt Vertex, Corner und Mitte(Best) gleich priorisiert.
2131 				// Zum Schluss kommt noch ein HitTest aufs Obj.
2132 				const SdrGluePointList* pGPL=pObj->GetGluePointList();
2133 				sal_uInt16 nConAnz=pGPL==NULL ? 0 : pGPL->GetCount();
2134 				sal_uInt16 nGesAnz=nConAnz+9;
2135 				FASTBOOL bUserFnd=sal_False;
2136 				sal_uIntPtr nBestDist=0xFFFFFFFF;
2137 				for (sal_uInt16 i=0; i<nGesAnz; i++)
2138                 {
2139 					FASTBOOL bUser=i<nConAnz;
2140 					FASTBOOL bVertex=i>=nConAnz+0 && i<nConAnz+4;
2141 					FASTBOOL bCorner=i>=nConAnz+4 && i<nConAnz+8;
2142 					FASTBOOL bCenter=i==nConAnz+8;
2143 					FASTBOOL bOk=sal_False;
2144 					Point aConPos;
2145 					sal_uInt16 nConNum=i;
2146 					if (bUser) {
2147 						const SdrGluePoint& rGP=(*pGPL)[nConNum];
2148 						aConPos=rGP.GetAbsolutePos(*pObj);
2149 						nConNum=rGP.GetId();
2150 						bOk=sal_True;
2151 					} else if (bVertex && !bUserFnd) {
2152 						nConNum=nConNum-nConAnz;
2153 						if (rPV.GetView().IsAutoVertexConnectors()) {
2154 							SdrGluePoint aPt(pObj->GetVertexGluePoint(nConNum));
2155 							aConPos=aPt.GetAbsolutePos(*pObj);
2156 							bOk=sal_True;
2157 						} else i+=3;
2158 					} else if (bCorner && !bUserFnd) {
2159 						nConNum-=nConAnz+4;
2160 						if (rPV.GetView().IsAutoCornerConnectors()) {
2161 							SdrGluePoint aPt(pObj->GetCornerGluePoint(nConNum));
2162 							aConPos=aPt.GetAbsolutePos(*pObj);
2163 							bOk=sal_True;
2164 						} else i+=3;
2165 					}
2166 					else if (bCenter && !bUserFnd && !bEdge)
2167 					{
2168 						// #109007#
2169 						// Suppress default connect at object center
2170 						if(!pThis || !pThis->GetSuppressDefaultConnect())
2171 						{
2172 							// Edges nicht!
2173 							nConNum=0;
2174 							aConPos=aObjBound.Center();
2175 							bOk=sal_True;
2176 						}
2177 					}
2178 					if (bOk && aMouseRect.IsInside(aConPos)) {
2179 						if (bUser) bUserFnd=sal_True;
2180 						bFnd=sal_True;
2181 						sal_uIntPtr nDist=(sal_uIntPtr)Abs(aConPos.X()-rPt.X())+(sal_uIntPtr)Abs(aConPos.Y()-rPt.Y());
2182 						if (nDist<nBestDist) {
2183 							nBestDist=nDist;
2184 							aTestCon.pObj=pObj;
2185 							aTestCon.nConId=nConNum;
2186 							aTestCon.bAutoCorner=bCorner;
2187 							aTestCon.bAutoVertex=bVertex;
2188 							aTestCon.bBestConn=sal_False; // bCenter;
2189 							aTestCon.bBestVertex=bCenter;
2190 						}
2191 					}
2192 				}
2193 				// Falls kein Konnektor getroffen wird nochmal
2194 				// HitTest versucht fuer BestConnector (=bCenter)
2195 				if(!bFnd &&
2196                     !bEdge &&
2197                     SdrObjectPrimitiveHit(*pObj, rPt, nBoundHitTol, rPV, &rVisLayer, false))
2198 				{
2199 					// #109007#
2200 					// Suppress default connect at object inside bound
2201 					if(!pThis || !pThis->GetSuppressDefaultConnect())
2202 					{
2203 						bFnd=sal_True;
2204 						aTestCon.pObj=pObj;
2205 						aTestCon.bBestConn=sal_True;
2206 					}
2207 				}
2208 				if (bFnd) {
2209 					Rectangle aMouseRect2(rPt,rPt);
2210 					aMouseRect.Left()  -=nBoundHitTol;
2211 					aMouseRect.Top()   -=nBoundHitTol;
2212 					aMouseRect.Right() +=nBoundHitTol;
2213 					aMouseRect.Bottom()+=nBoundHitTol;
2214 					bTestBoundHit=aObjBound.IsOver(aMouseRect2);
2215 				}
2216 
2217 			}
2218 		}
2219 	}
2220 	rCon=aTestCon;
2221 	return bFnd;
2222 }
2223 
2224 void SdrEdgeObj::NbcSetSnapRect(const Rectangle& rRect)
2225 {
2226 	const Rectangle aOld(GetSnapRect());
2227 
2228     if(aOld != rRect)
2229     {
2230         if(aRect.IsEmpty() && 0 == pEdgeTrack->GetPointCount())
2231         {
2232             // #i110629# When initializing, do not scale on empty Rectangle; this
2233             // will mirror the underlying text object (!)
2234             aRect = rRect;
2235             maSnapRect = rRect;
2236         }
2237         else
2238         {
2239 	        long nMulX = rRect.Right()  - rRect.Left();
2240 	        long nDivX = aOld.Right()   - aOld.Left();
2241 	        long nMulY = rRect.Bottom() - rRect.Top();
2242 	        long nDivY = aOld.Bottom()  - aOld.Top();
2243 	        if ( nDivX == 0 ) { nMulX = 1; nDivX = 1; }
2244 	        if ( nDivY == 0 ) { nMulY = 1; nDivY = 1; }
2245 	        Fraction aX(nMulX, nDivX);
2246 	        Fraction aY(nMulY, nDivY);
2247 	        NbcResize(aOld.TopLeft(), aX, aY);
2248 	        NbcMove(Size(rRect.Left() - aOld.Left(), rRect.Top() - aOld.Top()));
2249         }
2250     }
2251 }
2252 
2253 void SdrEdgeObj::NbcMove(const Size& rSiz)
2254 {
2255 	SdrTextObj::NbcMove(rSiz);
2256 	MoveXPoly(*pEdgeTrack,rSiz);
2257 }
2258 
2259 void SdrEdgeObj::NbcResize(const Point& rRefPnt, const Fraction& aXFact, const Fraction& aYFact)
2260 {
2261 	SdrTextObj::NbcResize(rRefPnt,aXFact,aXFact);
2262 	ResizeXPoly(*pEdgeTrack,rRefPnt,aXFact,aYFact);
2263 
2264 	// #75371# if resize is not from paste, forget user distances
2265 	if(!GetModel()->IsPasteResize())
2266 	{
2267 		// #75735#
2268 		aEdgeInfo.aObj1Line2 = Point();
2269 		aEdgeInfo.aObj1Line3 = Point();
2270 		aEdgeInfo.aObj2Line2 = Point();
2271 		aEdgeInfo.aObj2Line3 = Point();
2272 		aEdgeInfo.aMiddleLine = Point();
2273 	}
2274 }
2275 
2276 // #54102# added rotation support
2277 void SdrEdgeObj::NbcRotate(const Point& rRef, long nWink, double sn, double cs)
2278 {
2279     if(bEdgeTrackUserDefined)
2280     {
2281         // #120437# special handling when track is imported, apply
2282         // transformation directly to imported track.
2283         SdrTextObj::NbcRotate(rRef, nWink, sn, cs);
2284         RotateXPoly(*pEdgeTrack, rRef, sn, cs);
2285     }
2286     else
2287     {
2288         // handle start and end point if not connected
2289 	    FASTBOOL bCon1=aCon1.pObj!=NULL && aCon1.pObj->GetPage()==pPage;
2290 	    FASTBOOL bCon2=aCon2.pObj!=NULL && aCon2.pObj->GetPage()==pPage;
2291 
2292         if(!bCon1 && pEdgeTrack)
2293         {
2294             RotatePoint((*pEdgeTrack)[0],rRef,sn,cs);
2295             ImpDirtyEdgeTrack();
2296         }
2297 
2298         if(!bCon2 && pEdgeTrack)
2299         {
2300     	    sal_uInt16 nPntAnz = pEdgeTrack->GetPointCount();
2301             RotatePoint((*pEdgeTrack)[sal_uInt16(nPntAnz-1)],rRef,sn,cs);
2302             ImpDirtyEdgeTrack();
2303         }
2304     }
2305 }
2306 
2307 // #54102# added mirror support
2308 void SdrEdgeObj::NbcMirror(const Point& rRef1, const Point& rRef2)
2309 {
2310     if(bEdgeTrackUserDefined)
2311     {
2312         // #120437# special handling when track is imported, apply
2313         // transformation directly to imported track.
2314         SdrTextObj::NbcMirror(rRef1, rRef2);
2315         MirrorXPoly(*pEdgeTrack, rRef1, rRef2);
2316     }
2317     else
2318     {
2319         // handle start and end point if not connected
2320 	    FASTBOOL bCon1=aCon1.pObj!=NULL && aCon1.pObj->GetPage()==pPage;
2321 	    FASTBOOL bCon2=aCon2.pObj!=NULL && aCon2.pObj->GetPage()==pPage;
2322 
2323         if(!bCon1 && pEdgeTrack)
2324         {
2325     	    MirrorPoint((*pEdgeTrack)[0],rRef1,rRef2);
2326             ImpDirtyEdgeTrack();
2327         }
2328 
2329         if(!bCon2 && pEdgeTrack)
2330         {
2331     	    sal_uInt16 nPntAnz = pEdgeTrack->GetPointCount();
2332     	    MirrorPoint((*pEdgeTrack)[sal_uInt16(nPntAnz-1)],rRef1,rRef2);
2333             ImpDirtyEdgeTrack();
2334         }
2335     }
2336 }
2337 
2338 // #54102# added shear support
2339 void SdrEdgeObj::NbcShear(const Point& rRef, long nWink, double tn, FASTBOOL bVShear)
2340 {
2341     if(bEdgeTrackUserDefined)
2342     {
2343         // #120437# special handling when track is imported, apply
2344         // transformation directly to imported track.
2345         SdrTextObj::NbcShear(rRef, nWink, tn, bVShear);
2346         ShearXPoly(*pEdgeTrack, rRef, tn, bVShear);
2347     }
2348     else
2349     {
2350         // handle start and end point if not connected
2351 	    FASTBOOL bCon1=aCon1.pObj!=NULL && aCon1.pObj->GetPage()==pPage;
2352 	    FASTBOOL bCon2=aCon2.pObj!=NULL && aCon2.pObj->GetPage()==pPage;
2353 
2354         if(!bCon1 && pEdgeTrack)
2355         {
2356     	    ShearPoint((*pEdgeTrack)[0],rRef,tn,bVShear);
2357             ImpDirtyEdgeTrack();
2358         }
2359 
2360         if(!bCon2 && pEdgeTrack)
2361         {
2362     	    sal_uInt16 nPntAnz = pEdgeTrack->GetPointCount();
2363     	    ShearPoint((*pEdgeTrack)[sal_uInt16(nPntAnz-1)],rRef,tn,bVShear);
2364             ImpDirtyEdgeTrack();
2365         }
2366     }
2367 }
2368 
2369 SdrObject* SdrEdgeObj::DoConvertToPolyObj(sal_Bool bBezier, bool bAddText) const
2370 {
2371 	basegfx::B2DPolyPolygon aPolyPolygon;
2372 	aPolyPolygon.append(pEdgeTrack->getB2DPolygon());
2373 	SdrObject* pRet = ImpConvertMakeObj(aPolyPolygon, sal_False, bBezier);
2374 
2375     if(bAddText)
2376     {
2377     	pRet = ImpConvertAddText(pRet, bBezier);
2378     }
2379 
2380 	return pRet;
2381 }
2382 
2383 sal_uInt32 SdrEdgeObj::GetSnapPointCount() const
2384 {
2385 	return 2L;
2386 }
2387 
2388 Point SdrEdgeObj::GetSnapPoint(sal_uInt32 i) const
2389 {
2390 	((SdrEdgeObj*)this)->ImpUndirtyEdgeTrack();
2391 	sal_uInt16 nAnz=pEdgeTrack->GetPointCount();
2392 	if (i==0) return (*pEdgeTrack)[0];
2393 	else return (*pEdgeTrack)[nAnz-1];
2394 }
2395 
2396 sal_Bool SdrEdgeObj::IsPolyObj() const
2397 {
2398 	return sal_False;
2399 }
2400 
2401 sal_uInt32 SdrEdgeObj::GetPointCount() const
2402 {
2403 	return 0L;
2404 }
2405 
2406 Point SdrEdgeObj::GetPoint(sal_uInt32 i) const
2407 {
2408 	((SdrEdgeObj*)this)->ImpUndirtyEdgeTrack();
2409 	sal_uInt16 nAnz=pEdgeTrack->GetPointCount();
2410 	if (0L == i)
2411 		return (*pEdgeTrack)[0];
2412 	else
2413 		return (*pEdgeTrack)[nAnz-1];
2414 }
2415 
2416 void SdrEdgeObj::NbcSetPoint(const Point& rPnt, sal_uInt32 i)
2417 {
2418 	// ToDo: Umconnekten fehlt noch
2419 	ImpUndirtyEdgeTrack();
2420 	sal_uInt16 nAnz=pEdgeTrack->GetPointCount();
2421 	if (0L == i)
2422 		(*pEdgeTrack)[0]=rPnt;
2423 	if (1L == i)
2424 		(*pEdgeTrack)[nAnz-1]=rPnt;
2425 	SetEdgeTrackDirty();
2426 	SetRectsDirty();
2427 }
2428 
2429 SdrEdgeObjGeoData::SdrEdgeObjGeoData()
2430 {
2431 	pEdgeTrack=new XPolygon;
2432 }
2433 
2434 SdrEdgeObjGeoData::~SdrEdgeObjGeoData()
2435 {
2436 	delete pEdgeTrack;
2437 }
2438 
2439 SdrObjGeoData* SdrEdgeObj::NewGeoData() const
2440 {
2441 	return new SdrEdgeObjGeoData;
2442 }
2443 
2444 void SdrEdgeObj::SaveGeoData(SdrObjGeoData& rGeo) const
2445 {
2446 	SdrTextObj::SaveGeoData(rGeo);
2447 	SdrEdgeObjGeoData& rEGeo=(SdrEdgeObjGeoData&)rGeo;
2448 	rEGeo.aCon1          =aCon1;
2449 	rEGeo.aCon2          =aCon2;
2450 	*rEGeo.pEdgeTrack    =*pEdgeTrack;
2451 	rEGeo.bEdgeTrackDirty=bEdgeTrackDirty;
2452 	rEGeo.bEdgeTrackUserDefined=bEdgeTrackUserDefined;
2453 	rEGeo.aEdgeInfo      =aEdgeInfo;
2454 }
2455 
2456 void SdrEdgeObj::RestGeoData(const SdrObjGeoData& rGeo)
2457 {
2458 	SdrTextObj::RestGeoData(rGeo);
2459 	SdrEdgeObjGeoData& rEGeo=(SdrEdgeObjGeoData&)rGeo;
2460 	if (aCon1.pObj!=rEGeo.aCon1.pObj) {
2461 		if (aCon1.pObj!=NULL) aCon1.pObj->RemoveListener(*this);
2462 		aCon1=rEGeo.aCon1;
2463 		if (aCon1.pObj!=NULL) aCon1.pObj->AddListener(*this);
2464 	}
2465 	if (aCon2.pObj!=rEGeo.aCon2.pObj) {
2466 		if (aCon2.pObj!=NULL) aCon2.pObj->RemoveListener(*this);
2467 		aCon2=rEGeo.aCon2;
2468 		if (aCon2.pObj!=NULL) aCon2.pObj->AddListener(*this);
2469 	}
2470 	*pEdgeTrack    =*rEGeo.pEdgeTrack;
2471 	bEdgeTrackDirty=rEGeo.bEdgeTrackDirty;
2472 	bEdgeTrackUserDefined=rEGeo.bEdgeTrackUserDefined;
2473 	aEdgeInfo      =rEGeo.aEdgeInfo;
2474 }
2475 
2476 Point SdrEdgeObj::GetTailPoint( sal_Bool bTail ) const
2477 {
2478 	if( pEdgeTrack && pEdgeTrack->GetPointCount()!=0)
2479 	{
2480 		const XPolygon& rTrack0 = *pEdgeTrack;
2481 		if(bTail)
2482 		{
2483 			return rTrack0[0];
2484 		}
2485 		else
2486 		{
2487 			const sal_uInt16 nSiz = rTrack0.GetPointCount() - 1;
2488 			return rTrack0[nSiz];
2489 		}
2490 	}
2491 	else
2492 	{
2493 		if(bTail)
2494 			return aOutRect.TopLeft();
2495 		else
2496 			return aOutRect.BottomRight();
2497 	}
2498 
2499 }
2500 
2501 void SdrEdgeObj::SetTailPoint( sal_Bool bTail, const Point& rPt )
2502 {
2503 	ImpSetTailPoint( bTail, rPt );
2504 	SetChanged();
2505 }
2506 
2507 /** this method is used by the api to set a glue point for a connection
2508 	nId == -1 :		The best default point is automaticly choosen
2509 	0 <= nId <= 3 : One of the default points is choosen
2510 	nId >= 4 :		A user defined glue point is choosen
2511 */
2512 void SdrEdgeObj::setGluePointIndex( sal_Bool bTail, sal_Int32 nIndex /* = -1 */ )
2513 {
2514 	Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetCurrentBoundRect();
2515 	// #110094#-14 BroadcastObjectChange();
2516 
2517 	SdrObjConnection& rConn1 = GetConnection( bTail );
2518 
2519 	rConn1.SetAutoVertex( nIndex >= 0 && nIndex <= 3 );
2520 	rConn1.SetBestConnection( nIndex < 0 );
2521 	rConn1.SetBestVertex( nIndex < 0 );
2522 
2523 	if( nIndex > 3 )
2524 	{
2525 //		nIndex -= 4;
2526 		nIndex -= 3;		// SJ: the start api index is 0, whereas the implementation in svx starts from 1
2527 
2528 		// for user defined glue points we have
2529 		// to get the id for this index first
2530 		const SdrGluePointList* pList = rConn1.GetObject() ? rConn1.GetObject()->GetGluePointList() : NULL;
2531 		if( pList == NULL || SDRGLUEPOINT_NOTFOUND == pList->FindGluePoint((sal_uInt16)nIndex) )
2532 			return;
2533 	}
2534 	else if( nIndex < 0 )
2535 	{
2536 		nIndex = 0;
2537 	}
2538 
2539 	rConn1.SetConnectorId( (sal_uInt16)nIndex );
2540 
2541 	SetChanged();
2542 	SetRectsDirty();
2543 	ImpRecalcEdgeTrack();
2544 	// bEdgeTrackDirty=sal_True;
2545 }
2546 
2547 /** this method is used by the api to return a glue point id for a connection.
2548 	See setGluePointId for possible return values */
2549 sal_Int32 SdrEdgeObj::getGluePointIndex( sal_Bool bTail )
2550 {
2551 	SdrObjConnection& rConn1 = GetConnection( bTail );
2552 	sal_Int32 nId = -1;
2553 	if( !rConn1.IsBestConnection() )
2554 	{
2555 		nId = rConn1.GetConnectorId();
2556 		if( !rConn1.IsAutoVertex() )
2557 //			nId += 4;
2558 			nId += 3;		// SJ: the start api index is 0, whereas the implementation in svx starts from 1
2559 	}
2560 	return nId;
2561 }
2562 
2563 // #102344# Implementation was missing; edge track needs to be invalidated additionally.
2564 void SdrEdgeObj::NbcSetAnchorPos(const Point& rPnt)
2565 {
2566 	// call parent functionality
2567 	SdrTextObj::NbcSetAnchorPos(rPnt);
2568 
2569 	// Additionally, invalidate edge track
2570 	ImpDirtyEdgeTrack();
2571 }
2572 
2573 sal_Bool SdrEdgeObj::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& rPolyPolygon) const
2574 {
2575 	// use base method from SdrObject, it's not rotatable and
2576 	// a call to GetSnapRect() is used. That's what we need for Connector.
2577 	return SdrObject::TRGetBaseGeometry(rMatrix, rPolyPolygon);
2578 }
2579 
2580 void SdrEdgeObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& rPolyPolygon)
2581 {
2582 	// evtl. take care for existing connections. For now, just use the
2583 	// implementation from SdrObject.
2584 	SdrObject::TRSetBaseGeometry(rMatrix, rPolyPolygon);
2585 }
2586 
2587 // for geometry access
2588 ::basegfx::B2DPolygon SdrEdgeObj::getEdgeTrack() const
2589 {
2590 	if(bEdgeTrackDirty)
2591 	{
2592 		const_cast< SdrEdgeObj* >(this)->ImpRecalcEdgeTrack();
2593 	}
2594 
2595 	if(pEdgeTrack)
2596 	{
2597 		return pEdgeTrack->getB2DPolygon();
2598 	}
2599 	else
2600 	{
2601 		return ::basegfx::B2DPolygon();
2602 	}
2603 }
2604 
2605 //////////////////////////////////////////////////////////////////////////////
2606 // eof
2607