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