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