| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svx.hxx" |
| |
| #include <svx/svdoedge.hxx> |
| #include <svx/xpool.hxx> |
| #include <svx/xpoly.hxx> |
| #include <svx/svdattrx.hxx> |
| #include <svx/svdpool.hxx> |
| #include <svx/svdmodel.hxx> |
| #include <svx/svdpage.hxx> |
| #include <svx/svdpagv.hxx> |
| #include <svx/svdview.hxx> |
| #include <svx/svddrag.hxx> |
| #include <svx/svddrgv.hxx> |
| #include "svddrgm1.hxx" |
| #include <svx/svdhdl.hxx> |
| #include <svx/svdtrans.hxx> |
| #include <svx/svdetc.hxx> |
| #include "svx/svdglob.hxx" // StringCache |
| #include "svx/svdstr.hrc" // Objektname |
| #include <svl/style.hxx> |
| #include <svl/smplhint.hxx> |
| #include <editeng/eeitem.hxx> |
| #include "svdoimp.hxx" |
| #include <svx/sdr/properties/connectorproperties.hxx> |
| #include <svx/sdr/contact/viewcontactofsdredgeobj.hxx> |
| #include <basegfx/polygon/b2dpolygon.hxx> |
| #include <basegfx/polygon/b2dpolygontools.hxx> |
| #include <basegfx/matrix/b2dhommatrix.hxx> |
| #include <svx/sdrhittesthelper.hxx> |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| SdrObjConnection::~SdrObjConnection() |
| { |
| } |
| |
| void SdrObjConnection::ResetVars() |
| { |
| pObj=NULL; |
| nConId=0; |
| nXDist=0; |
| nYDist=0; |
| bBestConn=sal_True; |
| bBestVertex=sal_True; |
| bXDistOvr=sal_False; |
| bYDistOvr=sal_False; |
| bAutoVertex=sal_False; |
| bAutoCorner=sal_False; |
| } |
| |
| FASTBOOL SdrObjConnection::TakeGluePoint(SdrGluePoint& rGP, FASTBOOL bSetAbsPos) const |
| { |
| FASTBOOL bRet=sal_False; |
| if (pObj!=NULL) { // Ein Obj muss schon angedockt sein! |
| if (bAutoVertex) { |
| rGP=pObj->GetVertexGluePoint(nConId); |
| bRet=sal_True; |
| } else if (bAutoCorner) { |
| rGP=pObj->GetCornerGluePoint(nConId); |
| bRet=sal_True; |
| } else { |
| const SdrGluePointList* pGPL=pObj->GetGluePointList(); |
| if (pGPL!=NULL) { |
| sal_uInt16 nNum=pGPL->FindGluePoint(nConId); |
| if (nNum!=SDRGLUEPOINT_NOTFOUND) { |
| rGP=(*pGPL)[nNum]; |
| bRet=sal_True; |
| } |
| } |
| } |
| } |
| if (bRet && bSetAbsPos) { |
| Point aPt(rGP.GetAbsolutePos(*pObj)); |
| aPt+=aObjOfs; |
| rGP.SetPos(aPt); |
| } |
| return bRet; |
| } |
| |
| Point& SdrEdgeInfoRec::ImpGetLineVersatzPoint(SdrEdgeLineCode eLineCode) |
| { |
| switch (eLineCode) { |
| case OBJ1LINE2 : return aObj1Line2; |
| case OBJ1LINE3 : return aObj1Line3; |
| case OBJ2LINE2 : return aObj2Line2; |
| case OBJ2LINE3 : return aObj2Line3; |
| case MIDDLELINE: return aMiddleLine; |
| } // switch |
| return aMiddleLine; |
| } |
| |
| sal_uInt16 SdrEdgeInfoRec::ImpGetPolyIdx(SdrEdgeLineCode eLineCode, const XPolygon& rXP) const |
| { |
| switch (eLineCode) { |
| case OBJ1LINE2 : return 1; |
| case OBJ1LINE3 : return 2; |
| case OBJ2LINE2 : return rXP.GetPointCount()-3; |
| case OBJ2LINE3 : return rXP.GetPointCount()-4; |
| case MIDDLELINE: return nMiddleLine; |
| } // switch |
| return 0; |
| } |
| |
| FASTBOOL SdrEdgeInfoRec::ImpIsHorzLine(SdrEdgeLineCode eLineCode, const XPolygon& rXP) const |
| { |
| sal_uInt16 nIdx=ImpGetPolyIdx(eLineCode,rXP); |
| FASTBOOL bHorz=nAngle1==0 || nAngle1==18000; |
| if (eLineCode==OBJ2LINE2 || eLineCode==OBJ2LINE3) { |
| nIdx=rXP.GetPointCount()-nIdx; // #36314# |
| bHorz=nAngle2==0 || nAngle2==18000; // #52000# |
| } |
| if ((nIdx & 1)==1) bHorz=!bHorz; |
| return bHorz; |
| } |
| |
| void SdrEdgeInfoRec::ImpSetLineVersatz(SdrEdgeLineCode eLineCode, const XPolygon& rXP, long nVal) |
| { |
| Point& rPt=ImpGetLineVersatzPoint(eLineCode); |
| if (ImpIsHorzLine(eLineCode,rXP)) rPt.Y()=nVal; |
| else rPt.X()=nVal; |
| } |
| |
| long SdrEdgeInfoRec::ImpGetLineVersatz(SdrEdgeLineCode eLineCode, const XPolygon& rXP) const |
| { |
| const Point& rPt=ImpGetLineVersatzPoint(eLineCode); |
| if (ImpIsHorzLine(eLineCode,rXP)) return rPt.Y(); |
| else return rPt.X(); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // BaseProperties section |
| |
| sdr::properties::BaseProperties* SdrEdgeObj::CreateObjectSpecificProperties() |
| { |
| return new sdr::properties::ConnectorProperties(*this); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // DrawContact section |
| |
| sdr::contact::ViewContact* SdrEdgeObj::CreateObjectSpecificViewContact() |
| { |
| return new sdr::contact::ViewContactOfSdrEdgeObj(*this); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| TYPEINIT1(SdrEdgeObj,SdrTextObj); |
| |
| SdrEdgeObj::SdrEdgeObj() |
| : SdrTextObj(), |
| nNotifyingCount(0), |
| bEdgeTrackDirty(sal_False), |
| bEdgeTrackUserDefined(sal_False), |
| // #109007# Default is to allow default connects |
| mbSuppressDefaultConnect(sal_False), |
| // #110649# |
| mbBoundRectCalculationRunning(sal_False), |
| mbSuppressed(false) |
| { |
| bClosedObj=sal_False; |
| bIsEdge=sal_True; |
| pEdgeTrack=new XPolygon; |
| |
| } |
| |
| SdrEdgeObj::~SdrEdgeObj() |
| { |
| DisconnectFromNode(sal_True); |
| DisconnectFromNode(sal_False); |
| delete pEdgeTrack; |
| } |
| |
| void SdrEdgeObj::ImpSetAttrToEdgeInfo() |
| { |
| const SfxItemSet& rSet = GetObjectItemSet(); |
| SdrEdgeKind eKind = ((SdrEdgeKindItem&)(rSet.Get(SDRATTR_EDGEKIND))).GetValue(); |
| sal_Int32 nVal1 = ((SdrEdgeLine1DeltaItem&)rSet.Get(SDRATTR_EDGELINE1DELTA)).GetValue(); |
| sal_Int32 nVal2 = ((SdrEdgeLine2DeltaItem&)rSet.Get(SDRATTR_EDGELINE2DELTA)).GetValue(); |
| sal_Int32 nVal3 = ((SdrEdgeLine3DeltaItem&)rSet.Get(SDRATTR_EDGELINE3DELTA)).GetValue(); |
| |
| if(eKind == SDREDGE_ORTHOLINES || eKind == SDREDGE_BEZIER) |
| { |
| sal_Int32 nVals[3] = { nVal1, nVal2, nVal3 }; |
| sal_uInt16 n = 0; |
| |
| if(aEdgeInfo.nObj1Lines >= 2 && n < 3) |
| { |
| aEdgeInfo.ImpSetLineVersatz(OBJ1LINE2, *pEdgeTrack, nVals[n]); |
| n++; |
| } |
| |
| if(aEdgeInfo.nObj1Lines >= 3 && n < 3) |
| { |
| aEdgeInfo.ImpSetLineVersatz(OBJ1LINE3, *pEdgeTrack, nVals[n]); |
| n++; |
| } |
| |
| if(aEdgeInfo.nMiddleLine != 0xFFFF && n < 3) |
| { |
| aEdgeInfo.ImpSetLineVersatz(MIDDLELINE, *pEdgeTrack, nVals[n]); |
| n++; |
| } |
| |
| if(aEdgeInfo.nObj2Lines >= 3 && n < 3) |
| { |
| aEdgeInfo.ImpSetLineVersatz(OBJ2LINE3, *pEdgeTrack, nVals[n]); |
| n++; |
| } |
| |
| if(aEdgeInfo.nObj2Lines >= 2 && n < 3) |
| { |
| aEdgeInfo.ImpSetLineVersatz(OBJ2LINE2, *pEdgeTrack, nVals[n]); |
| n++; |
| } |
| } |
| else if(eKind == SDREDGE_THREELINES) |
| { |
| sal_Bool bHor1 = aEdgeInfo.nAngle1 == 0 || aEdgeInfo.nAngle1 == 18000; |
| sal_Bool bHor2 = aEdgeInfo.nAngle2 == 0 || aEdgeInfo.nAngle2 == 18000; |
| |
| if(bHor1) |
| { |
| aEdgeInfo.aObj1Line2.X() = nVal1; |
| } |
| else |
| { |
| aEdgeInfo.aObj1Line2.Y() = nVal1; |
| } |
| |
| if(bHor2) |
| { |
| aEdgeInfo.aObj2Line2.X() = nVal2; |
| } |
| else |
| { |
| aEdgeInfo.aObj2Line2.Y() = nVal2; |
| } |
| } |
| |
| // #84649# |
| ImpDirtyEdgeTrack(); |
| } |
| |
| void SdrEdgeObj::ImpSetEdgeInfoToAttr() |
| { |
| const SfxItemSet& rSet = GetObjectItemSet(); |
| SdrEdgeKind eKind = ((SdrEdgeKindItem&)(rSet.Get(SDRATTR_EDGEKIND))).GetValue(); |
| sal_Int32 nValAnz = ((SdrEdgeLineDeltaAnzItem&)rSet.Get(SDRATTR_EDGELINEDELTAANZ)).GetValue(); |
| sal_Int32 nVal1 = ((SdrEdgeLine1DeltaItem&)rSet.Get(SDRATTR_EDGELINE1DELTA)).GetValue(); |
| sal_Int32 nVal2 = ((SdrEdgeLine2DeltaItem&)rSet.Get(SDRATTR_EDGELINE2DELTA)).GetValue(); |
| sal_Int32 nVal3 = ((SdrEdgeLine3DeltaItem&)rSet.Get(SDRATTR_EDGELINE3DELTA)).GetValue(); |
| sal_Int32 nVals[3] = { nVal1, nVal2, nVal3 }; |
| sal_uInt16 n = 0; |
| |
| if(eKind == SDREDGE_ORTHOLINES || eKind == SDREDGE_BEZIER) |
| { |
| if(aEdgeInfo.nObj1Lines >= 2 && n < 3) |
| { |
| nVals[n] = aEdgeInfo.ImpGetLineVersatz(OBJ1LINE2, *pEdgeTrack); |
| n++; |
| } |
| |
| if(aEdgeInfo.nObj1Lines >= 3 && n < 3) |
| { |
| nVals[n] = aEdgeInfo.ImpGetLineVersatz(OBJ1LINE3, *pEdgeTrack); |
| n++; |
| } |
| |
| if(aEdgeInfo.nMiddleLine != 0xFFFF && n < 3) |
| { |
| nVals[n] = aEdgeInfo.ImpGetLineVersatz(MIDDLELINE, *pEdgeTrack); |
| n++; |
| } |
| |
| if(aEdgeInfo.nObj2Lines >= 3 && n < 3) |
| { |
| nVals[n] = aEdgeInfo.ImpGetLineVersatz(OBJ2LINE3, *pEdgeTrack); |
| n++; |
| } |
| |
| if(aEdgeInfo.nObj2Lines >= 2 && n < 3) |
| { |
| nVals[n] = aEdgeInfo.ImpGetLineVersatz(OBJ2LINE2, *pEdgeTrack); |
| n++; |
| } |
| } |
| else if(eKind == SDREDGE_THREELINES) |
| { |
| sal_Bool bHor1 = aEdgeInfo.nAngle1 == 0 || aEdgeInfo.nAngle1 == 18000; |
| sal_Bool bHor2 = aEdgeInfo.nAngle2 == 0 || aEdgeInfo.nAngle2 == 18000; |
| |
| n = 2; |
| nVals[0] = bHor1 ? aEdgeInfo.aObj1Line2.X() : aEdgeInfo.aObj1Line2.Y(); |
| nVals[1] = bHor2 ? aEdgeInfo.aObj2Line2.X() : aEdgeInfo.aObj2Line2.Y(); |
| } |
| |
| if(n != nValAnz || nVals[0] != nVal1 || nVals[1] != nVal2 || nVals[2] != nVal3) |
| { |
| // #75371# Here no more notifying is necessary, just local changes are OK. |
| if(n != nValAnz) |
| { |
| GetProperties().SetObjectItemDirect(SdrEdgeLineDeltaAnzItem(n)); |
| } |
| |
| if(nVals[0] != nVal1) |
| { |
| GetProperties().SetObjectItemDirect(SdrEdgeLine1DeltaItem(nVals[0])); |
| } |
| |
| if(nVals[1] != nVal2) |
| { |
| GetProperties().SetObjectItemDirect(SdrEdgeLine2DeltaItem(nVals[1])); |
| } |
| |
| if(nVals[2] != nVal3) |
| { |
| GetProperties().SetObjectItemDirect(SdrEdgeLine3DeltaItem(nVals[2])); |
| } |
| |
| if(n < 3) |
| { |
| GetProperties().ClearObjectItemDirect(SDRATTR_EDGELINE3DELTA); |
| } |
| |
| if(n < 2) |
| { |
| GetProperties().ClearObjectItemDirect(SDRATTR_EDGELINE2DELTA); |
| } |
| |
| if(n < 1) |
| { |
| GetProperties().ClearObjectItemDirect(SDRATTR_EDGELINE1DELTA); |
| } |
| } |
| } |
| |
| void SdrEdgeObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const |
| { |
| // #54102# allow rotation, mirror and shear |
| rInfo.bRotateFreeAllowed = true; |
| rInfo.bRotate90Allowed = true; |
| rInfo.bMirrorFreeAllowed = true; |
| rInfo.bMirror45Allowed = true; |
| rInfo.bMirror90Allowed = true; |
| rInfo.bTransparenceAllowed = sal_False; |
| rInfo.bGradientAllowed = sal_False; |
| rInfo.bShearAllowed = true; |
| rInfo.bEdgeRadiusAllowed = sal_False; |
| FASTBOOL bCanConv=!HasText() || ImpCanConvTextToCurve(); |
| rInfo.bCanConvToPath=bCanConv; |
| rInfo.bCanConvToPoly=bCanConv; |
| rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary()); |
| } |
| |
| sal_uInt16 SdrEdgeObj::GetObjIdentifier() const |
| { |
| return sal_uInt16(OBJ_EDGE); |
| } |
| |
| const Rectangle& SdrEdgeObj::GetCurrentBoundRect() const |
| { |
| if(bEdgeTrackDirty) |
| { |
| ((SdrEdgeObj*)this)->ImpRecalcEdgeTrack(); |
| } |
| |
| return SdrTextObj::GetCurrentBoundRect(); |
| } |
| |
| const Rectangle& SdrEdgeObj::GetSnapRect() const |
| { |
| if(bEdgeTrackDirty) |
| { |
| ((SdrEdgeObj*)this)->ImpRecalcEdgeTrack(); |
| } |
| |
| return SdrTextObj::GetSnapRect(); |
| } |
| |
| void SdrEdgeObj::RecalcSnapRect() |
| { |
| maSnapRect=pEdgeTrack->GetBoundRect(); |
| } |
| |
| void SdrEdgeObj::TakeUnrotatedSnapRect(Rectangle& rRect) const |
| { |
| rRect=GetSnapRect(); |
| } |
| |
| FASTBOOL SdrEdgeObj::IsNode() const |
| { |
| return sal_True; |
| } |
| |
| SdrGluePoint SdrEdgeObj::GetVertexGluePoint(sal_uInt16 nNum) const |
| { |
| Point aPt; |
| sal_uInt16 nPntAnz=pEdgeTrack->GetPointCount(); |
| if (nPntAnz>0) |
| { |
| Point aOfs = GetSnapRect().Center(); |
| if (nNum==2 && GetConnectedNode(sal_True)==NULL) aPt=(*pEdgeTrack)[0]; |
| else if (nNum==3 && GetConnectedNode(sal_False)==NULL) aPt=(*pEdgeTrack)[nPntAnz-1]; |
| else { |
| if ((nPntAnz & 1) ==1) { |
| aPt=(*pEdgeTrack)[nPntAnz/2]; |
| } else { |
| Point aPt1((*pEdgeTrack)[nPntAnz/2-1]); |
| Point aPt2((*pEdgeTrack)[nPntAnz/2]); |
| aPt1+=aPt2; |
| aPt1.X()/=2; |
| aPt1.Y()/=2; |
| aPt=aPt1; |
| } |
| } |
| aPt-=aOfs; |
| } |
| SdrGluePoint aGP(aPt); |
| aGP.SetPercent(sal_False); |
| return aGP; |
| } |
| |
| SdrGluePoint SdrEdgeObj::GetCornerGluePoint(sal_uInt16 nNum) const |
| { |
| return GetVertexGluePoint(nNum); |
| } |
| |
| const SdrGluePointList* SdrEdgeObj::GetGluePointList() const |
| { |
| return NULL; // Keine benutzerdefinierten Klebepunkte fuer Verbinder #31671# |
| } |
| |
| SdrGluePointList* SdrEdgeObj::ForceGluePointList() |
| { |
| return NULL; // Keine benutzerdefinierten Klebepunkte fuer Verbinder #31671# |
| } |
| |
| FASTBOOL SdrEdgeObj::IsEdge() const |
| { |
| return sal_True; |
| } |
| |
| void SdrEdgeObj::ConnectToNode(FASTBOOL bTail1, SdrObject* pObj) |
| { |
| SdrObjConnection& rCon=GetConnection(bTail1); |
| DisconnectFromNode(bTail1); |
| if (pObj!=NULL) { |
| pObj->AddListener(*this); |
| rCon.pObj=pObj; |
| |
| // #120437# If connection is set, reset bEdgeTrackUserDefined |
| bEdgeTrackUserDefined = false; |
| |
| ImpDirtyEdgeTrack(); |
| } |
| } |
| |
| void SdrEdgeObj::DisconnectFromNode(FASTBOOL bTail1) |
| { |
| SdrObjConnection& rCon=GetConnection(bTail1); |
| if (rCon.pObj!=NULL) { |
| rCon.pObj->RemoveListener(*this); |
| rCon.pObj=NULL; |
| } |
| } |
| |
| SdrObject* SdrEdgeObj::GetConnectedNode(FASTBOOL bTail1) const |
| { |
| SdrObject* pObj=GetConnection(bTail1).pObj; |
| if (pObj!=NULL && (pObj->GetPage()!=pPage || !pObj->IsInserted())) pObj=NULL; |
| return pObj; |
| } |
| |
| FASTBOOL SdrEdgeObj::CheckNodeConnection(FASTBOOL bTail1) const |
| { |
| FASTBOOL bRet=sal_False; |
| const SdrObjConnection& rCon=GetConnection(bTail1); |
| sal_uInt16 nPtAnz=pEdgeTrack->GetPointCount(); |
| if (rCon.pObj!=NULL && rCon.pObj->GetPage()==pPage && nPtAnz!=0) { |
| const SdrGluePointList* pGPL=rCon.pObj->GetGluePointList(); |
| sal_uInt16 nConAnz=pGPL==NULL ? 0 : pGPL->GetCount(); |
| sal_uInt16 nGesAnz=nConAnz+8; |
| Point aTail(bTail1 ? (*pEdgeTrack)[0] : (*pEdgeTrack)[sal_uInt16(nPtAnz-1)]); |
| for (sal_uInt16 i=0; i<nGesAnz && !bRet; i++) { |
| if (i<nConAnz) { // UserDefined |
| bRet=aTail==(*pGPL)[i].GetAbsolutePos(*rCon.pObj); |
| } else if (i<nConAnz+4) { // Vertex |
| SdrGluePoint aPt(rCon.pObj->GetVertexGluePoint(i-nConAnz)); |
| bRet=aTail==aPt.GetAbsolutePos(*rCon.pObj); |
| } else { // Corner |
| SdrGluePoint aPt(rCon.pObj->GetCornerGluePoint(i-nConAnz-4)); |
| bRet=aTail==aPt.GetAbsolutePos(*rCon.pObj); |
| } |
| } |
| } |
| return bRet; |
| } |
| |
| void SdrEdgeObj::ImpSetTailPoint(FASTBOOL bTail1, const Point& rPt) |
| { |
| sal_uInt16 nPtAnz=pEdgeTrack->GetPointCount(); |
| if (nPtAnz==0) { |
| (*pEdgeTrack)[0]=rPt; |
| (*pEdgeTrack)[1]=rPt; |
| } else if (nPtAnz==1) { |
| if (!bTail1) (*pEdgeTrack)[1]=rPt; |
| else { (*pEdgeTrack)[1]=(*pEdgeTrack)[0]; (*pEdgeTrack)[0]=rPt; } |
| } else { |
| if (!bTail1) (*pEdgeTrack)[sal_uInt16(nPtAnz-1)]=rPt; |
| else (*pEdgeTrack)[0]=rPt; |
| } |
| ImpRecalcEdgeTrack(); |
| SetRectsDirty(); |
| } |
| |
| void SdrEdgeObj::ImpDirtyEdgeTrack() |
| { |
| if ( !bEdgeTrackUserDefined || !(GetModel() && GetModel()->isLocked()) ) |
| bEdgeTrackDirty = sal_True; |
| } |
| |
| void SdrEdgeObj::ImpUndirtyEdgeTrack() |
| { |
| if (bEdgeTrackDirty && (GetModel() && GetModel()->isLocked()) ) { |
| ImpRecalcEdgeTrack(); |
| } |
| } |
| |
| void SdrEdgeObj::ImpRecalcEdgeTrack() |
| { |
| // #120437# if bEdgeTrackUserDefined, do not recalculate |
| if(bEdgeTrackUserDefined) |
| { |
| return; |
| } |
| |
| // #120437# also not when model locked during import, but remember |
| if(!GetModel() || GetModel()->isLocked()) |
| { |
| mbSuppressed = true; |
| return; |
| } |
| |
| // #110649# |
| if(IsBoundRectCalculationRunning()) |
| { |
| // this object is involved into another ImpRecalcEdgeTrack() call |
| // from another SdrEdgeObj. Do not calculate again to avoid loop. |
| // Also, do not change bEdgeTrackDirty so that it gets recalculated |
| // later at the first non-looping call. |
| } |
| else |
| { |
| if(mbSuppressed) |
| { |
| // #123048# If layouting was ever suppressed, it needs to be done once |
| // and the attr need to be set at EdgeInfo, else these attr *will be lost* |
| // in the following call to ImpSetEdgeInfoToAttr() sice they were never |
| // set before (!) |
| *pEdgeTrack=ImpCalcEdgeTrack(*pEdgeTrack,aCon1,aCon2,&aEdgeInfo); |
| ImpSetAttrToEdgeInfo(); |
| mbSuppressed = false; |
| } |
| |
| // To not run in a depth loop, use a coloring algorythm on |
| // SdrEdgeObj BoundRect calculations |
| mbBoundRectCalculationRunning = sal_True; |
| |
| Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetCurrentBoundRect(); |
| SetRectsDirty(); |
| // #110094#-14 if (!bEdgeTrackDirty) SendRepaintBroadcast(); |
| *pEdgeTrack=ImpCalcEdgeTrack(*pEdgeTrack,aCon1,aCon2,&aEdgeInfo); |
| ImpSetEdgeInfoToAttr(); // Die Werte aus aEdgeInfo in den Pool kopieren |
| bEdgeTrackDirty=sal_False; |
| |
| // Only redraw here, no object change |
| ActionChanged(); |
| // BroadcastObjectChange(); |
| |
| SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0); |
| |
| // #110649# |
| mbBoundRectCalculationRunning = sal_False; |
| } |
| } |
| |
| sal_uInt16 SdrEdgeObj::ImpCalcEscAngle(SdrObject* pObj, const Point& rPt) const |
| { |
| if (pObj==NULL) return SDRESC_ALL; |
| Rectangle aR(pObj->GetSnapRect()); |
| long dxl=rPt.X()-aR.Left(); |
| long dyo=rPt.Y()-aR.Top(); |
| long dxr=aR.Right()-rPt.X(); |
| long dyu=aR.Bottom()-rPt.Y(); |
| FASTBOOL bxMitt=Abs(dxl-dxr)<2; |
| FASTBOOL byMitt=Abs(dyo-dyu)<2; |
| long dx=Min(dxl,dxr); |
| long dy=Min(dyo,dyu); |
| FASTBOOL bDiag=Abs(dx-dy)<2; |
| if (bxMitt && byMitt) return SDRESC_ALL; // In der Mitte |
| if (bDiag) { // diagonal |
| sal_uInt16 nRet=0; |
| if (byMitt) nRet|=SDRESC_VERT; |
| if (bxMitt) nRet|=SDRESC_HORZ; |
| if (dxl<dxr) { // Links |
| if (dyo<dyu) nRet|=SDRESC_LEFT | SDRESC_TOP; |
| else nRet|=SDRESC_LEFT | SDRESC_BOTTOM; |
| } else { // Rechts |
| if (dyo<dyu) nRet|=SDRESC_RIGHT | SDRESC_TOP; |
| else nRet|=SDRESC_RIGHT | SDRESC_BOTTOM; |
| } |
| return nRet; |
| } |
| if (dx<dy) { // waagerecht |
| if (bxMitt) return SDRESC_HORZ; |
| if (dxl<dxr) return SDRESC_LEFT; |
| else return SDRESC_RIGHT; |
| } else { // senkrecht |
| if (byMitt) return SDRESC_VERT; |
| if (dyo<dyu) return SDRESC_TOP; |
| else return SDRESC_BOTTOM; |
| } |
| } |
| |
| FASTBOOL SdrEdgeObj::ImpStripPolyPoints(XPolygon& /*rXP*/) const |
| { |
| // fehlende Implementation !!! |
| return sal_False; |
| } |
| |
| XPolygon SdrEdgeObj::ImpCalcObjToCenter(const Point& rStPt, long nEscAngle, const Rectangle& rRect, const Point& rMeeting) const |
| { |
| XPolygon aXP; |
| aXP.Insert(XPOLY_APPEND,rStPt,XPOLY_NORMAL); |
| FASTBOOL bRts=nEscAngle==0; |
| FASTBOOL bObn=nEscAngle==9000; |
| FASTBOOL bLks=nEscAngle==18000; |
| FASTBOOL bUnt=nEscAngle==27000; |
| |
| Point aP1(rStPt); // erstmal den Pflichtabstand |
| if (bLks) aP1.X()=rRect.Left(); |
| if (bRts) aP1.X()=rRect.Right(); |
| if (bObn) aP1.Y()=rRect.Top(); |
| if (bUnt) aP1.Y()=rRect.Bottom(); |
| |
| FASTBOOL bFinish=sal_False; |
| if (!bFinish) { |
| Point aP2(aP1); // Und nun den Pflichtabstand ggf. bis auf Meetinghoehe erweitern |
| if (bLks && rMeeting.X()<=aP2.X()) aP2.X()=rMeeting.X(); |
| if (bRts && rMeeting.X()>=aP2.X()) aP2.X()=rMeeting.X(); |
| if (bObn && rMeeting.Y()<=aP2.Y()) aP2.Y()=rMeeting.Y(); |
| if (bUnt && rMeeting.Y()>=aP2.Y()) aP2.Y()=rMeeting.Y(); |
| aXP.Insert(XPOLY_APPEND,aP2,XPOLY_NORMAL); |
| |
| Point aP3(aP2); |
| if ((bLks && rMeeting.X()>aP2.X()) || (bRts && rMeeting.X()<aP2.X())) { // Aussenrum |
| if (rMeeting.Y()<aP2.Y()) { |
| aP3.Y()=rRect.Top(); |
| if (rMeeting.Y()<aP3.Y()) aP3.Y()=rMeeting.Y(); |
| } else { |
| aP3.Y()=rRect.Bottom(); |
| if (rMeeting.Y()>aP3.Y()) aP3.Y()=rMeeting.Y(); |
| } |
| aXP.Insert(XPOLY_APPEND,aP3,XPOLY_NORMAL); |
| if (aP3.Y()!=rMeeting.Y()) { |
| aP3.X()=rMeeting.X(); |
| aXP.Insert(XPOLY_APPEND,aP3,XPOLY_NORMAL); |
| } |
| } |
| if ((bObn && rMeeting.Y()>aP2.Y()) || (bUnt && rMeeting.Y()<aP2.Y())) { // Aussenrum |
| if (rMeeting.X()<aP2.X()) { |
| aP3.X()=rRect.Left(); |
| if (rMeeting.X()<aP3.X()) aP3.X()=rMeeting.X(); |
| } else { |
| aP3.X()=rRect.Right(); |
| if (rMeeting.X()>aP3.X()) aP3.X()=rMeeting.X(); |
| } |
| aXP.Insert(XPOLY_APPEND,aP3,XPOLY_NORMAL); |
| if (aP3.X()!=rMeeting.X()) { |
| aP3.Y()=rMeeting.Y(); |
| aXP.Insert(XPOLY_APPEND,aP3,XPOLY_NORMAL); |
| } |
| } |
| } |
| #ifdef DBG_UTIL |
| if (aXP.GetPointCount()>4) { |
| DBG_ERROR("SdrEdgeObj::ImpCalcObjToCenter(): Polygon hat mehr als 4 Punkte!"); |
| } |
| #endif |
| return aXP; |
| } |
| |
| XPolygon SdrEdgeObj::ImpCalcEdgeTrack(const XPolygon& rTrack0, SdrObjConnection& rCon1, SdrObjConnection& rCon2, SdrEdgeInfoRec* pInfo) const |
| { |
| Point aPt1,aPt2; |
| SdrGluePoint aGP1,aGP2; |
| sal_uInt16 nEsc1=SDRESC_ALL,nEsc2=SDRESC_ALL; |
| Rectangle aBoundRect1; |
| Rectangle aBoundRect2; |
| Rectangle aBewareRect1; |
| Rectangle aBewareRect2; |
| // Erstmal die alten Endpunkte wiederholen |
| if (rTrack0.GetPointCount()!=0) { |
| aPt1=rTrack0[0]; |
| sal_uInt16 nSiz=rTrack0.GetPointCount(); |
| nSiz--; |
| aPt2=rTrack0[nSiz]; |
| } else { |
| if (!aOutRect.IsEmpty()) { |
| aPt1=aOutRect.TopLeft(); |
| aPt2=aOutRect.BottomRight(); |
| } |
| } |
| |
| // #54102# To allow interactive preview, do also if not inserted |
| FASTBOOL bCon1=rCon1.pObj!=NULL && rCon1.pObj->GetPage()==pPage; // && rCon1.pObj->IsInserted(); |
| FASTBOOL bCon2=rCon2.pObj!=NULL && rCon2.pObj->GetPage()==pPage; // && rCon2.pObj->IsInserted(); |
| const SfxItemSet& rSet = GetObjectItemSet(); |
| |
| if (bCon1) { |
| if (rCon1.pObj==(SdrObject*)this) |
| { |
| // sicherheitshalber Abfragen #44515# |
| aBoundRect1=aOutRect; |
| } |
| else |
| { |
| aBoundRect1 = rCon1.pObj->GetCurrentBoundRect(); |
| } |
| aBoundRect1.Move(rCon1.aObjOfs.X(),rCon1.aObjOfs.Y()); |
| aBewareRect1=aBoundRect1; |
| |
| sal_Int32 nH = ((SdrEdgeNode1HorzDistItem&)rSet.Get(SDRATTR_EDGENODE1HORZDIST)).GetValue(); |
| sal_Int32 nV = ((SdrEdgeNode1VertDistItem&)rSet.Get(SDRATTR_EDGENODE1VERTDIST)).GetValue(); |
| |
| aBewareRect1.Left()-=nH; |
| aBewareRect1.Right()+=nH; |
| aBewareRect1.Top()-=nV; |
| aBewareRect1.Bottom()+=nV; |
| } else { |
| aBoundRect1=Rectangle(aPt1,aPt1); |
| aBoundRect1.Move(rCon1.aObjOfs.X(),rCon1.aObjOfs.Y()); |
| aBewareRect1=aBoundRect1; |
| } |
| if (bCon2) { |
| if (rCon2.pObj==(SdrObject*)this) { // sicherheitshalber Abfragen #44515# |
| aBoundRect2=aOutRect; |
| } |
| else |
| { |
| aBoundRect2 = rCon2.pObj->GetCurrentBoundRect(); |
| } |
| aBoundRect2.Move(rCon2.aObjOfs.X(),rCon2.aObjOfs.Y()); |
| aBewareRect2=aBoundRect2; |
| |
| sal_Int32 nH = ((SdrEdgeNode2HorzDistItem&)rSet.Get(SDRATTR_EDGENODE2HORZDIST)).GetValue(); |
| sal_Int32 nV = ((SdrEdgeNode2VertDistItem&)rSet.Get(SDRATTR_EDGENODE2VERTDIST)).GetValue(); |
| |
| aBewareRect2.Left()-=nH; |
| aBewareRect2.Right()+=nH; |
| aBewareRect2.Top()-=nV; |
| aBewareRect2.Bottom()+=nV; |
| } else { |
| aBoundRect2=Rectangle(aPt2,aPt2); |
| aBoundRect2.Move(rCon2.aObjOfs.X(),rCon2.aObjOfs.Y()); |
| aBewareRect2=aBoundRect2; |
| } |
| XPolygon aBestXP; |
| sal_uIntPtr nBestQual=0xFFFFFFFF; |
| SdrEdgeInfoRec aBestInfo; |
| FASTBOOL bAuto1=bCon1 && rCon1.bBestVertex; |
| FASTBOOL bAuto2=bCon2 && rCon2.bBestVertex; |
| if (bAuto1) rCon1.bAutoVertex=sal_True; |
| if (bAuto2) rCon2.bAutoVertex=sal_True; |
| sal_uInt16 nBestAuto1=0; |
| sal_uInt16 nBestAuto2=0; |
| sal_uInt16 nAnz1=bAuto1 ? 4 : 1; |
| sal_uInt16 nAnz2=bAuto2 ? 4 : 1; |
| for (sal_uInt16 nNum1=0; nNum1<nAnz1; nNum1++) { |
| if (bAuto1) rCon1.nConId=nNum1; |
| if (bCon1 && rCon1.TakeGluePoint(aGP1,sal_True)) { |
| aPt1=aGP1.GetPos(); |
| nEsc1=aGP1.GetEscDir(); |
| if (nEsc1==SDRESC_SMART) nEsc1=ImpCalcEscAngle(rCon1.pObj,aPt1-rCon1.aObjOfs); |
| } |
| for (sal_uInt16 nNum2=0; nNum2<nAnz2; nNum2++) { |
| if (bAuto2) rCon2.nConId=nNum2; |
| if (bCon2 && rCon2.TakeGluePoint(aGP2,sal_True)) { |
| aPt2=aGP2.GetPos(); |
| nEsc2=aGP2.GetEscDir(); |
| if (nEsc2==SDRESC_SMART) nEsc2=ImpCalcEscAngle(rCon2.pObj,aPt2-rCon2.aObjOfs); |
| } |
| for (long nA1=0; nA1<36000; nA1+=9000) { |
| sal_uInt16 nE1=nA1==0 ? SDRESC_RIGHT : nA1==9000 ? SDRESC_TOP : nA1==18000 ? SDRESC_LEFT : nA1==27000 ? SDRESC_BOTTOM : 0; |
| for (long nA2=0; nA2<36000; nA2+=9000) { |
| sal_uInt16 nE2=nA2==0 ? SDRESC_RIGHT : nA2==9000 ? SDRESC_TOP : nA2==18000 ? SDRESC_LEFT : nA2==27000 ? SDRESC_BOTTOM : 0; |
| if ((nEsc1&nE1)!=0 && (nEsc2&nE2)!=0) { |
| sal_uIntPtr nQual=0; |
| SdrEdgeInfoRec aInfo; |
| if (pInfo!=NULL) aInfo=*pInfo; |
| XPolygon aXP(ImpCalcEdgeTrack(aPt1,nA1,aBoundRect1,aBewareRect1,aPt2,nA2,aBoundRect2,aBewareRect2,&nQual,&aInfo)); |
| if (nQual<nBestQual) { |
| aBestXP=aXP; |
| nBestQual=nQual; |
| aBestInfo=aInfo; |
| nBestAuto1=nNum1; |
| nBestAuto2=nNum2; |
| } |
| } |
| } |
| } |
| } |
| } |
| if (bAuto1) rCon1.nConId=nBestAuto1; |
| if (bAuto2) rCon2.nConId=nBestAuto2; |
| if (pInfo!=NULL) *pInfo=aBestInfo; |
| return aBestXP; |
| } |
| |
| XPolygon SdrEdgeObj::ImpCalcEdgeTrack(const Point& rPt1, long nAngle1, const Rectangle& rBoundRect1, const Rectangle& rBewareRect1, |
| const Point& rPt2, long nAngle2, const Rectangle& rBoundRect2, const Rectangle& rBewareRect2, |
| sal_uIntPtr* pnQuality, SdrEdgeInfoRec* pInfo) const |
| { |
| SdrEdgeKind eKind=((SdrEdgeKindItem&)(GetObjectItem(SDRATTR_EDGEKIND))).GetValue(); |
| FASTBOOL bRts1=nAngle1==0; |
| FASTBOOL bObn1=nAngle1==9000; |
| FASTBOOL bLks1=nAngle1==18000; |
| FASTBOOL bUnt1=nAngle1==27000; |
| FASTBOOL bHor1=bLks1 || bRts1; |
| FASTBOOL bVer1=bObn1 || bUnt1; |
| FASTBOOL bRts2=nAngle2==0; |
| FASTBOOL bObn2=nAngle2==9000; |
| FASTBOOL bLks2=nAngle2==18000; |
| FASTBOOL bUnt2=nAngle2==27000; |
| FASTBOOL bHor2=bLks2 || bRts2; |
| FASTBOOL bVer2=bObn2 || bUnt2; |
| FASTBOOL bInfo=pInfo!=NULL; |
| if (bInfo) { |
| pInfo->cOrthoForm=0; |
| pInfo->nAngle1=nAngle1; |
| pInfo->nAngle2=nAngle2; |
| pInfo->nObj1Lines=1; |
| pInfo->nObj2Lines=1; |
| pInfo->nMiddleLine=0xFFFF; |
| } |
| Point aPt1(rPt1); |
| Point aPt2(rPt2); |
| Rectangle aBoundRect1 (rBoundRect1 ); |
| Rectangle aBoundRect2 (rBoundRect2 ); |
| Rectangle aBewareRect1(rBewareRect1); |
| Rectangle aBewareRect2(rBewareRect2); |
| Point aMeeting((aPt1.X()+aPt2.X()+1)/2,(aPt1.Y()+aPt2.Y()+1)/2); |
| FASTBOOL bMeetingXMid=sal_True; |
| FASTBOOL bMeetingYMid=sal_True; |
| if (eKind==SDREDGE_ONELINE) { |
| XPolygon aXP(2); |
| aXP[0]=rPt1; |
| aXP[1]=rPt2; |
| if (pnQuality!=NULL) { |
| *pnQuality=Abs(rPt1.X()-rPt2.X())+Abs(rPt1.Y()-rPt2.Y()); |
| } |
| return aXP; |
| } else if (eKind==SDREDGE_THREELINES) { |
| XPolygon aXP(4); |
| aXP[0]=rPt1; |
| aXP[1]=rPt1; |
| aXP[2]=rPt2; |
| aXP[3]=rPt2; |
| if (bRts1) aXP[1].X()=aBewareRect1.Right(); //+=500; |
| if (bObn1) aXP[1].Y()=aBewareRect1.Top(); //-=500; |
| if (bLks1) aXP[1].X()=aBewareRect1.Left(); //-=500; |
| if (bUnt1) aXP[1].Y()=aBewareRect1.Bottom(); //+=500; |
| if (bRts2) aXP[2].X()=aBewareRect2.Right(); //+=500; |
| if (bObn2) aXP[2].Y()=aBewareRect2.Top(); //-=500; |
| if (bLks2) aXP[2].X()=aBewareRect2.Left(); //-=500; |
| if (bUnt2) aXP[2].Y()=aBewareRect2.Bottom(); //+=500; |
| if (pnQuality!=NULL) { |
| long nQ=Abs(aXP[1].X()-aXP[0].X())+Abs(aXP[1].Y()-aXP[0].Y()); |
| nQ+=Abs(aXP[2].X()-aXP[1].X())+Abs(aXP[2].Y()-aXP[1].Y()); |
| nQ+=Abs(aXP[3].X()-aXP[2].X())+Abs(aXP[3].Y()-aXP[2].Y()); |
| *pnQuality=nQ; |
| } |
| if (bInfo) { |
| pInfo->nObj1Lines=2; |
| pInfo->nObj2Lines=2; |
| if (bHor1) { |
| aXP[1].X()+=pInfo->aObj1Line2.X(); |
| } else { |
| aXP[1].Y()+=pInfo->aObj1Line2.Y(); |
| } |
| if (bHor2) { |
| aXP[2].X()+=pInfo->aObj2Line2.X(); |
| } else { |
| aXP[2].Y()+=pInfo->aObj2Line2.Y(); |
| } |
| } |
| return aXP; |
| } |
| sal_uInt16 nIntersections=0; |
| FASTBOOL bForceMeeting=sal_False; // Muss die Linie durch den MeetingPoint laufen? |
| { |
| Point aC1(aBewareRect1.Center()); |
| Point aC2(aBewareRect2.Center()); |
| if (aBewareRect1.Left()<=aBewareRect2.Right() && aBewareRect1.Right()>=aBewareRect2.Left()) { |
| // Ueberschneidung auf der X-Achse |
| long n1=Max(aBewareRect1.Left(),aBewareRect2.Left()); |
| long n2=Min(aBewareRect1.Right(),aBewareRect2.Right()); |
| aMeeting.X()=(n1+n2+1)/2; |
| } else { |
| // Ansonsten den Mittelpunkt des Freiraums |
| if (aC1.X()<aC2.X()) { |
| aMeeting.X()=(aBewareRect1.Right()+aBewareRect2.Left()+1)/2; |
| } else { |
| aMeeting.X()=(aBewareRect1.Left()+aBewareRect2.Right()+1)/2; |
| } |
| } |
| if (aBewareRect1.Top()<=aBewareRect2.Bottom() && aBewareRect1.Bottom()>=aBewareRect2.Top()) { |
| // Ueberschneidung auf der Y-Achse |
| long n1=Max(aBewareRect1.Top(),aBewareRect2.Top()); |
| long n2=Min(aBewareRect1.Bottom(),aBewareRect2.Bottom()); |
| aMeeting.Y()=(n1+n2+1)/2; |
| } else { |
| // Ansonsten den Mittelpunkt des Freiraums |
| if (aC1.Y()<aC2.Y()) { |
| aMeeting.Y()=(aBewareRect1.Bottom()+aBewareRect2.Top()+1)/2; |
| } else { |
| aMeeting.Y()=(aBewareRect1.Top()+aBewareRect2.Bottom()+1)/2; |
| } |
| } |
| // Im Prinzip gibt es 3 zu unterscheidene Faelle: |
| // 1. Beide in die selbe Richtung |
| // 2. Beide in genau entgegengesetzte Richtungen |
| // 3. Einer waagerecht und der andere senkrecht |
| long nXMin=Min(aBewareRect1.Left(),aBewareRect2.Left()); |
| long nXMax=Max(aBewareRect1.Right(),aBewareRect2.Right()); |
| long nYMin=Min(aBewareRect1.Top(),aBewareRect2.Top()); |
| long nYMax=Max(aBewareRect1.Bottom(),aBewareRect2.Bottom()); |
| FASTBOOL bBewareOverlap=aBewareRect1.Right()>aBewareRect2.Left() && aBewareRect1.Left()<aBewareRect2.Right() && |
| aBewareRect1.Bottom()>aBewareRect2.Top() && aBewareRect1.Top()<aBewareRect2.Bottom(); |
| unsigned nMainCase=3; |
| if (nAngle1==nAngle2) nMainCase=1; |
| else if ((bHor1 && bHor2) || (bVer1 && bVer2)) nMainCase=2; |
| if (nMainCase==1) { // Fall 1: Beide in eine Richtung moeglich. |
| if (bVer1) aMeeting.X()=(aPt1.X()+aPt2.X()+1)/2; // ist hier besser, als der |
| if (bHor1) aMeeting.Y()=(aPt1.Y()+aPt2.Y()+1)/2; // Mittelpunkt des Freiraums |
| // bX1Ok bedeutet, dass die Vertikale, die aus Obj1 austritt, keinen Konflikt mit Obj2 bildet, ... |
| FASTBOOL bX1Ok=aPt1.X()<=aBewareRect2.Left() || aPt1.X()>=aBewareRect2.Right(); |
| FASTBOOL bX2Ok=aPt2.X()<=aBewareRect1.Left() || aPt2.X()>=aBewareRect1.Right(); |
| FASTBOOL bY1Ok=aPt1.Y()<=aBewareRect2.Top() || aPt1.Y()>=aBewareRect2.Bottom(); |
| FASTBOOL bY2Ok=aPt2.Y()<=aBewareRect1.Top() || aPt2.Y()>=aBewareRect1.Bottom(); |
| if (bLks1 && (bY1Ok || aBewareRect1.Left()<aBewareRect2.Right()) && (bY2Ok || aBewareRect2.Left()<aBewareRect1.Right())) { |
| aMeeting.X()=nXMin; |
| bMeetingXMid=sal_False; |
| } |
| if (bRts1 && (bY1Ok || aBewareRect1.Right()>aBewareRect2.Left()) && (bY2Ok || aBewareRect2.Right()>aBewareRect1.Left())) { |
| aMeeting.X()=nXMax; |
| bMeetingXMid=sal_False; |
| } |
| if (bObn1 && (bX1Ok || aBewareRect1.Top()<aBewareRect2.Bottom()) && (bX2Ok || aBewareRect2.Top()<aBewareRect1.Bottom())) { |
| aMeeting.Y()=nYMin; |
| bMeetingYMid=sal_False; |
| } |
| if (bUnt1 && (bX1Ok || aBewareRect1.Bottom()>aBewareRect2.Top()) && (bX2Ok || aBewareRect2.Bottom()>aBewareRect1.Top())) { |
| aMeeting.Y()=nYMax; |
| bMeetingYMid=sal_False; |
| } |
| } else if (nMainCase==2) { |
| // Fall 2: |
| bForceMeeting=sal_True; |
| if (bHor1) { // beide waagerecht |
| /* 9 Moeglichkeiten: ù ù ù */ |
| /* 2.1 Gegenueber, Ueberschneidung à ´ ù */ |
| /* nur auf der Y-Achse ù ù ù */ |
| /* 2.2, 2.3 Gegenueber, vertikal versetzt. Ã ù ù ù ù ù */ |
| /* Ueberschneidung weder auf der ù ´ ù ù ´ ù */ |
| /* X- noch auf der Y-Achse ù ù ù Ã ù ù */ |
| /* 2.4, 2.5 Untereinander, ù Ã ù ù ù ù */ |
| /* Ueberschneidung ù ´ ù ù ´ ù */ |
| /* nur auf X-Achse ù ù ù ù Ã ù */ |
| /* 2.6, 2.7 Gegeneinander, vertikal versetzt. ù ù Ã ù ù ù */ |
| /* Ueberschneidung weder auf der ù ´ ù ù ´ ù */ |
| /* X- noch auf der Y-Achse. ù ù ù ù ù Ã */ |
| /* 2.8 Gegeneinander. ù ù ù */ |
| /* Ueberschneidung nur ù ´ Ã */ |
| /* auf der Y-Achse. ù ù ù */ |
| /* 2.9 Die BewareRects der Objekte ueberschneiden */ |
| /* sich auf X- und Y-Achse. */ |
| /* Die Faelle gelten entsprechend umgesetzt auch fuer */ |
| /* senkrechte Linienaustritte. */ |
| /* Die Faelle 2.1-2.7 werden mit dem Default-Meeting ausreichend*/ |
| /* gut behandelt. Spezielle MeetingPoints werden hier also nur */ |
| /* fuer 2.8 und 2.9 bestimmt. */ |
| |
| // Normalisierung. aR1 soll der nach rechts und |
| // aR2 der nach links austretende sein. |
| Rectangle aBewR1(bRts1 ? aBewareRect1 : aBewareRect2); |
| Rectangle aBewR2(bRts1 ? aBewareRect2 : aBewareRect1); |
| Rectangle aBndR1(bRts1 ? aBoundRect1 : aBoundRect2); |
| Rectangle aBndR2(bRts1 ? aBoundRect2 : aBoundRect1); |
| if (aBewR1.Bottom()>aBewR2.Top() && aBewR1.Top()<aBewR2.Bottom()) { |
| // Ueberschneidung auf der Y-Achse. Faelle 2.1, 2.8, 2.9 |
| if (aBewR1.Right()>aBewR2.Left()) { |
| // Faelle 2.8, 2.9 |
| // Fall 2.8 ist immer Aussenrumlauf (bDirect=sal_False). |
| // Fall 2.9 kann auch Direktverbindung sein (bei geringer |
| // Ueberschneidung der BewareRects ohne Ueberschneidung der |
| // Boundrects wenn die Linienaustritte sonst das BewareRect |
| // des jeweils anderen Objekts verletzen wuerden. |
| FASTBOOL bCase29Direct=sal_False; |
| FASTBOOL bCase29=aBewR1.Right()>aBewR2.Left(); |
| if (aBndR1.Right()<=aBndR2.Left()) { // Fall 2.9 und keine Boundrectueberschneidung |
| if ((aPt1.Y()>aBewareRect2.Top() && aPt1.Y()<aBewareRect2.Bottom()) || |
| (aPt2.Y()>aBewareRect1.Top() && aPt2.Y()<aBewareRect1.Bottom())) { |
| bCase29Direct=sal_True; |
| } |
| } |
| if (!bCase29Direct) { |
| FASTBOOL bObenLang=Abs(nYMin-aMeeting.Y())<=Abs(nYMax-aMeeting.Y()); |
| if (bObenLang) { |
| aMeeting.Y()=nYMin; |
| } else { |
| aMeeting.Y()=nYMax; |
| } |
| bMeetingYMid=sal_False; |
| if (bCase29) { |
| // und nun noch dafuer sorgen, dass das |
| // umzingelte Obj nicht durchquert wird |
| if ((aBewR1.Center().Y()<aBewR2.Center().Y()) != bObenLang) { |
| aMeeting.X()=aBewR2.Right(); |
| } else { |
| aMeeting.X()=aBewR1.Left(); |
| } |
| bMeetingXMid=sal_False; |
| } |
| } else { |
| // Direkte Verbindung (3-Linien Z-Verbindung), da |
| // Verletzung der BewareRects unvermeidlich ist. |
| // Via Dreisatz werden die BewareRects nun verkleinert. |
| long nWant1=aBewR1.Right()-aBndR1.Right(); // Abstand bei Obj1 |
| long nWant2=aBndR2.Left()-aBewR2.Left(); // Abstand bei Obj2 |
| long nSpace=aBndR2.Left()-aBndR1.Right(); // verfuegbarer Platz |
| long nGet1=BigMulDiv(nWant1,nSpace,nWant1+nWant2); |
| long nGet2=nSpace-nGet1; |
| if (bRts1) { // Normalisierung zurueckwandeln |
| aBewareRect1.Right()+=nGet1-nWant1; |
| aBewareRect2.Left()-=nGet2-nWant2; |
| } else { |
| aBewareRect2.Right()+=nGet1-nWant1; |
| aBewareRect1.Left()-=nGet2-nWant2; |
| } |
| nIntersections++; // Qualitaet herabsetzen |
| } |
| } |
| } |
| } else if (bVer1) { // beide senkrecht |
| Rectangle aBewR1(bUnt1 ? aBewareRect1 : aBewareRect2); |
| Rectangle aBewR2(bUnt1 ? aBewareRect2 : aBewareRect1); |
| Rectangle aBndR1(bUnt1 ? aBoundRect1 : aBoundRect2); |
| Rectangle aBndR2(bUnt1 ? aBoundRect2 : aBoundRect1); |
| if (aBewR1.Right()>aBewR2.Left() && aBewR1.Left()<aBewR2.Right()) { |
| // Ueberschneidung auf der Y-Achse. Faelle 2.1, 2.8, 2.9 |
| if (aBewR1.Bottom()>aBewR2.Top()) { |
| // Faelle 2.8, 2.9 |
| // Fall 2.8 ist immer Aussenrumlauf (bDirect=sal_False). |
| // Fall 2.9 kann auch Direktverbindung sein (bei geringer |
| // Ueberschneidung der BewareRects ohne Ueberschneidung der |
| // Boundrects wenn die Linienaustritte sonst das BewareRect |
| // des jeweils anderen Objekts verletzen wuerden. |
| FASTBOOL bCase29Direct=sal_False; |
| FASTBOOL bCase29=aBewR1.Bottom()>aBewR2.Top(); |
| if (aBndR1.Bottom()<=aBndR2.Top()) { // Fall 2.9 und keine Boundrectueberschneidung |
| if ((aPt1.X()>aBewareRect2.Left() && aPt1.X()<aBewareRect2.Right()) || |
| (aPt2.X()>aBewareRect1.Left() && aPt2.X()<aBewareRect1.Right())) { |
| bCase29Direct=sal_True; |
| } |
| } |
| if (!bCase29Direct) { |
| FASTBOOL bLinksLang=Abs(nXMin-aMeeting.X())<=Abs(nXMax-aMeeting.X()); |
| if (bLinksLang) { |
| aMeeting.X()=nXMin; |
| } else { |
| aMeeting.X()=nXMax; |
| } |
| bMeetingXMid=sal_False; |
| if (bCase29) { |
| // und nun noch dafuer sorgen, dass das |
| // umzingelte Obj nicht durchquert wird |
| if ((aBewR1.Center().X()<aBewR2.Center().X()) != bLinksLang) { |
| aMeeting.Y()=aBewR2.Bottom(); |
| } else { |
| aMeeting.Y()=aBewR1.Top(); |
| } |
| bMeetingYMid=sal_False; |
| } |
| } else { |
| // Direkte Verbindung (3-Linien Z-Verbindung), da |
| // Verletzung der BewareRects unvermeidlich ist. |
| // Via Dreisatz werden die BewareRects nun verkleinert. |
| long nWant1=aBewR1.Bottom()-aBndR1.Bottom(); // Abstand bei Obj1 |
| long nWant2=aBndR2.Top()-aBewR2.Top(); // Abstand bei Obj2 |
| long nSpace=aBndR2.Top()-aBndR1.Bottom(); // verfuegbarer Platz |
| long nGet1=BigMulDiv(nWant1,nSpace,nWant1+nWant2); |
| long nGet2=nSpace-nGet1; |
| if (bUnt1) { // Normalisierung zurueckwandeln |
| aBewareRect1.Bottom()+=nGet1-nWant1; |
| aBewareRect2.Top()-=nGet2-nWant2; |
| } else { |
| aBewareRect2.Bottom()+=nGet1-nWant1; |
| aBewareRect1.Top()-=nGet2-nWant2; |
| } |
| nIntersections++; // Qualitaet herabsetzen |
| } |
| } |
| } |
| } |
| } else if (nMainCase==3) { // Fall 3: Einer waagerecht und der andere senkrecht. Sehr viele Fallunterscheidungen |
| /* Kleine Legende: ù ú ù ú ù -> Ohne Ueberschneidung, maximal Beruehrung. */ |
| /* ú ú ú ú ú -> Ueberschneidung */ |
| /* ù ú Ã ú ù -> Selbe Hoehe */ |
| /* ú ú ú ú ú -> Ueberschneidung */ |
| /* ù ú ù ú ù -> Ohne Ueberschneidung, maximal Beruehrung. */ |
| /* Linienaustritte links ´, rechts Ã, oben Á und unten Â. */ |
| /* Insgesamt sind 96 Konstellationen moeglich, wobei einige nicht einmal */ |
| /* eindeutig einem Fall und damit einer Behandlungsmethode zugeordnet werden */ |
| /* koennen. */ |
| /* 3.1: Hierzu moegen alle Konstellationen zaehlen, die durch den */ |
| /* Default-MeetingPoint zufriedenstellend abgedeckt sind (20+12). */ |
| /* Â Â Â ú Á Á ú Â Â Â Diese 12 ù ú ù Â ù ù ú ù ú ù ù Â ù ú ù ù ú ù ú ù */ |
| /* ú ú ú ú Á Á ú ú ú ú Konstel. ú ú ú ú ú ú ú ú ú Â ú ú ú ú ú Â ú ú ú ú */ |
| /* ù ú Ã ú ù ù ú ´ ú ù jedoch ù ú Ã ú Á ù ú Ã ú Â Á ú ´ ú ù Â ú ´ ú ù */ |
| /* ú ú ú ú Â Â ú ú ú ú nur zum ú ú ú ú Á ú ú ú ú ú Á ú ú ú ú ú ú ú ú ú */ |
| /* Á Á Á ú Â Â ú Á Á Á Teil: ù ú ù Á ù ù ú ù ú ù ù Á ù ú ù ù ú ù ú ù */ |
| /* Letztere 16 Faelle scheiden aus, sobald sich die Objekte offen */ |
| /* gegenueberstehen (siehe Fall 3.2). */ |
| /* 3.2: Die Objekte stehen sich offen gegenueber und somit ist eine */ |
| /* Verbindung mit lediglich 2 Linien moeglich (4+20). */ |
| /* Dieser Fall hat 1. Prioritaet. */ |
| /* ù ú ù ú Â Â ú ù ú ù Diese 20 ù ú ù Â ù ù Â ù ú ù ù ú ù ú ù ù ú ù ú ù */ |
| /* ú ú ú ú ú ú ú ú ú ú Konstel. ú ú ú Â Â Â Â ú ú ú ú ú ú ú ú ú ú ú ú ú */ |
| /* ù ú Ã ú ù ù ú ´ ú ù jedoch ù ú Ã Á Á Á Á ´ ú ù ù ú Ã Â Â Â Â ´ ú ù */ |
| /* ú ú ú ú ú ú ú ú ú ú nur zum ú ú ú Á Á Á Á ú ú ú ú ú ú ú ú ú ú ú ú ú */ |
| /* ù ú ù ú Á Á ú ù ú ù Teil: ù ú ù Á ù ù Á ù ú ù ù ú ù ú ù ù ú ù ú ù */ |
| /* 3.3: Die Linienaustritte zeigen vom anderen Objekt weg bzw. hinter */ |
| /* dessen Ruecken vorbei (52+4). */ |
| /* Á Á Á Á ù ù Á Á Á Á ù ú ú ú ù ù ú ù ú ù Diese 4 ù ú ù ú ù ù ú ù ú ù */ |
| /* Á Á Á Á ú ú Á Á Á Á Â Â Â ú ú ú ú Â Â Â Konstel. ú ú ú Â ú ú Â ú ú ú */ |
| /* Á Á Ã ú ù ù ú ´ Á Á Â Â Ã ú ù ù ú ´ Â Â jedoch ù ú Ã ú ù ù ú ´ ú ù */ |
| /* Á Á Á ú ú ú ú Á Á Á Â Â Â Â ú ú Â Â Â Â nur zum ú ú ú Á ú ú Á ú ú ú */ |
| /* ù ú ù ú ù ù ú ù ú ù Â Â Â Â ù ù Â Â Â Â Teil: ù ú ù ú ù ù ú ù ú ù */ |
| |
| // Fall 3.2 |
| Rectangle aTmpR1(aBewareRect1); |
| Rectangle aTmpR2(aBewareRect2); |
| if (bBewareOverlap) { |
| // Ueberschneidung der BewareRects: BoundRects fuer Check auf Fall 3.2 verwenden. |
| aTmpR1=aBoundRect1; |
| aTmpR2=aBoundRect2; |
| } |
| if ((((bRts1 && aTmpR1.Right ()<=aPt2.X()) || (bLks1 && aTmpR1.Left()>=aPt2.X())) && |
| ((bUnt2 && aTmpR2.Bottom()<=aPt1.Y()) || (bObn2 && aTmpR2.Top ()>=aPt1.Y()))) || |
| (((bRts2 && aTmpR2.Right ()<=aPt1.X()) || (bLks2 && aTmpR2.Left()>=aPt1.X())) && |
| ((bUnt1 && aTmpR1.Bottom()<=aPt2.Y()) || (bObn1 && aTmpR1.Top ()>=aPt2.Y())))) { |
| // Fall 3.2 trifft zu: Verbindung mit lediglich 2 Linien |
| bForceMeeting=sal_True; |
| bMeetingXMid=sal_False; |
| bMeetingYMid=sal_False; |
| if (bHor1) { |
| aMeeting.X()=aPt2.X(); |
| aMeeting.Y()=aPt1.Y(); |
| } else { |
| aMeeting.X()=aPt1.X(); |
| aMeeting.Y()=aPt2.Y(); |
| } |
| // Falls Ueberschneidung der BewareRects: |
| aBewareRect1=aTmpR1; |
| aBewareRect2=aTmpR2; |
| } else if ((((bRts1 && aBewareRect1.Right ()>aBewareRect2.Left ()) || |
| (bLks1 && aBewareRect1.Left ()<aBewareRect2.Right ())) && |
| ((bUnt2 && aBewareRect2.Bottom()>aBewareRect1.Top ()) || |
| (bObn2 && aBewareRect2.Top ()<aBewareRect1.Bottom()))) || |
| (((bRts2 && aBewareRect2.Right ()>aBewareRect1.Left ()) || |
| (bLks2 && aBewareRect2.Left ()<aBewareRect1.Right ())) && |
| ((bUnt1 && aBewareRect1.Bottom()>aBewareRect2.Top ()) || |
| (bObn1 && aBewareRect1.Top ()<aBewareRect2.Bottom())))) { |
| // Fall 3.3 |
| bForceMeeting=sal_True; |
| if (bRts1 || bRts2) { aMeeting.X()=nXMax; bMeetingXMid=sal_False; } |
| if (bLks1 || bLks2) { aMeeting.X()=nXMin; bMeetingXMid=sal_False; } |
| if (bUnt1 || bUnt2) { aMeeting.Y()=nYMax; bMeetingYMid=sal_False; } |
| if (bObn1 || bObn2) { aMeeting.Y()=nYMin; bMeetingYMid=sal_False; } |
| } |
| } |
| } |
| |
| XPolygon aXP1(ImpCalcObjToCenter(aPt1,nAngle1,aBewareRect1,aMeeting)); |
| XPolygon aXP2(ImpCalcObjToCenter(aPt2,nAngle2,aBewareRect2,aMeeting)); |
| sal_uInt16 nXP1Anz=aXP1.GetPointCount(); |
| sal_uInt16 nXP2Anz=aXP2.GetPointCount(); |
| if (bInfo) { |
| pInfo->nObj1Lines=nXP1Anz; if (nXP1Anz>1) pInfo->nObj1Lines--; |
| pInfo->nObj2Lines=nXP2Anz; if (nXP2Anz>1) pInfo->nObj2Lines--; |
| } |
| Point aEP1(aXP1[nXP1Anz-1]); |
| Point aEP2(aXP2[nXP2Anz-1]); |
| FASTBOOL bInsMeetingPoint=aEP1.X()!=aEP2.X() && aEP1.Y()!=aEP2.Y(); |
| FASTBOOL bHorzE1=aEP1.Y()==aXP1[nXP1Anz-2].Y(); // letzte Linie von XP1 horizontal? |
| FASTBOOL bHorzE2=aEP2.Y()==aXP2[nXP2Anz-2].Y(); // letzte Linie von XP2 horizontal? |
| if (aEP1==aEP2 && (bHorzE1 && bHorzE2 && aEP1.Y()==aEP2.Y()) || (!bHorzE1 && !bHorzE2 && aEP1.X()==aEP2.X())) { |
| // Sonderbehandlung fuer 'I'-Verbinder |
| nXP1Anz--; aXP1.Remove(nXP1Anz,1); |
| nXP2Anz--; aXP2.Remove(nXP2Anz,1); |
| bMeetingXMid=sal_False; |
| bMeetingYMid=sal_False; |
| } |
| if (bInsMeetingPoint) { |
| aXP1.Insert(XPOLY_APPEND,aMeeting,XPOLY_NORMAL); |
| if (bInfo) { |
| // Durch einfuegen des MeetingPoints kommen 2 weitere Linie hinzu. |
| // Evtl. wird eine von diesen die Mittellinie. |
| if (pInfo->nObj1Lines==pInfo->nObj2Lines) { |
| pInfo->nObj1Lines++; |
| pInfo->nObj2Lines++; |
| } else { |
| if (pInfo->nObj1Lines>pInfo->nObj2Lines) { |
| pInfo->nObj2Lines++; |
| pInfo->nMiddleLine=nXP1Anz-1; |
| } else { |
| pInfo->nObj1Lines++; |
| pInfo->nMiddleLine=nXP1Anz; |
| } |
| } |
| } |
| } else if (bInfo && aEP1!=aEP2 && nXP1Anz+nXP2Anz>=4) { |
| // Durch Verbinden der beiden Enden kommt eine weitere Linie hinzu. |
| // Dies wird die Mittellinie. |
| pInfo->nMiddleLine=nXP1Anz-1; |
| } |
| sal_uInt16 nNum=aXP2.GetPointCount(); |
| if (aXP1[nXP1Anz-1]==aXP2[nXP2Anz-1] && nXP1Anz>1 && nXP2Anz>1) nNum--; |
| while (nNum>0) { |
| nNum--; |
| aXP1.Insert(XPOLY_APPEND,aXP2[nNum],XPOLY_NORMAL); |
| } |
| sal_uInt16 nPntAnz=aXP1.GetPointCount(); |
| char cForm=0; |
| if (bInfo || pnQuality!=NULL) { |
| cForm='?'; |
| if (nPntAnz==2) cForm='I'; |
| else if (nPntAnz==3) cForm='L'; |
| else if (nPntAnz==4) { // Z oder U |
| if (nAngle1==nAngle2) cForm='U'; |
| else cForm='Z'; |
| } else if (nPntAnz==4) { /* Ú-¿ Ú-¿ */ |
| /* ... -Ù -Ù */ |
| } else if (nPntAnz==6) { // S oder C oder ... |
| if (nAngle1!=nAngle2) { |
| // Fuer Typ S hat Linie2 dieselbe Richtung wie Linie4. |
| // Bei Typ C sind die beiden genau entgegengesetzt. |
| Point aP1(aXP1[1]); |
| Point aP2(aXP1[2]); |
| Point aP3(aXP1[3]); |
| Point aP4(aXP1[4]); |
| if (aP1.Y()==aP2.Y()) { // beide Linien Horz |
| if ((aP1.X()<aP2.X())==(aP3.X()<aP4.X())) cForm='S'; |
| else cForm='C'; |
| } else { // sonst beide Linien Vert |
| if ((aP1.Y()<aP2.Y())==(aP3.Y()<aP4.Y())) cForm='S'; |
| else cForm='C'; |
| } |
| } else cForm='4'; // sonst der 3. Fall mit 5 Linien |
| } else cForm='?'; // |
| // Weitere Formen: |
| if (bInfo) { |
| pInfo->cOrthoForm=cForm; |
| if (cForm=='I' || cForm=='L' || cForm=='Z' || cForm=='U') { |
| pInfo->nObj1Lines=1; |
| pInfo->nObj2Lines=1; |
| if (cForm=='Z' || cForm=='U') { |
| pInfo->nMiddleLine=1; |
| } else { |
| pInfo->nMiddleLine=0xFFFF; |
| } |
| } else if (cForm=='S' || cForm=='C') { |
| pInfo->nObj1Lines=2; |
| pInfo->nObj2Lines=2; |
| pInfo->nMiddleLine=2; |
| } |
| } |
| } |
| if (pnQuality!=NULL) { |
| sal_uIntPtr nQual=0; |
| sal_uIntPtr nQual0=nQual; // Ueberlaeufe vorbeugen |
| FASTBOOL bOverflow=sal_False; |
| Point aPt0(aXP1[0]); |
| for (sal_uInt16 nPntNum=1; nPntNum<nPntAnz; nPntNum++) { |
| Point aPt1b(aXP1[nPntNum]); |
| nQual+=Abs(aPt1b.X()-aPt0.X())+Abs(aPt1b.Y()-aPt0.Y()); |
| if (nQual<nQual0) bOverflow=sal_True; |
| nQual0=nQual; |
| aPt0=aPt1b; |
| } |
| |
| sal_uInt16 nTmp=nPntAnz; |
| if (cForm=='Z') { |
| nTmp=2; // Z-Form hat gute Qualitaet (nTmp=2 statt 4) |
| sal_uIntPtr n1=Abs(aXP1[1].X()-aXP1[0].X())+Abs(aXP1[1].Y()-aXP1[0].Y()); |
| sal_uIntPtr n2=Abs(aXP1[2].X()-aXP1[1].X())+Abs(aXP1[2].Y()-aXP1[1].Y()); |
| sal_uIntPtr n3=Abs(aXP1[3].X()-aXP1[2].X())+Abs(aXP1[3].Y()-aXP1[2].Y()); |
| // fuer moeglichst gleichlange Linien sorgen |
| sal_uIntPtr nBesser=0; |
| n1+=n3; |
| n3=n2/4; |
| if (n1>=n2) nBesser=6; |
| else if (n1>=3*n3) nBesser=4; |
| else if (n1>=2*n3) nBesser=2; |
| if (aXP1[0].Y()!=aXP1[1].Y()) nBesser++; // Senkrechte Startlinie kriegt auch noch einen Pluspunkt (fuer H/V-Prio) |
| if (nQual>nBesser) nQual-=nBesser; else nQual=0; |
| } |
| if (nTmp>=3) { |
| nQual0=nQual; |
| nQual+=(sal_uIntPtr)nTmp*0x01000000; |
| if (nQual<nQual0 || nTmp>15) bOverflow=sal_True; |
| } |
| if (nPntAnz>=2) { // Austrittswinkel nochmal pruefen |
| Point aP1(aXP1[1]); aP1-=aXP1[0]; |
| Point aP2(aXP1[nPntAnz-2]); aP2-=aXP1[nPntAnz-1]; |
| long nAng1=0; if (aP1.X()<0) nAng1=18000; if (aP1.Y()>0) nAng1=27000; |
| if (aP1.Y()<0) nAng1=9000; if (aP1.X()!=0 && aP1.Y()!=0) nAng1=1; // Schraeg!?! |
| long nAng2=0; if (aP2.X()<0) nAng2=18000; if (aP2.Y()>0) nAng2=27000; |
| if (aP2.Y()<0) nAng2=9000; if (aP2.X()!=0 && aP2.Y()!=0) nAng2=1; // Schraeg!?! |
| if (nAng1!=nAngle1) nIntersections++; |
| if (nAng2!=nAngle2) nIntersections++; |
| } |
| |
| // Fuer den Qualitaetscheck wieder die Original-Rects verwenden und |
| // gleichzeitig checken, ob eins fuer die Edge-Berechnung verkleinert |
| // wurde (z.B. Fall 2.9) |
| aBewareRect1=rBewareRect1; |
| aBewareRect2=rBewareRect2; |
| |
| for (sal_uInt16 i=0; i<nPntAnz; i++) { |
| Point aPt1b(aXP1[i]); |
| FASTBOOL b1=aPt1b.X()>aBewareRect1.Left() && aPt1b.X()<aBewareRect1.Right() && |
| aPt1b.Y()>aBewareRect1.Top() && aPt1b.Y()<aBewareRect1.Bottom(); |
| FASTBOOL b2=aPt1b.X()>aBewareRect2.Left() && aPt1b.X()<aBewareRect2.Right() && |
| aPt1b.Y()>aBewareRect2.Top() && aPt1b.Y()<aBewareRect2.Bottom(); |
| sal_uInt16 nInt0=nIntersections; |
| if (i==0 || i==nPntAnz-1) { |
| if (b1 && b2) nIntersections++; |
| } else { |
| if (b1) nIntersections++; |
| if (b2) nIntersections++; |
| } |
| // und nun noch auf Ueberschneidungen checken |
| if (i>0 && nInt0==nIntersections) { |
| if (aPt0.Y()==aPt1b.Y()) { // Horizontale Linie |
| if (aPt0.Y()>aBewareRect1.Top() && aPt0.Y()<aBewareRect1.Bottom() && |
| ((aPt0.X()<=aBewareRect1.Left() && aPt1b.X()>=aBewareRect1.Right()) || |
| (aPt1b.X()<=aBewareRect1.Left() && aPt0.X()>=aBewareRect1.Right()))) nIntersections++; |
| if (aPt0.Y()>aBewareRect2.Top() && aPt0.Y()<aBewareRect2.Bottom() && |
| ((aPt0.X()<=aBewareRect2.Left() && aPt1b.X()>=aBewareRect2.Right()) || |
| (aPt1b.X()<=aBewareRect2.Left() && aPt0.X()>=aBewareRect2.Right()))) nIntersections++; |
| } else { // Vertikale Linie |
| if (aPt0.X()>aBewareRect1.Left() && aPt0.X()<aBewareRect1.Right() && |
| ((aPt0.Y()<=aBewareRect1.Top() && aPt1b.Y()>=aBewareRect1.Bottom()) || |
| (aPt1b.Y()<=aBewareRect1.Top() && aPt0.Y()>=aBewareRect1.Bottom()))) nIntersections++; |
| if (aPt0.X()>aBewareRect2.Left() && aPt0.X()<aBewareRect2.Right() && |
| ((aPt0.Y()<=aBewareRect2.Top() && aPt1b.Y()>=aBewareRect2.Bottom()) || |
| (aPt1b.Y()<=aBewareRect2.Top() && aPt0.Y()>=aBewareRect2.Bottom()))) nIntersections++; |
| } |
| } |
| aPt0=aPt1b; |
| } |
| if (nPntAnz<=1) nIntersections++; |
| nQual0=nQual; |
| nQual+=(sal_uIntPtr)nIntersections*0x10000000; |
| if (nQual<nQual0 || nIntersections>15) bOverflow=sal_True; |
| |
| if (bOverflow || nQual==0xFFFFFFFF) nQual=0xFFFFFFFE; |
| *pnQuality=nQual; |
| } |
| if (bInfo) { // nun die Linienversaetze auf aXP1 anwenden |
| if (pInfo->nMiddleLine!=0xFFFF) { |
| sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(MIDDLELINE,aXP1); |
| if (pInfo->ImpIsHorzLine(MIDDLELINE,aXP1)) { |
| aXP1[nIdx].Y()+=pInfo->aMiddleLine.Y(); |
| aXP1[nIdx+1].Y()+=pInfo->aMiddleLine.Y(); |
| } else { |
| aXP1[nIdx].X()+=pInfo->aMiddleLine.X(); |
| aXP1[nIdx+1].X()+=pInfo->aMiddleLine.X(); |
| } |
| } |
| if (pInfo->nObj1Lines>=2) { |
| sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(OBJ1LINE2,aXP1); |
| if (pInfo->ImpIsHorzLine(OBJ1LINE2,aXP1)) { |
| aXP1[nIdx].Y()+=pInfo->aObj1Line2.Y(); |
| aXP1[nIdx+1].Y()+=pInfo->aObj1Line2.Y(); |
| } else { |
| aXP1[nIdx].X()+=pInfo->aObj1Line2.X(); |
| aXP1[nIdx+1].X()+=pInfo->aObj1Line2.X(); |
| } |
| } |
| if (pInfo->nObj1Lines>=3) { |
| sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(OBJ1LINE3,aXP1); |
| if (pInfo->ImpIsHorzLine(OBJ1LINE3,aXP1)) { |
| aXP1[nIdx].Y()+=pInfo->aObj1Line3.Y(); |
| aXP1[nIdx+1].Y()+=pInfo->aObj1Line3.Y(); |
| } else { |
| aXP1[nIdx].X()+=pInfo->aObj1Line3.X(); |
| aXP1[nIdx+1].X()+=pInfo->aObj1Line3.X(); |
| } |
| } |
| if (pInfo->nObj2Lines>=2) { |
| sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(OBJ2LINE2,aXP1); |
| if (pInfo->ImpIsHorzLine(OBJ2LINE2,aXP1)) { |
| aXP1[nIdx].Y()+=pInfo->aObj2Line2.Y(); |
| aXP1[nIdx+1].Y()+=pInfo->aObj2Line2.Y(); |
| } else { |
| aXP1[nIdx].X()+=pInfo->aObj2Line2.X(); |
| aXP1[nIdx+1].X()+=pInfo->aObj2Line2.X(); |
| } |
| } |
| if (pInfo->nObj2Lines>=3) { |
| sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(OBJ2LINE3,aXP1); |
| if (pInfo->ImpIsHorzLine(OBJ2LINE3,aXP1)) { |
| aXP1[nIdx].Y()+=pInfo->aObj2Line3.Y(); |
| aXP1[nIdx+1].Y()+=pInfo->aObj2Line3.Y(); |
| } else { |
| aXP1[nIdx].X()+=pInfo->aObj2Line3.X(); |
| aXP1[nIdx+1].X()+=pInfo->aObj2Line3.X(); |
| } |
| } |
| } |
| // Nun mache ich ggf. aus dem Verbinder eine Bezierkurve |
| if (eKind==SDREDGE_BEZIER && nPntAnz>2) { |
| Point* pPt1=&aXP1[0]; |
| Point* pPt2=&aXP1[1]; |
| Point* pPt3=&aXP1[nPntAnz-2]; |
| Point* pPt4=&aXP1[nPntAnz-1]; |
| long dx1=pPt2->X()-pPt1->X(); |
| long dy1=pPt2->Y()-pPt1->Y(); |
| long dx2=pPt3->X()-pPt4->X(); |
| long dy2=pPt3->Y()-pPt4->Y(); |
| if (cForm=='L') { // nPntAnz==3 |
| aXP1.SetFlags(1,XPOLY_CONTROL); |
| Point aPt3(*pPt2); |
| aXP1.Insert(2,aPt3,XPOLY_CONTROL); |
| nPntAnz=aXP1.GetPointCount(); |
| pPt1=&aXP1[0]; |
| pPt2=&aXP1[1]; |
| pPt3=&aXP1[nPntAnz-2]; |
| pPt4=&aXP1[nPntAnz-1]; |
| pPt2->X()-=dx1/3; |
| pPt2->Y()-=dy1/3; |
| pPt3->X()-=dx2/3; |
| pPt3->Y()-=dy2/3; |
| } else if (nPntAnz>=4 && nPntAnz<=6) { // Z oder U oder ... |
| // fuer Alle Anderen werden die Endpunkte der Ausgangslinien |
| // erstmal zu Kontrollpunkten. Bei nPntAnz>4 ist also noch |
| // Nacharbeit erforderlich! |
| aXP1.SetFlags(1,XPOLY_CONTROL); |
| aXP1.SetFlags(nPntAnz-2,XPOLY_CONTROL); |
| // Distanz x1.5 |
| pPt2->X()+=dx1/2; |
| pPt2->Y()+=dy1/2; |
| pPt3->X()+=dx2/2; |
| pPt3->Y()+=dy2/2; |
| if (nPntAnz==5) { |
| // Vor und hinter dem Mittelpunkt jeweils |
| // noch einen Kontrollpunkt einfuegen |
| Point aCenter(aXP1[2]); |
| long dx1b=aCenter.X()-aXP1[1].X(); |
| long dy1b=aCenter.Y()-aXP1[1].Y(); |
| long dx2b=aCenter.X()-aXP1[3].X(); |
| long dy2b=aCenter.Y()-aXP1[3].Y(); |
| aXP1.Insert(2,aCenter,XPOLY_CONTROL); |
| aXP1.SetFlags(3,XPOLY_SYMMTR); |
| aXP1.Insert(4,aCenter,XPOLY_CONTROL); |
| aXP1[2].X()-=dx1b/2; |
| aXP1[2].Y()-=dy1b/2; |
| aXP1[3].X()-=(dx1b+dx2b)/4; |
| aXP1[3].Y()-=(dy1b+dy2b)/4; |
| aXP1[4].X()-=dx2b/2; |
| aXP1[4].Y()-=dy2b/2; |
| } |
| if (nPntAnz==6) { |
| Point aPt1b(aXP1[2]); |
| Point aPt2b(aXP1[3]); |
| aXP1.Insert(2,aPt1b,XPOLY_CONTROL); |
| aXP1.Insert(5,aPt2b,XPOLY_CONTROL); |
| long dx=aPt1b.X()-aPt2b.X(); |
| long dy=aPt1b.Y()-aPt2b.Y(); |
| aXP1[3].X()-=dx/2; |
| aXP1[3].Y()-=dy/2; |
| aXP1.SetFlags(3,XPOLY_SYMMTR); |
| //aXP1[4].X()+=dx/2; |
| //aXP1[4].Y()+=dy/2; |
| aXP1.Remove(4,1); // weil identisch mit aXP1[3] |
| } |
| } |
| } |
| return aXP1; |
| } |
| |
| /* |
| Nach einer einfachen Rechnung koennte es max. 64 unterschiedliche Verlaeufe mit |
| 5 Linien, 32 mit 4 Linien, 16 mit 3, 8 mit 2 Linien und 4 mit 1 Linie geben=124. |
| Normalisiert auf 1. Austrittswinkel nach rechts bleiben dann noch 31. |
| Dann noch eine vertikale Spiegelung wegnormalisiert bleiben noch 16 |
| characteristische Verlaufszuege mit 1-5 Linien: |
| Mit 1 Linie (Typ 'I'): -- |
| Mit 2 Linien (Typ 'L'): -Ù |
| Mit 3 Linien (Typ 'U'): -¿ (Typ 'Z'): Ú- |
| -Ù -Ù |
| Mit 4 Linien: 1 ist nicht plausibel, 3 ist=2 (90deg Drehung). Verbleibt 2,4 |
| Ú-Ù Ú¿ À¿ Ú¿ Ú¿ Ú-¿ |
| -Ù -Ù -Ù -Ù -Ù -Ù |
| Mit 5 Linien: nicht plausibel sind 1,2,4,5. 7 ist identisch mit 3 (Richtungsumkehr) |
| Bleibt also 3,6 und 8. '4' 'S' 'C' |
| ¿ Ú -¿ Ú- Ú-¿ Ú- |
| Ú-Ù Ú-Ù Ú-¿ Ú-¿ À¿ À¿ -Ù ³ Ú-¿ Ú-¿ À¿ Ú-¿ |
| -Ù -Ù -Ù Ù -Ù À- -Ù -Ù --Ù À Ù -Ù Ù -Ù À Ù |
| Insgesamt sind also 9 Grundtypen zu unterscheiden die den 400 Konstellationen |
| aus Objektposition und Austrittswinkeln zuzuordnen sind. |
| 4 der 9 Grundtypen haben eine 'Mittellinie'. Die Anzahl der zu Objektabstaende |
| je Objekt variiert von 0-3: |
| Mi O1 O2 Anmerkung |
| 'I': n 0 0 |
| 'L': n 0 0 |
| 'U': n 0-1 0-1 |
| 'Z': j 0 0 |
| 4.1: j 0 1 = U+1 bzw. 1+U |
| 4.2: n 0-2 0-2 = Z+1 |
| '4': j 0 2 = Z+2 |
| 'S': j 1 1 = 1+Z+1 |
| 'C': n 0-3 0-3 = 1+U+1 |
| */ |
| |
| void __EXPORT SdrEdgeObj::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) |
| { |
| SfxSimpleHint* pSimple=PTR_CAST(SfxSimpleHint,&rHint); |
| sal_uIntPtr nId=pSimple==0 ? 0 : pSimple->GetId(); |
| FASTBOOL bDataChg=nId==SFX_HINT_DATACHANGED; |
| FASTBOOL bDying=nId==SFX_HINT_DYING; |
| FASTBOOL bObj1=aCon1.pObj!=NULL && aCon1.pObj->GetBroadcaster()==&rBC; |
| FASTBOOL bObj2=aCon2.pObj!=NULL && aCon2.pObj->GetBroadcaster()==&rBC; |
| if (bDying && (bObj1 || bObj2)) { |
| // #35605# Dying vorher abfangen, damit AttrObj nicht |
| // wg. vermeintlicher Vorlagenaenderung rumbroadcastet |
| if (bObj1) aCon1.pObj=NULL; |
| if (bObj2) aCon2.pObj=NULL; |
| return; // Und mehr braucht hier nicht getan werden. |
| } |
| if ( bObj1 || bObj2 ) |
| { |
| bEdgeTrackUserDefined = sal_False; |
| } |
| SdrTextObj::Notify(rBC,rHint); |
| if (nNotifyingCount==0) { // Hier nun auch ein VerriegelungsFlag |
| ((SdrEdgeObj*)this)->nNotifyingCount++; |
| SdrHint* pSdrHint=PTR_CAST(SdrHint,&rHint); |
| if (bDataChg) { // StyleSheet geaendert |
| ImpSetAttrToEdgeInfo(); // Werte bei Vorlagenaenderung vom Pool nach aEdgeInfo kopieren |
| } |
| if (bDataChg || |
| (bObj1 && aCon1.pObj->GetPage()==pPage) || |
| (bObj2 && aCon2.pObj->GetPage()==pPage) || |
| (pSdrHint && pSdrHint->GetKind()==HINT_OBJREMOVED)) |
| { |
| // Broadcasting nur, wenn auf der selben Page |
| Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetCurrentBoundRect(); |
| // #110094#-14 if (!bEdgeTrackDirty) SendRepaintBroadcast(); |
| ImpDirtyEdgeTrack(); |
| |
| // only redraw here, no objectchange |
| ActionChanged(); |
| // BroadcastObjectChange(); |
| |
| SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0); |
| } |
| ((SdrEdgeObj*)this)->nNotifyingCount--; |
| } |
| } |
| |
| /** updates edges that are connected to the edges of this object |
| as if the connected objects send a repaint broadcast |
| #103122# |
| */ |
| void SdrEdgeObj::Reformat() |
| { |
| if( NULL != aCon1.pObj ) |
| { |
| SfxSimpleHint aHint( SFX_HINT_DATACHANGED ); |
| Notify( *const_cast<SfxBroadcaster*>(aCon1.pObj->GetBroadcaster()), aHint ); |
| } |
| |
| if( NULL != aCon2.pObj ) |
| { |
| SfxSimpleHint aHint( SFX_HINT_DATACHANGED ); |
| Notify( *const_cast<SfxBroadcaster*>(aCon2.pObj->GetBroadcaster()), aHint ); |
| } |
| } |
| |
| void SdrEdgeObj::operator=(const SdrObject& rObj) |
| { |
| SdrTextObj::operator=(rObj); |
| *pEdgeTrack =*((SdrEdgeObj&)rObj).pEdgeTrack; |
| bEdgeTrackDirty=((SdrEdgeObj&)rObj).bEdgeTrackDirty; |
| aCon1 =((SdrEdgeObj&)rObj).aCon1; |
| aCon2 =((SdrEdgeObj&)rObj).aCon2; |
| aCon1.pObj=NULL; |
| aCon2.pObj=NULL; |
| aEdgeInfo=((SdrEdgeObj&)rObj).aEdgeInfo; |
| } |
| |
| void SdrEdgeObj::TakeObjNameSingul(XubString& rName) const |
| { |
| rName=ImpGetResStr(STR_ObjNameSingulEDGE); |
| |
| String aName( GetName() ); |
| if(aName.Len()) |
| { |
| rName += sal_Unicode(' '); |
| rName += sal_Unicode('\''); |
| rName += aName; |
| rName += sal_Unicode('\''); |
| } |
| } |
| |
| void SdrEdgeObj::TakeObjNamePlural(XubString& rName) const |
| { |
| rName=ImpGetResStr(STR_ObjNamePluralEDGE); |
| } |
| |
| basegfx::B2DPolyPolygon SdrEdgeObj::TakeXorPoly() const |
| { |
| basegfx::B2DPolyPolygon aPolyPolygon; |
| |
| if (bEdgeTrackDirty) |
| { |
| ((SdrEdgeObj*)this)->ImpRecalcEdgeTrack(); |
| } |
| |
| if(pEdgeTrack) |
| { |
| aPolyPolygon.append(pEdgeTrack->getB2DPolygon()); |
| } |
| |
| return aPolyPolygon; |
| } |
| |
| void SdrEdgeObj::SetEdgeTrackPath( const basegfx::B2DPolyPolygon& rPoly ) |
| { |
| if ( !rPoly.count() ) |
| { |
| bEdgeTrackDirty = sal_True; |
| bEdgeTrackUserDefined = sal_False; |
| } |
| else |
| { |
| *pEdgeTrack = XPolygon( rPoly.getB2DPolygon( 0 ) ); |
| bEdgeTrackDirty = sal_False; |
| bEdgeTrackUserDefined = sal_True; |
| |
| // #i110629# also set aRect and maSnapeRect dependent from pEdgeTrack |
| const Rectangle aPolygonBounds(pEdgeTrack->GetBoundRect()); |
| aRect = aPolygonBounds; |
| maSnapRect = aPolygonBounds; |
| } |
| } |
| |
| basegfx::B2DPolyPolygon SdrEdgeObj::GetEdgeTrackPath() const |
| { |
| basegfx::B2DPolyPolygon aPolyPolygon; |
| |
| if (bEdgeTrackDirty) |
| ((SdrEdgeObj*)this)->ImpRecalcEdgeTrack(); |
| |
| aPolyPolygon.append( pEdgeTrack->getB2DPolygon() ); |
| |
| return aPolyPolygon; |
| } |
| |
| sal_uInt32 SdrEdgeObj::GetHdlCount() const |
| { |
| SdrEdgeKind eKind=((SdrEdgeKindItem&)(GetObjectItem(SDRATTR_EDGEKIND))).GetValue(); |
| sal_uInt32 nHdlAnz(0L); |
| sal_uInt32 nPntAnz(pEdgeTrack->GetPointCount()); |
| |
| if(nPntAnz) |
| { |
| nHdlAnz = 2L; |
| |
| if ((eKind==SDREDGE_ORTHOLINES || eKind==SDREDGE_BEZIER) && nPntAnz >= 4L) |
| { |
| sal_uInt32 nO1(aEdgeInfo.nObj1Lines > 0L ? aEdgeInfo.nObj1Lines - 1L : 0L); |
| sal_uInt32 nO2(aEdgeInfo.nObj2Lines > 0L ? aEdgeInfo.nObj2Lines - 1L : 0L); |
| sal_uInt32 nM(aEdgeInfo.nMiddleLine != 0xFFFF ? 1L : 0L); |
| nHdlAnz += nO1 + nO2 + nM; |
| } |
| else if (eKind==SDREDGE_THREELINES && nPntAnz == 4L) |
| { |
| if(GetConnectedNode(sal_True)) |
| nHdlAnz++; |
| |
| if(GetConnectedNode(sal_False)) |
| nHdlAnz++; |
| } |
| } |
| |
| return nHdlAnz; |
| } |
| |
| SdrHdl* SdrEdgeObj::GetHdl(sal_uInt32 nHdlNum) const |
| { |
| SdrHdl* pHdl=NULL; |
| sal_uInt32 nPntAnz(pEdgeTrack->GetPointCount()); |
| if (nPntAnz!=0) { |
| if (nHdlNum==0) { |
| pHdl=new ImpEdgeHdl((*pEdgeTrack)[0],HDL_POLY); |
| if (aCon1.pObj!=NULL && aCon1.bBestVertex) pHdl->Set1PixMore(sal_True); |
| } else if (nHdlNum==1) { |
| pHdl=new ImpEdgeHdl((*pEdgeTrack)[sal_uInt16(nPntAnz-1)],HDL_POLY); |
| if (aCon2.pObj!=NULL && aCon2.bBestVertex) pHdl->Set1PixMore(sal_True); |
| } else { |
| SdrEdgeKind eKind=((SdrEdgeKindItem&)(GetObjectItem(SDRATTR_EDGEKIND))).GetValue(); |
| if (eKind==SDREDGE_ORTHOLINES || eKind==SDREDGE_BEZIER) { |
| sal_uInt32 nO1(aEdgeInfo.nObj1Lines > 0L ? aEdgeInfo.nObj1Lines - 1L : 0L); |
| sal_uInt32 nO2(aEdgeInfo.nObj2Lines > 0L ? aEdgeInfo.nObj2Lines - 1L : 0L); |
| sal_uInt32 nM(aEdgeInfo.nMiddleLine != 0xFFFF ? 1L : 0L); |
| sal_uInt32 nNum(nHdlNum - 2L); |
| sal_Int32 nPt(0L); |
| pHdl=new ImpEdgeHdl(Point(),HDL_POLY); |
| if (nNum<nO1) { |
| nPt=nNum+1L; |
| if (nNum==0) ((ImpEdgeHdl*)pHdl)->SetLineCode(OBJ1LINE2); |
| if (nNum==1) ((ImpEdgeHdl*)pHdl)->SetLineCode(OBJ1LINE3); |
| } else { |
| nNum=nNum-nO1; |
| if (nNum<nO2) { |
| nPt=nPntAnz-3-nNum; |
| if (nNum==0) ((ImpEdgeHdl*)pHdl)->SetLineCode(OBJ2LINE2); |
| if (nNum==1) ((ImpEdgeHdl*)pHdl)->SetLineCode(OBJ2LINE3); |
| } else { |
| nNum=nNum-nO2; |
| if (nNum<nM) { |
| nPt=aEdgeInfo.nMiddleLine; |
| ((ImpEdgeHdl*)pHdl)->SetLineCode(MIDDLELINE); |
| } |
| } |
| } |
| if (nPt>0) { |
| Point aPos((*pEdgeTrack)[(sal_uInt16)nPt]); |
| aPos+=(*pEdgeTrack)[(sal_uInt16)nPt+1]; |
| aPos.X()/=2; |
| aPos.Y()/=2; |
| pHdl->SetPos(aPos); |
| } else { |
| delete pHdl; |
| pHdl=NULL; |
| } |
| } else if (eKind==SDREDGE_THREELINES) { |
| sal_uInt32 nNum(nHdlNum); |
| if (GetConnectedNode(sal_True)==NULL) nNum++; |
| Point aPos((*pEdgeTrack)[(sal_uInt16)nNum-1]); |
| pHdl=new ImpEdgeHdl(aPos,HDL_POLY); |
| if (nNum==2) ((ImpEdgeHdl*)pHdl)->SetLineCode(OBJ1LINE2); |
| if (nNum==3) ((ImpEdgeHdl*)pHdl)->SetLineCode(OBJ2LINE2); |
| } |
| } |
| if (pHdl!=NULL) { |
| pHdl->SetPointNum(nHdlNum); |
| } |
| } |
| return pHdl; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| bool SdrEdgeObj::hasSpecialDrag() const |
| { |
| return true; |
| } |
| |
| SdrObject* SdrEdgeObj::getFullDragClone() const |
| { |
| // use Clone operator |
| SdrEdgeObj* pRetval = (SdrEdgeObj*)Clone(); |
| |
| // copy connections for clone, SdrEdgeObj::operator= does not do this |
| pRetval->ConnectToNode(true, GetConnectedNode(true)); |
| pRetval->ConnectToNode(false, GetConnectedNode(false)); |
| |
| return pRetval; |
| } |
| |
| bool SdrEdgeObj::beginSpecialDrag(SdrDragStat& rDrag) const |
| { |
| if(!rDrag.GetHdl()) |
| return false; |
| |
| rDrag.SetEndDragChangesAttributes(true); |
| |
| if(rDrag.GetHdl()->GetPointNum() < 2) |
| { |
| rDrag.SetNoSnap(true); |
| } |
| |
| return true; |
| } |
| |
| bool SdrEdgeObj::applySpecialDrag(SdrDragStat& rDragStat) |
| { |
| SdrEdgeObj* pOriginalEdge = dynamic_cast< SdrEdgeObj* >(rDragStat.GetHdl()->GetObj()); |
| const bool bOriginalEdgeModified(pOriginalEdge == this); |
| |
| if(!bOriginalEdgeModified && pOriginalEdge) |
| { |
| // copy connections when clone is modified. This is needed because |
| // as preparation to this modification the data from the original object |
| // was copied to the clone using the operator=. As can be seen there, |
| // that operator does not copy the connections (for good reason) |
| ConnectToNode(true, pOriginalEdge->GetConnection(true).GetObject()); |
| ConnectToNode(false, pOriginalEdge->GetConnection(false).GetObject()); |
| } |
| |
| if(rDragStat.GetHdl()->GetPointNum() < 2) |
| { |
| // start or end point connector drag |
| const bool bDragA(0 == rDragStat.GetHdl()->GetPointNum()); |
| const Point aPointNow(rDragStat.GetNow()); |
| |
| if(rDragStat.GetPageView()) |
| { |
| SdrObjConnection* pDraggedOne(bDragA ? &aCon1 : &aCon2); |
| |
| // clear connection |
| DisconnectFromNode(bDragA); |
| |
| // look for new connection |
| ImpFindConnector(aPointNow, *rDragStat.GetPageView(), *pDraggedOne, pOriginalEdge); |
| |
| if(pDraggedOne->pObj) |
| { |
| // if found, officially connect to it; ImpFindConnector only |
| // sets pObj hard |
| SdrObject* pNewConnection = pDraggedOne->pObj; |
| pDraggedOne->pObj = 0; |
| ConnectToNode(bDragA, pNewConnection); |
| } |
| |
| if(rDragStat.GetView() && !bOriginalEdgeModified) |
| { |
| // show IA helper, but only do this during IA, so not when the original |
| // Edge gets modified in the last call |
| rDragStat.GetView()->SetConnectMarker(*pDraggedOne, *rDragStat.GetPageView()); |
| } |
| } |
| |
| if(pEdgeTrack) |
| { |
| // change pEdgeTrack to modified position |
| if(bDragA) |
| { |
| (*pEdgeTrack)[0] = aPointNow; |
| } |
| else |
| { |
| (*pEdgeTrack)[sal_uInt16(pEdgeTrack->GetPointCount()-1)] = aPointNow; |
| } |
| } |
| |
| // reset edge info's offsets, this is a end point drag |
| aEdgeInfo.aObj1Line2 = Point(); |
| aEdgeInfo.aObj1Line3 = Point(); |
| aEdgeInfo.aObj2Line2 = Point(); |
| aEdgeInfo.aObj2Line3 = Point(); |
| aEdgeInfo.aMiddleLine = Point(); |
| } |
| else |
| { |
| // control point connector drag |
| const ImpEdgeHdl* pEdgeHdl = (ImpEdgeHdl*)rDragStat.GetHdl(); |
| const SdrEdgeLineCode eLineCode = pEdgeHdl->GetLineCode(); |
| const Point aDist(rDragStat.GetNow() - rDragStat.GetStart()); |
| sal_Int32 nDist(pEdgeHdl->IsHorzDrag() ? aDist.X() : aDist.Y()); |
| |
| nDist += aEdgeInfo.ImpGetLineVersatz(eLineCode, *pEdgeTrack); |
| aEdgeInfo.ImpSetLineVersatz(eLineCode, *pEdgeTrack, nDist); |
| } |
| |
| // force recalc EdgeTrack |
| *pEdgeTrack = ImpCalcEdgeTrack(*pEdgeTrack, aCon1, aCon2, &aEdgeInfo); |
| bEdgeTrackDirty=sal_False; |
| |
| // save EdgeInfos and mark object as user modified |
| ImpSetEdgeInfoToAttr(); |
| bEdgeTrackUserDefined = false; |
| SetRectsDirty(); |
| //SetChanged(); |
| |
| if(bOriginalEdgeModified && rDragStat.GetView()) |
| { |
| // hide connect marker helper again when original gets changed. |
| // This happens at the end of the interaction |
| rDragStat.GetView()->HideConnectMarker(); |
| } |
| |
| return true; |
| } |
| |
| String SdrEdgeObj::getSpecialDragComment(const SdrDragStat& rDrag) const |
| { |
| const bool bCreateComment(rDrag.GetView() && this == rDrag.GetView()->GetCreateObj()); |
| |
| if(bCreateComment) |
| { |
| return String(); |
| } |
| else |
| { |
| XubString aStr; |
| ImpTakeDescriptionStr(STR_DragEdgeTail, aStr); |
| |
| return aStr; |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| basegfx::B2DPolygon SdrEdgeObj::ImplAddConnectorOverlay(SdrDragMethod& rDragMethod, bool bTail1, bool bTail2, bool bDetail) const |
| { |
| basegfx::B2DPolygon aResult; |
| |
| if(bDetail) |
| { |
| SdrObjConnection aMyCon1(aCon1); |
| SdrObjConnection aMyCon2(aCon2); |
| |
| if (bTail1) |
| { |
| const basegfx::B2DPoint aTemp(rDragMethod.getCurrentTransformation() * basegfx::B2DPoint(aMyCon1.aObjOfs.X(), aMyCon1.aObjOfs.Y())); |
| aMyCon1.aObjOfs.X() = basegfx::fround(aTemp.getX()); |
| aMyCon1.aObjOfs.Y() = basegfx::fround(aTemp.getY()); |
| } |
| |
| if (bTail2) |
| { |
| const basegfx::B2DPoint aTemp(rDragMethod.getCurrentTransformation() * basegfx::B2DPoint(aMyCon2.aObjOfs.X(), aMyCon2.aObjOfs.Y())); |
| aMyCon2.aObjOfs.X() = basegfx::fround(aTemp.getX()); |
| aMyCon2.aObjOfs.Y() = basegfx::fround(aTemp.getY()); |
| } |
| |
| SdrEdgeInfoRec aInfo(aEdgeInfo); |
| XPolygon aXP(ImpCalcEdgeTrack(*pEdgeTrack, aMyCon1, aMyCon2, &aInfo)); |
| |
| if(aXP.GetPointCount()) |
| { |
| aResult = aXP.getB2DPolygon(); |
| } |
| } |
| else |
| { |
| Point aPt1((*pEdgeTrack)[0]); |
| Point aPt2((*pEdgeTrack)[sal_uInt16(pEdgeTrack->GetPointCount() - 1)]); |
| |
| if (aCon1.pObj && (aCon1.bBestConn || aCon1.bBestVertex)) |
| aPt1 = aCon1.pObj->GetSnapRect().Center(); |
| |
| if (aCon2.pObj && (aCon2.bBestConn || aCon2.bBestVertex)) |
| aPt2 = aCon2.pObj->GetSnapRect().Center(); |
| |
| if (bTail1) |
| { |
| const basegfx::B2DPoint aTemp(rDragMethod.getCurrentTransformation() * basegfx::B2DPoint(aPt1.X(), aPt1.Y())); |
| aPt1.X() = basegfx::fround(aTemp.getX()); |
| aPt1.Y() = basegfx::fround(aTemp.getY()); |
| } |
| |
| if (bTail2) |
| { |
| const basegfx::B2DPoint aTemp(rDragMethod.getCurrentTransformation() * basegfx::B2DPoint(aPt2.X(), aPt2.Y())); |
| aPt2.X() = basegfx::fround(aTemp.getX()); |
| aPt2.Y() = basegfx::fround(aTemp.getY()); |
| } |
| |
| aResult.append(basegfx::B2DPoint(aPt1.X(), aPt1.Y())); |
| aResult.append(basegfx::B2DPoint(aPt2.X(), aPt2.Y())); |
| } |
| |
| return aResult; |
| } |
| |
| FASTBOOL SdrEdgeObj::BegCreate(SdrDragStat& rDragStat) |
| { |
| rDragStat.SetNoSnap(sal_True); |
| pEdgeTrack->SetPointCount(2); |
| (*pEdgeTrack)[0]=rDragStat.GetStart(); |
| (*pEdgeTrack)[1]=rDragStat.GetNow(); |
| if (rDragStat.GetPageView()!=NULL) { |
| ImpFindConnector(rDragStat.GetStart(),*rDragStat.GetPageView(),aCon1,this); |
| ConnectToNode(sal_True,aCon1.pObj); |
| } |
| *pEdgeTrack=ImpCalcEdgeTrack(*pEdgeTrack,aCon1,aCon2,&aEdgeInfo); |
| return sal_True; |
| } |
| |
| FASTBOOL SdrEdgeObj::MovCreate(SdrDragStat& rDragStat) |
| { |
| sal_uInt16 nMax=pEdgeTrack->GetPointCount(); |
| (*pEdgeTrack)[nMax-1]=rDragStat.GetNow(); |
| if (rDragStat.GetPageView()!=NULL) { |
| ImpFindConnector(rDragStat.GetNow(),*rDragStat.GetPageView(),aCon2,this); |
| rDragStat.GetView()->SetConnectMarker(aCon2,*rDragStat.GetPageView()); |
| } |
| SetBoundRectDirty(); |
| bSnapRectDirty=sal_True; |
| ConnectToNode(sal_False,aCon2.pObj); |
| *pEdgeTrack=ImpCalcEdgeTrack(*pEdgeTrack,aCon1,aCon2,&aEdgeInfo); |
| bEdgeTrackDirty=sal_False; |
| return sal_True; |
| } |
| |
| FASTBOOL SdrEdgeObj::EndCreate(SdrDragStat& rDragStat, SdrCreateCmd eCmd) |
| { |
| FASTBOOL bOk=(eCmd==SDRCREATE_FORCEEND || rDragStat.GetPointAnz()>=2); |
| if (bOk) { |
| ConnectToNode(sal_True,aCon1.pObj); |
| ConnectToNode(sal_False,aCon2.pObj); |
| if (rDragStat.GetView()!=NULL) { |
| rDragStat.GetView()->HideConnectMarker(); |
| } |
| ImpSetEdgeInfoToAttr(); // Die Werte aus aEdgeInfo in den Pool kopieren |
| } |
| SetRectsDirty(); |
| return bOk; |
| } |
| |
| FASTBOOL SdrEdgeObj::BckCreate(SdrDragStat& rDragStat) |
| { |
| if (rDragStat.GetView()!=NULL) { |
| rDragStat.GetView()->HideConnectMarker(); |
| } |
| return sal_False; |
| } |
| |
| void SdrEdgeObj::BrkCreate(SdrDragStat& rDragStat) |
| { |
| if (rDragStat.GetView()!=NULL) { |
| rDragStat.GetView()->HideConnectMarker(); |
| } |
| } |
| |
| basegfx::B2DPolyPolygon SdrEdgeObj::TakeCreatePoly(const SdrDragStat& /*rStatDrag*/) const |
| { |
| basegfx::B2DPolyPolygon aRetval; |
| aRetval.append(pEdgeTrack->getB2DPolygon()); |
| return aRetval; |
| } |
| |
| Pointer SdrEdgeObj::GetCreatePointer() const |
| { |
| return Pointer(POINTER_DRAW_CONNECT); |
| } |
| |
| FASTBOOL SdrEdgeObj::ImpFindConnector(const Point& rPt, const SdrPageView& rPV, SdrObjConnection& rCon, const SdrEdgeObj* pThis, OutputDevice* pOut) |
| { |
| rCon.ResetVars(); |
| if (pOut==NULL) pOut=rPV.GetView().GetFirstOutputDevice(); // GetWin(0); |
| if (pOut==NULL) return sal_False; |
| SdrObjList* pOL=rPV.GetObjList(); |
| const SetOfByte& rVisLayer=rPV.GetVisibleLayers(); |
| // Sensitiver Bereich der Konnektoren ist doppelt so gross wie die Handles: |
| sal_uInt16 nMarkHdSiz=rPV.GetView().GetMarkHdlSizePixel(); |
| Size aHalfConSiz(nMarkHdSiz,nMarkHdSiz); |
| aHalfConSiz=pOut->PixelToLogic(aHalfConSiz); |
| Size aHalfCenterSiz(2*aHalfConSiz.Width(),2*aHalfConSiz.Height()); |
| Rectangle aMouseRect(rPt,rPt); |
| aMouseRect.Left() -=aHalfConSiz.Width(); |
| aMouseRect.Top() -=aHalfConSiz.Height(); |
| aMouseRect.Right() +=aHalfConSiz.Width(); |
| aMouseRect.Bottom()+=aHalfConSiz.Height(); |
| sal_uInt16 nBoundHitTol=(sal_uInt16)aHalfConSiz.Width()/2; if (nBoundHitTol==0) nBoundHitTol=1; |
| sal_uIntPtr no=pOL->GetObjCount(); |
| FASTBOOL bFnd=sal_False; |
| SdrObjConnection aTestCon; |
| SdrObjConnection aBestCon; |
| FASTBOOL bTestBoundHit=sal_False; |
| //int bBestBoundHit=sal_False; |
| |
| while (no>0 && !bFnd) { |
| // Problem: Gruppenobjekt mit verschiedenen Layern liefert LayerID 0 !!!! |
| no--; |
| SdrObject* pObj=pOL->GetObj(no); |
| if (rVisLayer.IsSet(pObj->GetLayer()) && pObj->IsVisible() && // only visible objects |
| (pThis==NULL || pObj!=(SdrObject*)pThis) && // nicht an mich selbst connecten |
| pObj->IsNode()) |
| { |
| Rectangle aObjBound(pObj->GetCurrentBoundRect()); |
| if (aObjBound.IsOver(aMouseRect)) { |
| aTestCon.ResetVars(); |
| bTestBoundHit=sal_False; |
| FASTBOOL bEdge=HAS_BASE(SdrEdgeObj,pObj); // kein BestCon fuer Edge |
| // Die Userdefined Konnektoren haben absolute Prioritaet. |
| // Danach kommt Vertex, Corner und Mitte(Best) gleich priorisiert. |
| // Zum Schluss kommt noch ein HitTest aufs Obj. |
| const SdrGluePointList* pGPL=pObj->GetGluePointList(); |
| sal_uInt16 nConAnz=pGPL==NULL ? 0 : pGPL->GetCount(); |
| sal_uInt16 nGesAnz=nConAnz+9; |
| FASTBOOL bUserFnd=sal_False; |
| sal_uIntPtr nBestDist=0xFFFFFFFF; |
| for (sal_uInt16 i=0; i<nGesAnz; i++) |
| { |
| FASTBOOL bUser=i<nConAnz; |
| FASTBOOL bVertex=i>=nConAnz+0 && i<nConAnz+4; |
| FASTBOOL bCorner=i>=nConAnz+4 && i<nConAnz+8; |
| FASTBOOL bCenter=i==nConAnz+8; |
| FASTBOOL bOk=sal_False; |
| Point aConPos; |
| sal_uInt16 nConNum=i; |
| if (bUser) { |
| const SdrGluePoint& rGP=(*pGPL)[nConNum]; |
| aConPos=rGP.GetAbsolutePos(*pObj); |
| nConNum=rGP.GetId(); |
| bOk=sal_True; |
| } else if (bVertex && !bUserFnd) { |
| nConNum=nConNum-nConAnz; |
| if (rPV.GetView().IsAutoVertexConnectors()) { |
| SdrGluePoint aPt(pObj->GetVertexGluePoint(nConNum)); |
| aConPos=aPt.GetAbsolutePos(*pObj); |
| bOk=sal_True; |
| } else i+=3; |
| } else if (bCorner && !bUserFnd) { |
| nConNum-=nConAnz+4; |
| if (rPV.GetView().IsAutoCornerConnectors()) { |
| SdrGluePoint aPt(pObj->GetCornerGluePoint(nConNum)); |
| aConPos=aPt.GetAbsolutePos(*pObj); |
| bOk=sal_True; |
| } else i+=3; |
| } |
| else if (bCenter && !bUserFnd && !bEdge) |
| { |
| // #109007# |
| // Suppress default connect at object center |
| if(!pThis || !pThis->GetSuppressDefaultConnect()) |
| { |
| // Edges nicht! |
| nConNum=0; |
| aConPos=aObjBound.Center(); |
| bOk=sal_True; |
| } |
| } |
| if (bOk && aMouseRect.IsInside(aConPos)) { |
| if (bUser) bUserFnd=sal_True; |
| bFnd=sal_True; |
| sal_uIntPtr nDist=(sal_uIntPtr)Abs(aConPos.X()-rPt.X())+(sal_uIntPtr)Abs(aConPos.Y()-rPt.Y()); |
| if (nDist<nBestDist) { |
| nBestDist=nDist; |
| aTestCon.pObj=pObj; |
| aTestCon.nConId=nConNum; |
| aTestCon.bAutoCorner=bCorner; |
| aTestCon.bAutoVertex=bVertex; |
| aTestCon.bBestConn=sal_False; // bCenter; |
| aTestCon.bBestVertex=bCenter; |
| } |
| } |
| } |
| // Falls kein Konnektor getroffen wird nochmal |
| // HitTest versucht fuer BestConnector (=bCenter) |
| if(!bFnd && |
| !bEdge && |
| SdrObjectPrimitiveHit(*pObj, rPt, nBoundHitTol, rPV, &rVisLayer, false)) |
| { |
| // #109007# |
| // Suppress default connect at object inside bound |
| if(!pThis || !pThis->GetSuppressDefaultConnect()) |
| { |
| bFnd=sal_True; |
| aTestCon.pObj=pObj; |
| aTestCon.bBestConn=sal_True; |
| } |
| } |
| if (bFnd) { |
| Rectangle aMouseRect2(rPt,rPt); |
| aMouseRect.Left() -=nBoundHitTol; |
| aMouseRect.Top() -=nBoundHitTol; |
| aMouseRect.Right() +=nBoundHitTol; |
| aMouseRect.Bottom()+=nBoundHitTol; |
| bTestBoundHit=aObjBound.IsOver(aMouseRect2); |
| } |
| |
| } |
| } |
| } |
| rCon=aTestCon; |
| return bFnd; |
| } |
| |
| void SdrEdgeObj::NbcSetSnapRect(const Rectangle& rRect) |
| { |
| const Rectangle aOld(GetSnapRect()); |
| |
| if(aOld != rRect) |
| { |
| if(aRect.IsEmpty() && 0 == pEdgeTrack->GetPointCount()) |
| { |
| // #i110629# When initializing, do not scale on empty Rectangle; this |
| // will mirror the underlying text object (!) |
| aRect = rRect; |
| maSnapRect = rRect; |
| } |
| else |
| { |
| long nMulX = rRect.Right() - rRect.Left(); |
| long nDivX = aOld.Right() - aOld.Left(); |
| long nMulY = rRect.Bottom() - rRect.Top(); |
| long nDivY = aOld.Bottom() - aOld.Top(); |
| if ( nDivX == 0 ) { nMulX = 1; nDivX = 1; } |
| if ( nDivY == 0 ) { nMulY = 1; nDivY = 1; } |
| Fraction aX(nMulX, nDivX); |
| Fraction aY(nMulY, nDivY); |
| NbcResize(aOld.TopLeft(), aX, aY); |
| NbcMove(Size(rRect.Left() - aOld.Left(), rRect.Top() - aOld.Top())); |
| } |
| } |
| } |
| |
| void SdrEdgeObj::NbcMove(const Size& rSiz) |
| { |
| SdrTextObj::NbcMove(rSiz); |
| MoveXPoly(*pEdgeTrack,rSiz); |
| } |
| |
| void SdrEdgeObj::NbcResize(const Point& rRefPnt, const Fraction& aXFact, const Fraction& aYFact) |
| { |
| SdrTextObj::NbcResize(rRefPnt,aXFact,aXFact); |
| ResizeXPoly(*pEdgeTrack,rRefPnt,aXFact,aYFact); |
| |
| // #75371# if resize is not from paste, forget user distances |
| if(!GetModel()->IsPasteResize()) |
| { |
| // #75735# |
| aEdgeInfo.aObj1Line2 = Point(); |
| aEdgeInfo.aObj1Line3 = Point(); |
| aEdgeInfo.aObj2Line2 = Point(); |
| aEdgeInfo.aObj2Line3 = Point(); |
| aEdgeInfo.aMiddleLine = Point(); |
| } |
| } |
| |
| // #54102# added rotation support |
| void SdrEdgeObj::NbcRotate(const Point& rRef, long nWink, double sn, double cs) |
| { |
| if(bEdgeTrackUserDefined) |
| { |
| // #120437# special handling when track is imported, apply |
| // transformation directly to imported track. |
| SdrTextObj::NbcRotate(rRef, nWink, sn, cs); |
| RotateXPoly(*pEdgeTrack, rRef, sn, cs); |
| } |
| else |
| { |
| // handle start and end point if not connected |
| FASTBOOL bCon1=aCon1.pObj!=NULL && aCon1.pObj->GetPage()==pPage; |
| FASTBOOL bCon2=aCon2.pObj!=NULL && aCon2.pObj->GetPage()==pPage; |
| |
| if(!bCon1 && pEdgeTrack) |
| { |
| RotatePoint((*pEdgeTrack)[0],rRef,sn,cs); |
| ImpDirtyEdgeTrack(); |
| } |
| |
| if(!bCon2 && pEdgeTrack) |
| { |
| sal_uInt16 nPntAnz = pEdgeTrack->GetPointCount(); |
| RotatePoint((*pEdgeTrack)[sal_uInt16(nPntAnz-1)],rRef,sn,cs); |
| ImpDirtyEdgeTrack(); |
| } |
| } |
| } |
| |
| // #54102# added mirror support |
| void SdrEdgeObj::NbcMirror(const Point& rRef1, const Point& rRef2) |
| { |
| if(bEdgeTrackUserDefined) |
| { |
| // #120437# special handling when track is imported, apply |
| // transformation directly to imported track. |
| SdrTextObj::NbcMirror(rRef1, rRef2); |
| MirrorXPoly(*pEdgeTrack, rRef1, rRef2); |
| } |
| else |
| { |
| // handle start and end point if not connected |
| FASTBOOL bCon1=aCon1.pObj!=NULL && aCon1.pObj->GetPage()==pPage; |
| FASTBOOL bCon2=aCon2.pObj!=NULL && aCon2.pObj->GetPage()==pPage; |
| |
| if(!bCon1 && pEdgeTrack) |
| { |
| MirrorPoint((*pEdgeTrack)[0],rRef1,rRef2); |
| ImpDirtyEdgeTrack(); |
| } |
| |
| if(!bCon2 && pEdgeTrack) |
| { |
| sal_uInt16 nPntAnz = pEdgeTrack->GetPointCount(); |
| MirrorPoint((*pEdgeTrack)[sal_uInt16(nPntAnz-1)],rRef1,rRef2); |
| ImpDirtyEdgeTrack(); |
| } |
| } |
| } |
| |
| // #54102# added shear support |
| void SdrEdgeObj::NbcShear(const Point& rRef, long nWink, double tn, FASTBOOL bVShear) |
| { |
| if(bEdgeTrackUserDefined) |
| { |
| // #120437# special handling when track is imported, apply |
| // transformation directly to imported track. |
| SdrTextObj::NbcShear(rRef, nWink, tn, bVShear); |
| ShearXPoly(*pEdgeTrack, rRef, tn, bVShear); |
| } |
| else |
| { |
| // handle start and end point if not connected |
| FASTBOOL bCon1=aCon1.pObj!=NULL && aCon1.pObj->GetPage()==pPage; |
| FASTBOOL bCon2=aCon2.pObj!=NULL && aCon2.pObj->GetPage()==pPage; |
| |
| if(!bCon1 && pEdgeTrack) |
| { |
| ShearPoint((*pEdgeTrack)[0],rRef,tn,bVShear); |
| ImpDirtyEdgeTrack(); |
| } |
| |
| if(!bCon2 && pEdgeTrack) |
| { |
| sal_uInt16 nPntAnz = pEdgeTrack->GetPointCount(); |
| ShearPoint((*pEdgeTrack)[sal_uInt16(nPntAnz-1)],rRef,tn,bVShear); |
| ImpDirtyEdgeTrack(); |
| } |
| } |
| } |
| |
| SdrObject* SdrEdgeObj::DoConvertToPolyObj(sal_Bool bBezier, bool bAddText) const |
| { |
| basegfx::B2DPolyPolygon aPolyPolygon; |
| aPolyPolygon.append(pEdgeTrack->getB2DPolygon()); |
| SdrObject* pRet = ImpConvertMakeObj(aPolyPolygon, sal_False, bBezier); |
| |
| if(bAddText) |
| { |
| pRet = ImpConvertAddText(pRet, bBezier); |
| } |
| |
| return pRet; |
| } |
| |
| sal_uInt32 SdrEdgeObj::GetSnapPointCount() const |
| { |
| return 2L; |
| } |
| |
| Point SdrEdgeObj::GetSnapPoint(sal_uInt32 i) const |
| { |
| ((SdrEdgeObj*)this)->ImpUndirtyEdgeTrack(); |
| sal_uInt16 nAnz=pEdgeTrack->GetPointCount(); |
| if (i==0) return (*pEdgeTrack)[0]; |
| else return (*pEdgeTrack)[nAnz-1]; |
| } |
| |
| sal_Bool SdrEdgeObj::IsPolyObj() const |
| { |
| return sal_False; |
| } |
| |
| sal_uInt32 SdrEdgeObj::GetPointCount() const |
| { |
| return 0L; |
| } |
| |
| Point SdrEdgeObj::GetPoint(sal_uInt32 i) const |
| { |
| ((SdrEdgeObj*)this)->ImpUndirtyEdgeTrack(); |
| sal_uInt16 nAnz=pEdgeTrack->GetPointCount(); |
| if (0L == i) |
| return (*pEdgeTrack)[0]; |
| else |
| return (*pEdgeTrack)[nAnz-1]; |
| } |
| |
| void SdrEdgeObj::NbcSetPoint(const Point& rPnt, sal_uInt32 i) |
| { |
| // ToDo: Umconnekten fehlt noch |
| ImpUndirtyEdgeTrack(); |
| sal_uInt16 nAnz=pEdgeTrack->GetPointCount(); |
| if (0L == i) |
| (*pEdgeTrack)[0]=rPnt; |
| if (1L == i) |
| (*pEdgeTrack)[nAnz-1]=rPnt; |
| SetEdgeTrackDirty(); |
| SetRectsDirty(); |
| } |
| |
| SdrEdgeObjGeoData::SdrEdgeObjGeoData() |
| { |
| pEdgeTrack=new XPolygon; |
| } |
| |
| SdrEdgeObjGeoData::~SdrEdgeObjGeoData() |
| { |
| delete pEdgeTrack; |
| } |
| |
| SdrObjGeoData* SdrEdgeObj::NewGeoData() const |
| { |
| return new SdrEdgeObjGeoData; |
| } |
| |
| void SdrEdgeObj::SaveGeoData(SdrObjGeoData& rGeo) const |
| { |
| SdrTextObj::SaveGeoData(rGeo); |
| SdrEdgeObjGeoData& rEGeo=(SdrEdgeObjGeoData&)rGeo; |
| rEGeo.aCon1 =aCon1; |
| rEGeo.aCon2 =aCon2; |
| *rEGeo.pEdgeTrack =*pEdgeTrack; |
| rEGeo.bEdgeTrackDirty=bEdgeTrackDirty; |
| rEGeo.bEdgeTrackUserDefined=bEdgeTrackUserDefined; |
| rEGeo.aEdgeInfo =aEdgeInfo; |
| } |
| |
| void SdrEdgeObj::RestGeoData(const SdrObjGeoData& rGeo) |
| { |
| SdrTextObj::RestGeoData(rGeo); |
| SdrEdgeObjGeoData& rEGeo=(SdrEdgeObjGeoData&)rGeo; |
| if (aCon1.pObj!=rEGeo.aCon1.pObj) { |
| if (aCon1.pObj!=NULL) aCon1.pObj->RemoveListener(*this); |
| aCon1=rEGeo.aCon1; |
| if (aCon1.pObj!=NULL) aCon1.pObj->AddListener(*this); |
| } |
| if (aCon2.pObj!=rEGeo.aCon2.pObj) { |
| if (aCon2.pObj!=NULL) aCon2.pObj->RemoveListener(*this); |
| aCon2=rEGeo.aCon2; |
| if (aCon2.pObj!=NULL) aCon2.pObj->AddListener(*this); |
| } |
| *pEdgeTrack =*rEGeo.pEdgeTrack; |
| bEdgeTrackDirty=rEGeo.bEdgeTrackDirty; |
| bEdgeTrackUserDefined=rEGeo.bEdgeTrackUserDefined; |
| aEdgeInfo =rEGeo.aEdgeInfo; |
| } |
| |
| Point SdrEdgeObj::GetTailPoint( sal_Bool bTail ) const |
| { |
| if( pEdgeTrack && pEdgeTrack->GetPointCount()!=0) |
| { |
| const XPolygon& rTrack0 = *pEdgeTrack; |
| if(bTail) |
| { |
| return rTrack0[0]; |
| } |
| else |
| { |
| const sal_uInt16 nSiz = rTrack0.GetPointCount() - 1; |
| return rTrack0[nSiz]; |
| } |
| } |
| else |
| { |
| if(bTail) |
| return aOutRect.TopLeft(); |
| else |
| return aOutRect.BottomRight(); |
| } |
| |
| } |
| |
| void SdrEdgeObj::SetTailPoint( sal_Bool bTail, const Point& rPt ) |
| { |
| ImpSetTailPoint( bTail, rPt ); |
| SetChanged(); |
| } |
| |
| /** this method is used by the api to set a glue point for a connection |
| nId == -1 : The best default point is automatically chosen |
| 0 <= nId <= 3 : One of the default points is chosen |
| nId >= 4 : A user defined glue point is chosen |
| */ |
| void SdrEdgeObj::setGluePointIndex( sal_Bool bTail, sal_Int32 nIndex /* = -1 */ ) |
| { |
| Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetCurrentBoundRect(); |
| // #110094#-14 BroadcastObjectChange(); |
| |
| SdrObjConnection& rConn1 = GetConnection( bTail ); |
| |
| rConn1.SetAutoVertex( nIndex >= 0 && nIndex <= 3 ); |
| rConn1.SetBestConnection( nIndex < 0 ); |
| rConn1.SetBestVertex( nIndex < 0 ); |
| |
| if( nIndex > 3 ) |
| { |
| // nIndex -= 4; |
| nIndex -= 3; // SJ: the start api index is 0, whereas the implementation in svx starts from 1 |
| |
| // for user defined glue points we have |
| // to get the id for this index first |
| const SdrGluePointList* pList = rConn1.GetObject() ? rConn1.GetObject()->GetGluePointList() : NULL; |
| if( pList == NULL || SDRGLUEPOINT_NOTFOUND == pList->FindGluePoint((sal_uInt16)nIndex) ) |
| return; |
| } |
| else if( nIndex < 0 ) |
| { |
| nIndex = 0; |
| } |
| |
| rConn1.SetConnectorId( (sal_uInt16)nIndex ); |
| |
| SetChanged(); |
| SetRectsDirty(); |
| ImpRecalcEdgeTrack(); |
| // bEdgeTrackDirty=sal_True; |
| } |
| |
| /** this method is used by the api to return a glue point id for a connection. |
| See setGluePointId for possible return values */ |
| sal_Int32 SdrEdgeObj::getGluePointIndex( sal_Bool bTail ) |
| { |
| SdrObjConnection& rConn1 = GetConnection( bTail ); |
| sal_Int32 nId = -1; |
| if( !rConn1.IsBestConnection() ) |
| { |
| nId = rConn1.GetConnectorId(); |
| if( !rConn1.IsAutoVertex() ) |
| // nId += 4; |
| nId += 3; // SJ: the start api index is 0, whereas the implementation in svx starts from 1 |
| } |
| return nId; |
| } |
| |
| // #102344# Implementation was missing; edge track needs to be invalidated additionally. |
| void SdrEdgeObj::NbcSetAnchorPos(const Point& rPnt) |
| { |
| // call parent functionality |
| SdrTextObj::NbcSetAnchorPos(rPnt); |
| |
| // Additionally, invalidate edge track |
| ImpDirtyEdgeTrack(); |
| } |
| |
| sal_Bool SdrEdgeObj::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& rPolyPolygon) const |
| { |
| // use base method from SdrObject, it's not rotatable and |
| // a call to GetSnapRect() is used. That's what we need for Connector. |
| return SdrObject::TRGetBaseGeometry(rMatrix, rPolyPolygon); |
| } |
| |
| void SdrEdgeObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& rPolyPolygon) |
| { |
| // evtl. take care for existing connections. For now, just use the |
| // implementation from SdrObject. |
| SdrObject::TRSetBaseGeometry(rMatrix, rPolyPolygon); |
| } |
| |
| // for geometry access |
| ::basegfx::B2DPolygon SdrEdgeObj::getEdgeTrack() const |
| { |
| if(bEdgeTrackDirty) |
| { |
| const_cast< SdrEdgeObj* >(this)->ImpRecalcEdgeTrack(); |
| } |
| |
| if(pEdgeTrack) |
| { |
| return pEdgeTrack->getB2DPolygon(); |
| } |
| else |
| { |
| return ::basegfx::B2DPolygon(); |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // eof |