| /************************************************************** |
| * |
| * 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/svdpoev.hxx> |
| #include <math.h> |
| #include <svx/svdpagv.hxx> |
| #include <svx/svdpage.hxx> |
| #include <svx/svdopath.hxx> |
| #include <svx/svdundo.hxx> |
| #include "svx/svdstr.hrc" // Namen aus der Resource |
| #include "svx/svdglob.hxx" // StringCache |
| #include <svx/svdtrans.hxx> |
| #include <basegfx/polygon/b2dpolygon.hxx> |
| #include <basegfx/polygon/b2dpolygontools.hxx> |
| #include <vcl/salbtype.hxx> // FRound |
| |
| #include <svx/polypolygoneditor.hxx> |
| |
| using namespace sdr; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void SdrPolyEditView::ImpResetPolyPossibilityFlags() |
| { |
| eMarkedPointsSmooth=SDRPATHSMOOTH_DONTCARE; |
| eMarkedSegmentsKind=SDRPATHSEGMENT_DONTCARE; |
| bSetMarkedPointsSmoothPossible=sal_False; |
| bSetMarkedSegmentsKindPossible=sal_False; |
| } |
| |
| void SdrPolyEditView::ImpClearVars() |
| { |
| ImpResetPolyPossibilityFlags(); |
| } |
| |
| SdrPolyEditView::SdrPolyEditView(SdrModel* pModel1, OutputDevice* pOut): |
| SdrEditView(pModel1,pOut) |
| { |
| ImpClearVars(); |
| } |
| |
| SdrPolyEditView::~SdrPolyEditView() |
| { |
| } |
| |
| void SdrPolyEditView::ImpCheckPolyPossibilities() |
| { |
| ImpResetPolyPossibilityFlags(); |
| const sal_uIntPtr nMarkAnz(GetMarkedObjectCount()); |
| |
| if(nMarkAnz && !ImpIsFrameHandles()) |
| { |
| bool b1stSmooth(true); |
| bool b1stSegm(true); |
| bool bCurve(false); |
| bool bSmoothFuz(false); |
| bool bSegmFuz(false); |
| basegfx::B2VectorContinuity eSmooth = basegfx::CONTINUITY_NONE; |
| |
| for(sal_uIntPtr nMarkNum(0L); nMarkNum < nMarkAnz; nMarkNum++) |
| { |
| SdrMark* pM = GetSdrMarkByIndex(nMarkNum); |
| CheckPolyPossibilitiesHelper( pM, b1stSmooth, b1stSegm, bCurve, bSmoothFuz, bSegmFuz, eSmooth ); |
| } |
| } |
| } |
| |
| void SdrPolyEditView::CheckPolyPossibilitiesHelper( SdrMark* pM, bool& b1stSmooth, bool& b1stSegm, bool& bCurve, bool& bSmoothFuz, bool& bSegmFuz, basegfx::B2VectorContinuity& eSmooth ) |
| { |
| SdrObject* pObj = pM->GetMarkedSdrObj(); |
| SdrUShortCont* pPts = pM->GetMarkedPoints(); |
| SdrPathObj* pPath = PTR_CAST(SdrPathObj,pObj); |
| |
| if(pPath && pPts) |
| { |
| const sal_uInt32 nMarkedPntAnz(pPts->GetCount()); |
| |
| if(nMarkedPntAnz) |
| { |
| bool bClosed(pPath->IsClosed()); |
| bSetMarkedPointsSmoothPossible = true; |
| |
| if(bClosed) |
| { |
| bSetMarkedSegmentsKindPossible = true; |
| } |
| |
| for(sal_uInt32 nMarkedPntNum(0L); nMarkedPntNum < nMarkedPntAnz; nMarkedPntNum++) |
| { |
| sal_uInt32 nNum(pPts->GetObject(nMarkedPntNum)); |
| sal_uInt32 nPolyNum, nPntNum; |
| |
| if(PolyPolygonEditor::GetRelativePolyPoint(pPath->GetPathPoly(), nNum, nPolyNum, nPntNum)) |
| { |
| const basegfx::B2DPolygon aLocalPolygon(pPath->GetPathPoly().getB2DPolygon(nPolyNum)); |
| bool bCanSegment(bClosed || nPntNum < aLocalPolygon.count() - 1L); |
| |
| if(!bSetMarkedSegmentsKindPossible && bCanSegment) |
| { |
| bSetMarkedSegmentsKindPossible = true; |
| } |
| |
| if(!bSmoothFuz) |
| { |
| if (b1stSmooth) |
| { |
| b1stSmooth = false; |
| eSmooth = basegfx::tools::getContinuityInPoint(aLocalPolygon, nPntNum); |
| } |
| else |
| { |
| bSmoothFuz = (eSmooth != basegfx::tools::getContinuityInPoint(aLocalPolygon, nPntNum)); |
| } |
| } |
| |
| if(!bSegmFuz) |
| { |
| if(bCanSegment) |
| { |
| bool bCrv(aLocalPolygon.isNextControlPointUsed(nPntNum)); |
| |
| if(b1stSegm) |
| { |
| b1stSegm = false; |
| bCurve = bCrv; |
| } |
| else |
| { |
| bSegmFuz = (bCrv != bCurve); |
| } |
| } |
| } |
| } |
| } |
| |
| if(!b1stSmooth && !bSmoothFuz) |
| { |
| if(basegfx::CONTINUITY_NONE == eSmooth) |
| { |
| eMarkedPointsSmooth = SDRPATHSMOOTH_ANGULAR; |
| } |
| |
| if(basegfx::CONTINUITY_C1 == eSmooth) |
| { |
| eMarkedPointsSmooth = SDRPATHSMOOTH_ASYMMETRIC; |
| } |
| |
| if(basegfx::CONTINUITY_C2 == eSmooth) |
| { |
| eMarkedPointsSmooth = SDRPATHSMOOTH_SYMMETRIC; |
| } |
| } |
| |
| if(!b1stSegm && !bSegmFuz) |
| { |
| eMarkedSegmentsKind = (bCurve) ? SDRPATHSEGMENT_CURVE : SDRPATHSEGMENT_LINE; |
| } |
| } |
| } |
| } |
| |
| void SdrPolyEditView::SetMarkedPointsSmooth(SdrPathSmoothKind eKind) |
| { |
| basegfx::B2VectorContinuity eFlags; |
| |
| if(SDRPATHSMOOTH_ANGULAR == eKind) |
| { |
| eFlags = basegfx::CONTINUITY_NONE; |
| } |
| else if(SDRPATHSMOOTH_ASYMMETRIC == eKind) |
| { |
| eFlags = basegfx::CONTINUITY_C1; |
| } |
| else if(SDRPATHSMOOTH_SYMMETRIC == eKind) |
| { |
| eFlags = basegfx::CONTINUITY_C2; |
| } |
| else |
| { |
| return; |
| } |
| |
| if(HasMarkedPoints()) |
| { |
| SortMarkedObjects(); |
| |
| const bool bUndo = IsUndoEnabled(); |
| if( bUndo ) |
| BegUndo(ImpGetResStr(STR_EditSetPointsSmooth), GetDescriptionOfMarkedPoints()); |
| sal_uIntPtr nMarkAnz(GetMarkedObjectCount()); |
| |
| for(sal_uIntPtr nMarkNum(nMarkAnz); nMarkNum > 0L;) |
| { |
| nMarkNum--; |
| SdrMark* pM = GetSdrMarkByIndex(nMarkNum); |
| SdrUShortCont* pPts = pM->GetMarkedPoints(); |
| SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() ); |
| |
| if(pPts && pPath) |
| { |
| PolyPolygonEditor aEditor( pPath->GetPathPoly(), pPath->IsClosed() ); |
| if(aEditor.SetPointsSmooth( eFlags, pPts->getContainer() ) ) |
| { |
| if( bUndo ) |
| AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPath)); |
| pPath->SetPathPoly(aEditor.GetPolyPolygon()); |
| } |
| } |
| } |
| |
| if( bUndo ) |
| EndUndo(); |
| } |
| } |
| |
| void SdrPolyEditView::SetMarkedSegmentsKind(SdrPathSegmentKind eKind) |
| { |
| if(HasMarkedPoints()) |
| { |
| SortMarkedObjects(); |
| |
| const bool bUndo = IsUndoEnabled(); |
| if( bUndo ) |
| BegUndo(ImpGetResStr(STR_EditSetSegmentsKind), GetDescriptionOfMarkedPoints()); |
| sal_uIntPtr nMarkAnz(GetMarkedObjectCount()); |
| |
| for(sal_uIntPtr nMarkNum(nMarkAnz); nMarkNum > 0L;) |
| { |
| nMarkNum--; |
| SdrMark* pM = GetSdrMarkByIndex(nMarkNum); |
| SdrUShortCont* pPts = pM->GetMarkedPoints(); |
| SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() ); |
| |
| if(pPts && pPath) |
| { |
| PolyPolygonEditor aEditor( pPath->GetPathPoly(), pPath->IsClosed() ); |
| if(aEditor.SetSegmentsKind( eKind, pPts->getContainer()) ) |
| { |
| if( bUndo ) |
| AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPath)); |
| pPath->SetPathPoly(aEditor.GetPolyPolygon()); |
| } |
| } |
| } |
| |
| if( bUndo ) |
| EndUndo(); |
| } |
| } |
| |
| sal_Bool SdrPolyEditView::IsSetMarkedPointsSmoothPossible() const |
| { |
| ForcePossibilities(); |
| return bSetMarkedPointsSmoothPossible; |
| } |
| |
| SdrPathSmoothKind SdrPolyEditView::GetMarkedPointsSmooth() const |
| { |
| ForcePossibilities(); |
| return eMarkedPointsSmooth; |
| } |
| |
| sal_Bool SdrPolyEditView::IsSetMarkedSegmentsKindPossible() const |
| { |
| ForcePossibilities(); |
| return bSetMarkedSegmentsKindPossible; |
| } |
| |
| SdrPathSegmentKind SdrPolyEditView::GetMarkedSegmentsKind() const |
| { |
| ForcePossibilities(); |
| return eMarkedSegmentsKind; |
| } |
| |
| sal_Bool SdrPolyEditView::IsDeleteMarkedPointsPossible() const |
| { |
| return HasMarkedPoints(); |
| } |
| |
| void SdrPolyEditView::DeleteMarkedPoints() |
| { |
| if (HasMarkedPoints()) |
| { |
| BrkAction(); |
| SortMarkedObjects(); |
| sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); |
| |
| const bool bUndo = IsUndoEnabled(); |
| if( bUndo ) |
| { |
| // Description |
| BegUndo(ImpGetResStr(STR_EditDelete),GetDescriptionOfMarkedPoints(),SDRREPFUNC_OBJ_DELETE); |
| } |
| |
| for (sal_uIntPtr nMarkNum=nMarkAnz; nMarkNum>0;) |
| { |
| nMarkNum--; |
| SdrMark* pM=GetSdrMarkByIndex(nMarkNum); |
| SdrUShortCont* pPts=pM->GetMarkedPoints(); |
| SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() ); |
| |
| if( pPath && pPts ) |
| { |
| PolyPolygonEditor aEditor( pPath ->GetPathPoly(), pPath->IsClosed() ); |
| if( aEditor.DeletePoints( pPts->getContainer() ) ) |
| { |
| if( aEditor.GetPolyPolygon().count() ) |
| { |
| if( bUndo ) |
| AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPath )); |
| pPath->SetPathPoly( aEditor.GetPolyPolygon() ); |
| } |
| else |
| { |
| if( bUndo ) |
| AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pPath ) ); |
| pM->GetPageView()->GetObjList()->RemoveObject(pPath->GetOrdNum()); |
| if( !bUndo ) |
| { |
| SdrObject* pObj = pPath; |
| SdrObject::Free(pObj); |
| } |
| } |
| } |
| } |
| } |
| |
| if( bUndo ) |
| EndUndo(); |
| UnmarkAllPoints(); |
| MarkListHasChanged(); |
| } |
| } |
| |
| void SdrPolyEditView::RipUpAtMarkedPoints() |
| { |
| if(HasMarkedPoints()) |
| { |
| SortMarkedObjects(); |
| sal_uInt32 nMarkAnz(GetMarkedObjectCount()); |
| |
| const bool bUndo = IsUndoEnabled(); |
| if( bUndo ) |
| BegUndo(ImpGetResStr(STR_EditRipUp), GetDescriptionOfMarkedPoints()); |
| |
| for(sal_uInt32 nMarkNum(nMarkAnz); nMarkNum > 0L;) |
| { |
| nMarkNum--; |
| SdrMark* pM = GetSdrMarkByIndex(nMarkNum); |
| SdrUShortCont* pPts = pM->GetMarkedPoints(); |
| SdrPathObj* pObj = PTR_CAST(SdrPathObj, pM->GetMarkedSdrObj()); |
| |
| if(pPts && pObj) |
| { |
| pPts->ForceSort(); |
| if( bUndo ) |
| AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); |
| sal_Bool bKorregFlag(sal_False); |
| sal_Bool bInsAny(sal_False); |
| sal_uInt32 nMarkPtsAnz(pPts->GetCount()); |
| sal_uInt32 nMax(pObj->GetHdlCount()); |
| |
| for(sal_uInt32 i(nMarkPtsAnz); i > 0L;) |
| { |
| i--; |
| sal_uInt32 nNewPt0Idx(0L); |
| SdrObject* pNeuObj = pObj->RipPoint(pPts->GetObject(i), nNewPt0Idx); |
| |
| if(pNeuObj) |
| { |
| bInsAny = sal_True; |
| SdrInsertReason aReason(SDRREASON_VIEWCALL, pObj); |
| pM->GetPageView()->GetObjList()->InsertObject(pNeuObj, pObj->GetOrdNum() + 1, &aReason); |
| if( bUndo ) |
| AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pNeuObj)); |
| MarkObj(pNeuObj, pM->GetPageView(), sal_False, sal_True); |
| } |
| |
| if(nNewPt0Idx) |
| { |
| // Korrektur notwendig? |
| DBG_ASSERT(bKorregFlag==sal_False,"Mehrfache Indexkorrektur bei SdrPolyEditView::RipUp()"); |
| if(!bKorregFlag) |
| { |
| bKorregFlag = sal_True; |
| |
| for(sal_uInt32 nBla(0L); nBla < nMarkPtsAnz; nBla++) |
| { |
| sal_uInt32 nPntNum(pPts->GetObject(nBla)); |
| nPntNum += nNewPt0Idx; |
| |
| if(nPntNum >= nMax) |
| { |
| nPntNum -= nMax; |
| } |
| |
| pPts->Replace((sal_uInt16)nPntNum, nBla); |
| } |
| |
| i = nMarkPtsAnz; // ... und nochmal von vorn |
| } |
| } |
| } |
| } |
| } |
| |
| UnmarkAllPoints(); |
| if( bUndo ) |
| EndUndo(); |
| MarkListHasChanged(); |
| } |
| } |
| |
| bool SdrPolyEditView::IsRipUpAtMarkedPointsPossible() const |
| { |
| bool bRetval(false); |
| const sal_uInt32 nMarkCount(GetMarkedObjectCount()); |
| |
| for(sal_uInt32 a(0); a < nMarkCount; a++) |
| { |
| const SdrMark* pMark = GetSdrMarkByIndex(a); |
| const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj()); |
| |
| if(pMarkedPathObject) |
| { |
| const SdrUShortCont* pSelectedPoints = pMark->GetMarkedPoints(); |
| |
| if(pSelectedPoints && pSelectedPoints->GetCount()) |
| { |
| const basegfx::B2DPolyPolygon& rPathPolyPolygon = pMarkedPathObject->GetPathPoly(); |
| |
| if(1 == rPathPolyPolygon.count()) |
| { |
| // #i76617# Do not yet use basegfx::B2DPolygon since curve definitions |
| // are different and methods need to be changed thoroughly with interaction rework |
| const Polygon aPathPolygon(rPathPolyPolygon.getB2DPolygon(0)); |
| const sal_uInt16 nPointCount(aPathPolygon.GetSize()); |
| |
| if(nPointCount >= 3) |
| { |
| bRetval = pMarkedPathObject->IsClosedObj(); // #i76617# aPathPolygon.isClosed(); |
| |
| for(sal_uInt32 b(0); !bRetval && b < pSelectedPoints->GetCount(); b++) |
| { |
| const sal_uInt16 nMarkedPointNum(pSelectedPoints->GetObject(b)); |
| |
| bRetval = (nMarkedPointNum > 0 && nMarkedPointNum < nPointCount - 1); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return bRetval; |
| } |
| |
| bool SdrPolyEditView::IsOpenCloseMarkedObjectsPossible() const |
| { |
| bool bRetval(false); |
| const sal_uInt32 nMarkCount(GetMarkedObjectCount()); |
| |
| for(sal_uInt32 a(0); a < nMarkCount; a++) |
| { |
| const SdrMark* pMark = GetSdrMarkByIndex(a); |
| const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj()); |
| |
| if(pMarkedPathObject) |
| { |
| // #i76617# Do not yet use basegfx::B2DPolygon since curve definitions |
| // are different and methods need to be changed thoroughly with interaction rework |
| const PolyPolygon aPathPolyPolygon(pMarkedPathObject->GetPathPoly()); |
| const sal_uInt16 nPolygonCount(aPathPolyPolygon.Count()); |
| |
| for(sal_uInt16 b(0); !bRetval && b < nPolygonCount; b++) |
| { |
| const Polygon& rPathPolygon = aPathPolyPolygon[b]; |
| const sal_uInt16 nPointCount(rPathPolygon.GetSize()); |
| |
| bRetval = (nPointCount >= 3); |
| } |
| } |
| } |
| |
| return bRetval; |
| } |
| |
| SdrObjClosedKind SdrPolyEditView::GetMarkedObjectsClosedState() const |
| { |
| bool bOpen(false); |
| bool bClosed(false); |
| const sal_uInt32 nMarkCount(GetMarkedObjectCount()); |
| |
| for(sal_uInt32 a(0); !(bOpen && bClosed) && a < nMarkCount; a++) |
| { |
| const SdrMark* pMark = GetSdrMarkByIndex(a); |
| const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj()); |
| |
| if(pMarkedPathObject) |
| { |
| if(pMarkedPathObject->IsClosedObj()) |
| { |
| bClosed = true; |
| } |
| else |
| { |
| bOpen = true; |
| } |
| } |
| } |
| |
| if(bOpen && bClosed) |
| { |
| return SDROBJCLOSED_DONTCARE; |
| } |
| else if(bOpen) |
| { |
| return SDROBJCLOSED_OPEN; |
| } |
| else |
| { |
| return SDROBJCLOSED_CLOSED; |
| } |
| } |
| |
| void SdrPolyEditView::ShutMarkedObjects() |
| { |
| CloseMarkedObjects(); |
| } |
| |
| void SdrPolyEditView::CloseMarkedObjects(sal_Bool bToggle, sal_Bool bOpen) // , long nOpenDistance) |
| { |
| if (AreObjectsMarked()) |
| { |
| const bool bUndo = IsUndoEnabled(); |
| if( bUndo ) |
| BegUndo(ImpGetResStr(STR_EditShut),GetDescriptionOfMarkedPoints()); |
| |
| bool bChg=false; |
| sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); |
| for (sal_uIntPtr nm=0; nm<nMarkAnz; nm++) |
| { |
| SdrMark* pM=GetSdrMarkByIndex(nm); |
| SdrObject* pO=pM->GetMarkedSdrObj(); |
| sal_Bool bClosed=pO->IsClosedObj(); |
| if (pO->IsPolyObj() && (bClosed==bOpen) || bToggle) |
| { |
| if( bUndo ) |
| AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO)); |
| |
| SdrPathObj* pPathObj = dynamic_cast< SdrPathObj* >( pO ); |
| if(pPathObj) |
| pPathObj->ToggleClosed(); |
| bChg=true; |
| } |
| } |
| |
| if( bUndo ) |
| EndUndo(); |
| |
| if (bChg) |
| { |
| UnmarkAllPoints(); |
| MarkListHasChanged(); |
| } |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void SdrPolyEditView::ImpCopyMarkedPoints() |
| { |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void SdrPolyEditView::ImpTransformMarkedPoints(PPolyTrFunc pTrFunc, const void* p1, const void* p2, const void* p3, const void* p4, const void* p5) |
| { |
| const bool bUndo = IsUndoEnabled(); |
| |
| sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); |
| for (sal_uIntPtr nm=0; nm<nMarkAnz; nm++) |
| { |
| SdrMark* pM=GetSdrMarkByIndex(nm); |
| SdrObject* pObj=pM->GetMarkedSdrObj(); |
| const SdrUShortCont* pPts=pM->GetMarkedPoints(); |
| sal_uIntPtr nPtAnz=pPts==NULL ? 0 : pPts->GetCount(); |
| SdrPathObj* pPath=PTR_CAST(SdrPathObj,pObj); |
| if (nPtAnz!=0 && pPath!=NULL) |
| { |
| if( bUndo ) |
| AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); |
| |
| basegfx::B2DPolyPolygon aXPP(pPath->GetPathPoly()); |
| |
| for(sal_uInt32 nPtNum(0L); nPtNum < nPtAnz; nPtNum++) |
| { |
| sal_uInt32 nPt(pPts->GetObject(nPtNum)); |
| sal_uInt32 nPolyNum, nPointNum; |
| |
| if(PolyPolygonEditor::GetRelativePolyPoint(aXPP, nPt, nPolyNum, nPointNum)) |
| { |
| //#i83671# used nLocalPointNum (which was the polygon point count) |
| // instead of the point index (nPointNum). This of course leaded |
| // to a wrong point access to the B2DPolygon. |
| basegfx::B2DPolygon aNewXP(aXPP.getB2DPolygon(nPolyNum)); |
| Point aPos, aC1, aC2; |
| bool bC1(false); |
| bool bC2(false); |
| |
| const basegfx::B2DPoint aB2DPos(aNewXP.getB2DPoint(nPointNum)); |
| aPos = Point(FRound(aB2DPos.getX()), FRound(aB2DPos.getY())); |
| |
| if(aNewXP.isPrevControlPointUsed(nPointNum)) |
| { |
| const basegfx::B2DPoint aB2DC1(aNewXP.getPrevControlPoint(nPointNum)); |
| aC1 = Point(FRound(aB2DC1.getX()), FRound(aB2DC1.getY())); |
| bC1 = true; |
| } |
| |
| if(aNewXP.isNextControlPointUsed(nPointNum)) |
| { |
| const basegfx::B2DPoint aB2DC2(aNewXP.getNextControlPoint(nPointNum)); |
| aC2 = Point(FRound(aB2DC2.getX()), FRound(aB2DC2.getY())); |
| bC2 = true; |
| } |
| |
| (*pTrFunc)(aPos,&aC1,&aC2,p1,p2,p3,p4,p5); |
| aNewXP.setB2DPoint(nPointNum, basegfx::B2DPoint(aPos.X(), aPos.Y())); |
| |
| if (bC1) |
| { |
| aNewXP.setPrevControlPoint(nPointNum, basegfx::B2DPoint(aC1.X(), aC1.Y())); |
| } |
| |
| if (bC2) |
| { |
| aNewXP.setNextControlPoint(nPointNum, basegfx::B2DPoint(aC2.X(), aC2.Y())); |
| } |
| |
| aXPP.setB2DPolygon(nPolyNum, aNewXP); |
| } |
| } |
| |
| pPath->SetPathPoly(aXPP); |
| } |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static void ImpMove(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* /*p2*/, const void* /*p3*/, const void* /*p4*/, const void* /*p5*/) |
| { |
| MovePoint(rPt,*(const Size*)p1); |
| if (pC1!=NULL) MovePoint(*pC1,*(const Size*)p1); |
| if (pC2!=NULL) MovePoint(*pC2,*(const Size*)p1); |
| } |
| |
| void SdrPolyEditView::MoveMarkedPoints(const Size& rSiz, bool bCopy) |
| { |
| bCopy=sal_False; // noch nicht implementiert |
| ForceUndirtyMrkPnt(); |
| XubString aStr(ImpGetResStr(STR_EditMove)); |
| if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy); |
| BegUndo(aStr,GetDescriptionOfMarkedPoints(),SDRREPFUNC_OBJ_MOVE); |
| if (bCopy) ImpCopyMarkedPoints(); |
| ImpTransformMarkedPoints(ImpMove,&rSiz); |
| EndUndo(); |
| AdjustMarkHdl(); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static void ImpResize(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* p2, const void* p3, const void* /*p4*/, const void* /*p5*/) |
| { |
| ResizePoint(rPt,*(const Point*)p1,*(const Fraction*)p2,*(const Fraction*)p3); |
| if (pC1!=NULL) ResizePoint(*pC1,*(const Point*)p1,*(const Fraction*)p2,*(const Fraction*)p3); |
| if (pC2!=NULL) ResizePoint(*pC2,*(const Point*)p1,*(const Fraction*)p2,*(const Fraction*)p3); |
| } |
| |
| void SdrPolyEditView::ResizeMarkedPoints(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bCopy) |
| { |
| bCopy=sal_False; // noch nicht implementiert |
| ForceUndirtyMrkPnt(); |
| XubString aStr(ImpGetResStr(STR_EditResize)); |
| if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy); |
| BegUndo(aStr,GetDescriptionOfMarkedPoints(),SDRREPFUNC_OBJ_RESIZE); |
| if (bCopy) ImpCopyMarkedPoints(); |
| ImpTransformMarkedPoints(ImpResize,&rRef,&xFact,&yFact); |
| EndUndo(); |
| AdjustMarkHdl(); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static void ImpRotate(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* /*p2*/, const void* p3, const void* p4, const void* /*p5*/) |
| { |
| RotatePoint(rPt,*(const Point*)p1,*(const double*)p3,*(const double*)p4); |
| if (pC1!=NULL) RotatePoint(*pC1,*(const Point*)p1,*(const double*)p3,*(const double*)p4); |
| if (pC2!=NULL) RotatePoint(*pC2,*(const Point*)p1,*(const double*)p3,*(const double*)p4); |
| } |
| |
| void SdrPolyEditView::RotateMarkedPoints(const Point& rRef, long nWink, bool bCopy) |
| { |
| bCopy=sal_False; // noch nicht implementiert |
| ForceUndirtyMrkPnt(); |
| XubString aStr(ImpGetResStr(STR_EditResize)); |
| if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy); |
| BegUndo(aStr,GetDescriptionOfMarkedPoints(),SDRREPFUNC_OBJ_ROTATE); |
| if (bCopy) ImpCopyMarkedPoints(); |
| double nSin=sin(nWink*nPi180); |
| double nCos=cos(nWink*nPi180); |
| ImpTransformMarkedPoints(ImpRotate,&rRef,&nWink,&nSin,&nCos); |
| EndUndo(); |
| AdjustMarkHdl(); |
| } |
| |
| // eof |