| /************************************************************** |
| * |
| * 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/svdmrkv.hxx> |
| #include <svx/svdetc.hxx> |
| #include <svx/svdoedge.hxx> |
| #include "svx/svdglob.hxx" |
| #include "svx/svditext.hxx" |
| #include <svx/svdview.hxx> |
| #include <svx/svdpagv.hxx> |
| #include <svx/svdpage.hxx> |
| #include "svddrgm1.hxx" |
| |
| #ifdef DBG_UTIL |
| #include <svdibrow.hxx> |
| #endif |
| |
| #include <svx/svdoole2.hxx> |
| #include <svx/xgrad.hxx> |
| #include <svx/xflgrit.hxx> |
| #include "gradtrns.hxx" |
| #include <svx/xflftrit.hxx> |
| #include <svx/dialmgr.hxx> |
| #include "svx/svdstr.hrc" |
| #include <svx/svdundo.hxx> |
| #include <svx/svdopath.hxx> |
| #include <svx/scene3d.hxx> |
| #include <svx/svdovirt.hxx> |
| #include <svx/sdr/overlay/overlayrollingrectangle.hxx> |
| #include <svx/sdr/overlay/overlaymanager.hxx> |
| #include <svx/sdrpaintwindow.hxx> |
| #include <svx/sdrpagewindow.hxx> |
| #include <svx/sdrhittesthelper.hxx> |
| #include <svx/svdocapt.hxx> |
| #include <svx/svdograf.hxx> |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // predefines |
| |
| class SdrUnoControlList; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // #114409#-3 Migrate Marking of Objects, Points and GluePoints |
| |
| class ImplMarkingOverlay |
| { |
| // The OverlayObjects |
| ::sdr::overlay::OverlayObjectList maObjects; |
| |
| // The remembered second position in logical coodinates |
| basegfx::B2DPoint maSecondPosition; |
| |
| // bitfield |
| // A flag to remember if the action is for unmarking. |
| unsigned mbUnmarking : 1; |
| |
| public: |
| ImplMarkingOverlay(const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos, sal_Bool bUnmarking = sal_False); |
| ~ImplMarkingOverlay(); |
| |
| void SetSecondPosition(const basegfx::B2DPoint& rNewPosition); |
| sal_Bool IsUnmarking() const { return mbUnmarking; } |
| }; |
| |
| ImplMarkingOverlay::ImplMarkingOverlay(const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos, sal_Bool bUnmarking) |
| : maSecondPosition(rStartPos), |
| mbUnmarking(bUnmarking) |
| { |
| for(sal_uInt32 a(0L); a < rView.PaintWindowCount(); a++) |
| { |
| SdrPaintWindow* pCandidate = rView.GetPaintWindow(a); |
| ::sdr::overlay::OverlayManager* pTargetOverlay = pCandidate->GetOverlayManager(); |
| |
| if(pTargetOverlay) |
| { |
| ::sdr::overlay::OverlayRollingRectangleStriped* pNew = new ::sdr::overlay::OverlayRollingRectangleStriped( |
| rStartPos, rStartPos, false); |
| pTargetOverlay->add(*pNew); |
| maObjects.append(*pNew); |
| } |
| } |
| } |
| |
| ImplMarkingOverlay::~ImplMarkingOverlay() |
| { |
| // The OverlayObjects are cleared using the destructor of OverlayObjectList. |
| // That destructor calls clear() at the list which removes all objects from the |
| // OverlayManager and deletes them. |
| } |
| |
| void ImplMarkingOverlay::SetSecondPosition(const basegfx::B2DPoint& rNewPosition) |
| { |
| if(rNewPosition != maSecondPosition) |
| { |
| // apply to OverlayObjects |
| for(sal_uInt32 a(0L); a < maObjects.count(); a++) |
| { |
| ::sdr::overlay::OverlayRollingRectangleStriped& rCandidate = (::sdr::overlay::OverlayRollingRectangleStriped&)maObjects.getOverlayObject(a); |
| rCandidate.setSecondPosition(rNewPosition); |
| } |
| |
| // remember new position |
| maSecondPosition = rNewPosition; |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // |
| // @@ @@ @@@@ @@@@@ @@ @@ @@ @@ @@ @@@@@ @@ @@ |
| // @@@ @@@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ |
| // @@@@@@@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @ @@ |
| // @@@@@@@ @@@@@@ @@@@@ @@@@ @@@@@ @@ @@@@ @@@@@@@ |
| // @@ @ @@ @@ @@ @@ @@ @@ @@ @@@ @@ @@ @@@@@@@ |
| // @@ @@ @@ @@ @@ @@ @@ @@ @@@ @@ @@ @@@ @@@ |
| // @@ @@ @@ @@ @@ @@ @@ @@ @ @@ @@@@@ @@ @@ |
| // |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void SdrMarkView::ImpClearVars() |
| { |
| eDragMode=SDRDRAG_MOVE; |
| //HMHbHdlShown=sal_False; |
| bRefHdlShownOnly=sal_False; |
| eEditMode=SDREDITMODE_EDIT; |
| eEditMode0=SDREDITMODE_EDIT; |
| bDesignMode=sal_False; |
| pMarkedObj=NULL; |
| pMarkedPV=NULL; |
| bForceFrameHandles=sal_False; |
| bPlusHdlAlways=sal_False; |
| nFrameHandlesLimit=50; |
| bInsPolyPoint=sal_False; |
| mnInsPointNum = 0L; |
| bMarkedObjRectDirty=sal_False; |
| bMarkedPointsRectsDirty=sal_False; |
| mbMarkHandlesHidden = false; |
| bMrkPntDirty=sal_False; |
| bMarkHdlWhenTextEdit=sal_False; |
| bMarkableObjCountDirty=sal_False; // noch nicht implementiert |
| nMarkableObjCount=0; // noch nicht implementiert |
| |
| // #114409#-3 Migrate selections |
| BrkMarkObj(); |
| BrkMarkPoints(); |
| BrkMarkGluePoints(); |
| } |
| |
| SdrMarkView::SdrMarkView(SdrModel* pModel1, OutputDevice* pOut) |
| : SdrSnapView(pModel1,pOut), |
| mpMarkObjOverlay(0L), |
| mpMarkPointsOverlay(0L), |
| mpMarkGluePointsOverlay(0L), |
| aHdl(this), |
| mpSdrViewSelection(new sdr::ViewSelection()) |
| { |
| ImpClearVars(); |
| StartListening(*pModel1); |
| } |
| |
| SdrMarkView::~SdrMarkView() |
| { |
| // #114409#-3 Migrate selections |
| BrkMarkObj(); |
| BrkMarkPoints(); |
| BrkMarkGluePoints(); |
| delete mpSdrViewSelection; |
| } |
| |
| void __EXPORT SdrMarkView::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) |
| { |
| SdrHint* pSdrHint=PTR_CAST(SdrHint,&rHint); |
| if (pSdrHint!=NULL) |
| { |
| SdrHintKind eKind=pSdrHint->GetKind(); |
| |
| if (eKind==HINT_OBJCHG || eKind==HINT_OBJINSERTED || eKind==HINT_OBJREMOVED) |
| { |
| bMarkedObjRectDirty=sal_True; |
| bMarkedPointsRectsDirty=sal_True; |
| } |
| /* removed for now since this breaks existing code who iterates over the mark list and sequentially replaces objects |
| if( eKind==HINT_OBJREMOVED && IsObjMarked( const_cast<SdrObject*>(pSdrHint->GetObject()) ) ) |
| { |
| MarkObj( const_cast<SdrObject*>(pSdrHint->GetObject()), GetSdrPageView(), sal_True ); |
| } |
| */ |
| } |
| SdrSnapView::Notify(rBC,rHint); |
| } |
| |
| void SdrMarkView::ModelHasChanged() |
| { |
| SdrPaintView::ModelHasChanged(); |
| GetMarkedObjectListWriteAccess().SetNameDirty(); |
| bMarkedObjRectDirty=sal_True; |
| bMarkedPointsRectsDirty=sal_True; |
| // Es sind beispielsweise Obj markiert und maMarkedObjectListist Sorted. |
| // In einer anderen View 2 wird die ObjOrder veraendert |
| // (z.B. MovToTop()). Dann ist Neusortieren der MarkList erforderlich. |
| GetMarkedObjectListWriteAccess().SetUnsorted(); |
| SortMarkedObjects(); |
| bMrkPntDirty=sal_True; |
| UndirtyMrkPnt(); |
| SdrView* pV=(SdrView*)this; |
| if (pV!=NULL && !pV->IsDragObj() && !pV->IsInsObjPoint()) { // an dieser Stelle habe ich ein ziemliches Problem !!! |
| AdjustMarkHdl(); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| sal_Bool SdrMarkView::IsAction() const |
| { |
| return SdrSnapView::IsAction() || IsMarkObj() || IsMarkPoints() || IsMarkGluePoints(); |
| } |
| |
| void SdrMarkView::MovAction(const Point& rPnt) |
| { |
| SdrSnapView::MovAction(rPnt); |
| |
| if(IsMarkObj()) |
| { |
| MovMarkObj(rPnt); |
| } |
| else if(IsMarkPoints()) |
| { |
| MovMarkPoints(rPnt); |
| } |
| else if(IsMarkGluePoints()) |
| { |
| MovMarkGluePoints(rPnt); |
| } |
| } |
| |
| void SdrMarkView::EndAction() |
| { |
| if(IsMarkObj()) |
| { |
| EndMarkObj(); |
| } |
| else if(IsMarkPoints()) |
| { |
| EndMarkPoints(); |
| } |
| else if(IsMarkGluePoints()) |
| { |
| EndMarkGluePoints(); |
| } |
| |
| SdrSnapView::EndAction(); |
| } |
| |
| void SdrMarkView::BckAction() |
| { |
| SdrSnapView::BckAction(); |
| BrkMarkObj(); |
| BrkMarkPoints(); |
| BrkMarkGluePoints(); |
| } |
| |
| void SdrMarkView::BrkAction() |
| { |
| SdrSnapView::BrkAction(); |
| BrkMarkObj(); |
| BrkMarkPoints(); |
| BrkMarkGluePoints(); |
| } |
| |
| void SdrMarkView::TakeActionRect(Rectangle& rRect) const |
| { |
| if(IsMarkObj() || IsMarkPoints() || IsMarkGluePoints()) |
| { |
| rRect = Rectangle(aDragStat.GetStart(), aDragStat.GetNow()); |
| } |
| else |
| { |
| SdrSnapView::TakeActionRect(rRect); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void SdrMarkView::ClearPageView() |
| { |
| UnmarkAllObj(); |
| SdrSnapView::ClearPageView(); |
| } |
| |
| void SdrMarkView::HideSdrPage() |
| { |
| bool bMrkChg(false); |
| //HMHbool bVis(false); |
| |
| if(mpPageView) |
| { |
| // break all creation actions when hiding page (#75081#) |
| BrkAction(); |
| //HMHbVis = IsMarkHdlShown(); |
| |
| //HMHif(bVis) |
| //HMH{ |
| //HMH HideMarkHdl(); |
| //HMH} |
| |
| // Alle Markierungen dieser Seite verwerfen |
| bMrkChg = GetMarkedObjectListWriteAccess().DeletePageView(*mpPageView); |
| } |
| |
| SdrSnapView::HideSdrPage(); |
| |
| if(bMrkChg) |
| { |
| MarkListHasChanged(); |
| AdjustMarkHdl(); |
| } |
| |
| //HMHif(bVis) |
| //HMH{ |
| //HMH ShowMarkHdl(); |
| //HMH} |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| sal_Bool SdrMarkView::BegMarkObj(const Point& rPnt, sal_Bool bUnmark) |
| { |
| BrkAction(); |
| |
| DBG_ASSERT(0L == mpMarkObjOverlay, "SdrMarkView::BegMarkObj: There exists a mpMarkObjOverlay (!)"); |
| basegfx::B2DPoint aStartPos(rPnt.X(), rPnt.Y()); |
| mpMarkObjOverlay = new ImplMarkingOverlay(*this, aStartPos, bUnmark); |
| |
| aDragStat.Reset(rPnt); |
| aDragStat.NextPoint(); |
| aDragStat.SetMinMove(nMinMovLog); |
| |
| return sal_True; |
| } |
| |
| void SdrMarkView::MovMarkObj(const Point& rPnt) |
| { |
| if(IsMarkObj() && aDragStat.CheckMinMoved(rPnt)) |
| { |
| aDragStat.NextMove(rPnt); |
| DBG_ASSERT(mpMarkObjOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); |
| basegfx::B2DPoint aNewPos(rPnt.X(), rPnt.Y()); |
| mpMarkObjOverlay->SetSecondPosition(aNewPos); |
| } |
| } |
| |
| sal_Bool SdrMarkView::EndMarkObj() |
| { |
| sal_Bool bRetval(sal_False); |
| |
| if(IsMarkObj()) |
| { |
| if(aDragStat.IsMinMoved()) |
| { |
| Rectangle aRect(aDragStat.GetStart(), aDragStat.GetNow()); |
| aRect.Justify(); |
| MarkObj(aRect, mpMarkObjOverlay->IsUnmarking()); |
| bRetval = sal_True; |
| } |
| |
| // cleanup |
| BrkMarkObj(); |
| } |
| |
| return bRetval; |
| } |
| |
| void SdrMarkView::BrkMarkObj() |
| { |
| if(IsMarkObj()) |
| { |
| DBG_ASSERT(mpMarkObjOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); |
| delete mpMarkObjOverlay; |
| mpMarkObjOverlay = 0L; |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| sal_Bool SdrMarkView::BegMarkPoints(const Point& rPnt, sal_Bool bUnmark) |
| { |
| if(HasMarkablePoints()) |
| { |
| BrkAction(); |
| |
| DBG_ASSERT(0L == mpMarkPointsOverlay, "SdrMarkView::BegMarkObj: There exists a mpMarkPointsOverlay (!)"); |
| basegfx::B2DPoint aStartPos(rPnt.X(), rPnt.Y()); |
| mpMarkPointsOverlay = new ImplMarkingOverlay(*this, aStartPos, bUnmark); |
| |
| aDragStat.Reset(rPnt); |
| aDragStat.NextPoint(); |
| aDragStat.SetMinMove(nMinMovLog); |
| |
| return sal_True; |
| } |
| |
| return sal_False; |
| } |
| |
| void SdrMarkView::MovMarkPoints(const Point& rPnt) |
| { |
| if(IsMarkPoints() && aDragStat.CheckMinMoved(rPnt)) |
| { |
| aDragStat.NextMove(rPnt); |
| |
| DBG_ASSERT(mpMarkPointsOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); |
| basegfx::B2DPoint aNewPos(rPnt.X(), rPnt.Y()); |
| mpMarkPointsOverlay->SetSecondPosition(aNewPos); |
| } |
| } |
| |
| sal_Bool SdrMarkView::EndMarkPoints() |
| { |
| sal_Bool bRetval(sal_False); |
| |
| if(IsMarkPoints()) |
| { |
| if(aDragStat.IsMinMoved()) |
| { |
| Rectangle aRect(aDragStat.GetStart(), aDragStat.GetNow()); |
| aRect.Justify(); |
| MarkPoints(aRect, mpMarkPointsOverlay->IsUnmarking()); |
| |
| bRetval = sal_True; |
| } |
| |
| // cleanup |
| BrkMarkPoints(); |
| } |
| |
| return bRetval; |
| } |
| |
| void SdrMarkView::BrkMarkPoints() |
| { |
| if(IsMarkPoints()) |
| { |
| DBG_ASSERT(mpMarkPointsOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); |
| delete mpMarkPointsOverlay; |
| mpMarkPointsOverlay = 0L; |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| sal_Bool SdrMarkView::BegMarkGluePoints(const Point& rPnt, sal_Bool bUnmark) |
| { |
| if(HasMarkableGluePoints()) |
| { |
| BrkAction(); |
| |
| DBG_ASSERT(0L == mpMarkGluePointsOverlay, "SdrMarkView::BegMarkObj: There exists a mpMarkGluePointsOverlay (!)"); |
| basegfx::B2DPoint aStartPos(rPnt.X(), rPnt.Y()); |
| mpMarkGluePointsOverlay = new ImplMarkingOverlay(*this, aStartPos, bUnmark); |
| |
| aDragStat.Reset(rPnt); |
| aDragStat.NextPoint(); |
| aDragStat.SetMinMove(nMinMovLog); |
| |
| return sal_True; |
| } |
| |
| return sal_False; |
| } |
| |
| void SdrMarkView::MovMarkGluePoints(const Point& rPnt) |
| { |
| if(IsMarkGluePoints() && aDragStat.CheckMinMoved(rPnt)) |
| { |
| aDragStat.NextMove(rPnt); |
| |
| DBG_ASSERT(mpMarkGluePointsOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); |
| basegfx::B2DPoint aNewPos(rPnt.X(), rPnt.Y()); |
| mpMarkGluePointsOverlay->SetSecondPosition(aNewPos); |
| } |
| } |
| |
| sal_Bool SdrMarkView::EndMarkGluePoints() |
| { |
| sal_Bool bRetval(sal_False); |
| |
| if(IsMarkGluePoints()) |
| { |
| if(aDragStat.IsMinMoved()) |
| { |
| Rectangle aRect(aDragStat.GetStart(),aDragStat.GetNow()); |
| aRect.Justify(); |
| MarkGluePoints(&aRect, mpMarkGluePointsOverlay->IsUnmarking()); |
| |
| bRetval = sal_True; |
| } |
| |
| // cleanup |
| BrkMarkGluePoints(); |
| } |
| |
| return bRetval; |
| } |
| |
| void SdrMarkView::BrkMarkGluePoints() |
| { |
| if(IsMarkGluePoints()) |
| { |
| DBG_ASSERT(mpMarkGluePointsOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); |
| delete mpMarkGluePointsOverlay; |
| mpMarkGluePointsOverlay = 0L; |
| } |
| } |
| |
| sal_Bool SdrMarkView::HasMarkableObj() const |
| { |
| sal_uIntPtr nCount=0; |
| |
| SdrPageView* pPV = GetSdrPageView(); |
| if(pPV) |
| { |
| SdrObjList* pOL=pPV->GetObjList(); |
| sal_uIntPtr nObjAnz=pOL->GetObjCount(); |
| for (sal_uIntPtr nObjNum=0; nObjNum<nObjAnz && nCount==0; nObjNum++) { |
| SdrObject* pObj=pOL->GetObj(nObjNum); |
| if (IsObjMarkable(pObj,pPV)) { |
| nCount++; |
| } |
| } |
| } |
| return nCount!=0; |
| } |
| |
| sal_uIntPtr SdrMarkView::GetMarkableObjCount() const |
| { |
| sal_uIntPtr nCount=0; |
| SdrPageView* pPV = GetSdrPageView(); |
| |
| if(pPV) |
| { |
| SdrObjList* pOL=pPV->GetObjList(); |
| sal_uIntPtr nObjAnz=pOL->GetObjCount(); |
| for (sal_uIntPtr nObjNum=0; nObjNum<nObjAnz; nObjNum++) { |
| SdrObject* pObj=pOL->GetObj(nObjNum); |
| if (IsObjMarkable(pObj,pPV)) { |
| nCount++; |
| } |
| } |
| } |
| return nCount; |
| } |
| |
| //HMHvoid SdrMarkView::ImpShowMarkHdl(bool /*bNoRefHdl*/) |
| //HMH{ |
| //HMH bNoRefHdl=sal_False; // geht leider erstmal nicht anders |
| //HMH if (!bHdlShown) { |
| //HMH bRefHdlShownOnly=sal_False; |
| //HMH bHdlShown=sal_True; |
| //HMH } |
| //HMH} |
| |
| //HMHvoid SdrMarkView::ShowMarkHdl(bool /*bNoRefHdl*/) |
| //HMH{ |
| //HMH bNoRefHdl=sal_False; // geht leider erstmal nicht anders |
| //HMH ImpShowMarkHdl(bNoRefHdl); |
| //HMH} |
| |
| |
| //HMHvoid SdrMarkView::HideMarkHdl(bool /*bNoRefHdl*/) |
| //HMH{ |
| //HMH bNoRefHdl=sal_False; // geht leider erstmal nicht anders |
| //HMH if (bHdlShown) { |
| //HMH bRefHdlShownOnly=bNoRefHdl; |
| //HMH bHdlShown=sal_False; |
| //HMH } |
| //HMH} |
| |
| void SdrMarkView::hideMarkHandles() |
| { |
| if(!mbMarkHandlesHidden) |
| { |
| mbMarkHandlesHidden = true; |
| AdjustMarkHdl(); |
| } |
| } |
| |
| void SdrMarkView::showMarkHandles() |
| { |
| if(mbMarkHandlesHidden) |
| { |
| mbMarkHandlesHidden = false; |
| AdjustMarkHdl(); |
| } |
| } |
| |
| sal_Bool SdrMarkView::ImpIsFrameHandles() const |
| { |
| sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); |
| sal_Bool bFrmHdl=nMarkAnz>nFrameHandlesLimit || bForceFrameHandles; |
| sal_Bool bStdDrag=eDragMode==SDRDRAG_MOVE; |
| if (nMarkAnz==1 && bStdDrag && bFrmHdl) |
| { |
| const SdrObject* pObj=GetMarkedObjectByIndex(0); |
| if (pObj->GetObjInventor()==SdrInventor) |
| { |
| sal_uInt16 nIdent=pObj->GetObjIdentifier(); |
| if (nIdent==OBJ_LINE || nIdent==OBJ_EDGE || nIdent==OBJ_CAPTION || nIdent==OBJ_MEASURE || nIdent==OBJ_CUSTOMSHAPE || nIdent==OBJ_TABLE ) |
| { |
| bFrmHdl=sal_False; |
| } |
| } |
| } |
| if (!bStdDrag && !bFrmHdl) { |
| // Grundsaetzlich erstmal alle anderen Dragmodi nur mit FrameHandles |
| bFrmHdl=sal_True; |
| if (eDragMode==SDRDRAG_ROTATE) { |
| // bei Rotate ObjOwn-Drag, wenn mind. 1 PolyObj |
| for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && bFrmHdl; nMarkNum++) { |
| const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); |
| const SdrObject* pObj=pM->GetMarkedSdrObj(); |
| bFrmHdl=!pObj->IsPolyObj(); |
| } |
| } |
| } |
| if (!bFrmHdl) { |
| // FrameHandles, wenn wenigstens 1 Obj kein SpecialDrag kann |
| for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && !bFrmHdl; nMarkNum++) { |
| const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); |
| const SdrObject* pObj=pM->GetMarkedSdrObj(); |
| bFrmHdl=!pObj->hasSpecialDrag(); |
| } |
| } |
| |
| // no FrameHdl for crop |
| if(bFrmHdl && SDRDRAG_CROP == eDragMode) |
| { |
| bFrmHdl = sal_False; |
| } |
| |
| return bFrmHdl; |
| } |
| |
| void SdrMarkView::SetMarkHandles() |
| { |
| // #105722# remember old focus handle values to search for it again |
| const SdrHdl* pSaveOldFocusHdl = aHdl.GetFocusHdl(); |
| sal_Bool bSaveOldFocus(sal_False); |
| sal_uInt32 nSavePolyNum(0L), nSavePointNum(0L); |
| SdrHdlKind eSaveKind(HDL_MOVE); |
| SdrObject* pSaveObj = NULL; |
| |
| if(pSaveOldFocusHdl |
| && pSaveOldFocusHdl->GetObj() |
| && pSaveOldFocusHdl->GetObj()->ISA(SdrPathObj) |
| && (pSaveOldFocusHdl->GetKind() == HDL_POLY || pSaveOldFocusHdl->GetKind() == HDL_BWGT)) |
| { |
| bSaveOldFocus = sal_True; |
| nSavePolyNum = pSaveOldFocusHdl->GetPolyNum(); |
| nSavePointNum = pSaveOldFocusHdl->GetPointNum(); |
| pSaveObj = pSaveOldFocusHdl->GetObj(); |
| eSaveKind = pSaveOldFocusHdl->GetKind(); |
| } |
| |
| // delete/clear all handles. This will always be done, even with areMarkHandlesHidden() |
| aHdl.Clear(); |
| aHdl.SetRotateShear(eDragMode==SDRDRAG_ROTATE); |
| aHdl.SetDistortShear(eDragMode==SDRDRAG_SHEAR); |
| pMarkedObj=NULL; |
| pMarkedPV=NULL; |
| |
| // are handles enabled at all? Create only then |
| if(!areMarkHandlesHidden()) |
| { |
| sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); |
| sal_Bool bStdDrag=eDragMode==SDRDRAG_MOVE; |
| sal_Bool bSingleTextObjMark=sal_False; |
| |
| if (nMarkAnz==1) |
| { |
| pMarkedObj=GetMarkedObjectByIndex(0); |
| bSingleTextObjMark = |
| pMarkedObj && |
| pMarkedObj->ISA(SdrTextObj) && |
| static_cast<SdrTextObj*>(pMarkedObj)->IsTextFrame(); |
| } |
| |
| sal_Bool bFrmHdl=ImpIsFrameHandles(); |
| |
| if (nMarkAnz>0) |
| { |
| pMarkedPV=GetSdrPageViewOfMarkedByIndex(0); |
| |
| for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz && (pMarkedPV!=NULL || !bFrmHdl); nMarkNum++) |
| { |
| const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); |
| |
| if (pMarkedPV!=pM->GetPageView()) |
| { |
| pMarkedPV=NULL; |
| } |
| } |
| } |
| |
| // check if text edit or ole is active and handles need to be suppressed. This may be the case |
| // when a single object is selected |
| // Using a strict return statement is okay here; no handles means *no* handles. |
| if(pMarkedObj) |
| { |
| // formally #i33755#: If TextEdit is active the EditEngine will directly paint |
| // to the window, so suppress Overlay and handles completely; a text frame for |
| // the active text edit will be painted by the repaitnt mechanism in |
| // SdrObjEditView::ImpPaintOutlinerView in this case. This needs to be reworked |
| // in the future |
| // Also formally #122142#: Pretty much the same for SdrCaptionObj's in calc. |
| if(((SdrView*)this)->IsTextEdit()) |
| { |
| const SdrTextObj* pSdrTextObj = dynamic_cast< const SdrTextObj* >(pMarkedObj); |
| |
| if(pSdrTextObj && pSdrTextObj->IsInEditMode()) |
| { |
| return; |
| } |
| } |
| |
| // formally #i118524#: if inplace activated OLE is selected, suppress handles |
| const SdrOle2Obj* pSdrOle2Obj = dynamic_cast< const SdrOle2Obj* >(pMarkedObj); |
| |
| if(pSdrOle2Obj && (pSdrOle2Obj->isInplaceActive() || pSdrOle2Obj->isUiActive())) |
| { |
| return; |
| } |
| } |
| |
| if (bFrmHdl) |
| { |
| Rectangle aRect(GetMarkedObjRect()); |
| |
| if(!aRect.IsEmpty()) |
| { // sonst nix gefunden |
| if( bSingleTextObjMark ) |
| { |
| const sal_uIntPtr nSiz0=aHdl.GetHdlCount(); |
| pMarkedObj->AddToHdlList(aHdl); |
| const sal_uIntPtr nSiz1=aHdl.GetHdlCount(); |
| for (sal_uIntPtr i=nSiz0; i<nSiz1; i++) |
| { |
| SdrHdl* pHdl=aHdl.GetHdl(i); |
| pHdl->SetObj(pMarkedObj); |
| pHdl->SetPageView(pMarkedPV); |
| pHdl->SetObjHdlNum(sal_uInt16(i-nSiz0)); |
| } |
| } |
| else |
| { |
| sal_Bool bWdt0=aRect.Left()==aRect.Right(); |
| sal_Bool bHgt0=aRect.Top()==aRect.Bottom(); |
| if (bWdt0 && bHgt0) |
| { |
| aHdl.AddHdl(new SdrHdl(aRect.TopLeft(),HDL_UPLFT)); |
| } |
| else if (!bStdDrag && (bWdt0 || bHgt0)) |
| { |
| aHdl.AddHdl(new SdrHdl(aRect.TopLeft() ,HDL_UPLFT)); |
| aHdl.AddHdl(new SdrHdl(aRect.BottomRight(),HDL_LWRGT)); |
| } |
| else |
| { |
| if (!bWdt0 && !bHgt0) aHdl.AddHdl(new SdrHdl(aRect.TopLeft() ,HDL_UPLFT)); |
| if ( !bHgt0) aHdl.AddHdl(new SdrHdl(aRect.TopCenter() ,HDL_UPPER)); |
| if (!bWdt0 && !bHgt0) aHdl.AddHdl(new SdrHdl(aRect.TopRight() ,HDL_UPRGT)); |
| if (!bWdt0 ) aHdl.AddHdl(new SdrHdl(aRect.LeftCenter() ,HDL_LEFT )); |
| if (!bWdt0 ) aHdl.AddHdl(new SdrHdl(aRect.RightCenter() ,HDL_RIGHT)); |
| if (!bWdt0 && !bHgt0) aHdl.AddHdl(new SdrHdl(aRect.BottomLeft() ,HDL_LWLFT)); |
| if ( !bHgt0) aHdl.AddHdl(new SdrHdl(aRect.BottomCenter(),HDL_LOWER)); |
| if (!bWdt0 && !bHgt0) aHdl.AddHdl(new SdrHdl(aRect.BottomRight() ,HDL_LWRGT)); |
| } |
| } |
| } |
| } |
| else |
| { |
| bool bDone(false); |
| |
| // moved crop handling to non-frame part and the handle creation to SdrGrafObj |
| if(1 == nMarkAnz && pMarkedObj && SDRDRAG_CROP == eDragMode) |
| { |
| const SdrGrafObj* pSdrGrafObj = dynamic_cast< const SdrGrafObj* >(pMarkedObj); |
| |
| if(pSdrGrafObj) |
| { |
| pSdrGrafObj->addCropHandles(aHdl); |
| bDone = true; |
| } |
| } |
| |
| if(!bDone) |
| { |
| for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) |
| { |
| const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); |
| SdrObject* pObj=pM->GetMarkedSdrObj(); |
| SdrPageView* pPV=pM->GetPageView(); |
| const sal_uIntPtr nSiz0=aHdl.GetHdlCount(); |
| pObj->AddToHdlList(aHdl); |
| const sal_uIntPtr nSiz1=aHdl.GetHdlCount(); |
| bool bPoly=pObj->IsPolyObj(); |
| const SdrUShortCont* pMrkPnts=pM->GetMarkedPoints(); |
| for (sal_uIntPtr i=nSiz0; i<nSiz1; i++) |
| { |
| SdrHdl* pHdl=aHdl.GetHdl(i); |
| pHdl->SetObj(pObj); |
| pHdl->SetPageView(pPV); |
| pHdl->SetObjHdlNum(sal_uInt16(i-nSiz0)); |
| if (bPoly) |
| { |
| sal_Bool bSelected=pMrkPnts!=NULL && pMrkPnts->Exist(sal_uInt16(i-nSiz0)); |
| pHdl->SetSelected(bSelected); |
| //sal_Bool bPlus=bPlusHdlAlways; |
| if (bPlusHdlAlways || bSelected) |
| { |
| sal_uInt32 nPlusAnz=pObj->GetPlusHdlCount(*pHdl); |
| for (sal_uInt32 nPlusNum=0; nPlusNum<nPlusAnz; nPlusNum++) |
| { |
| SdrHdl* pPlusHdl=pObj->GetPlusHdl(*pHdl,nPlusNum); |
| if (pPlusHdl!=NULL) |
| { |
| pPlusHdl->SetObj(pObj); |
| pPlusHdl->SetPageView(pPV); |
| pPlusHdl->SetPlusHdl(sal_True); |
| aHdl.AddHdl(pPlusHdl); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| // GluePoint-Handles |
| for (sal_uIntPtr nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++) |
| { |
| const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); |
| SdrObject* pObj=pM->GetMarkedSdrObj(); |
| SdrPageView* pPV=pM->GetPageView(); |
| const SdrUShortCont* pMrkGlue=pM->GetMarkedGluePoints(); |
| if (pMrkGlue!=NULL) |
| { |
| const SdrGluePointList* pGPL=pObj->GetGluePointList(); |
| if (pGPL!=NULL) |
| { |
| //sal_uInt16 nGlueAnz=pGPL->GetCount(); |
| sal_uInt16 nAnz=(sal_uInt16)pMrkGlue->GetCount(); |
| for (sal_uInt16 nNum=0; nNum<nAnz; nNum++) |
| { |
| sal_uInt16 nId=pMrkGlue->GetObject(nNum); |
| //nNum changed to nNumGP because already used in for loop |
| sal_uInt16 nNumGP=pGPL->FindGluePoint(nId); |
| if (nNumGP!=SDRGLUEPOINT_NOTFOUND) |
| { |
| const SdrGluePoint& rGP=(*pGPL)[nNumGP]; |
| Point aPos(rGP.GetAbsolutePos(*pObj)); |
| SdrHdl* pGlueHdl=new SdrHdl(aPos,HDL_GLUE); |
| pGlueHdl->SetObj(pObj); |
| pGlueHdl->SetPageView(pPV); |
| pGlueHdl->SetObjHdlNum(nId); |
| aHdl.AddHdl(pGlueHdl); |
| } |
| } |
| } |
| } |
| } |
| |
| // Drehpunkt/Spiegelachse |
| AddDragModeHdl(eDragMode); |
| |
| // sort handles |
| aHdl.Sort(); |
| |
| // add custom handles (used by other apps, e.g. AnchorPos) |
| AddCustomHdl(); |
| |
| // #105722# try to restore focus handle index from remembered values |
| if(bSaveOldFocus) |
| { |
| for(sal_uInt32 a(0); a < aHdl.GetHdlCount(); a++) |
| { |
| SdrHdl* pCandidate = aHdl.GetHdl(a); |
| |
| if(pCandidate->GetObj() |
| && pCandidate->GetObj() == pSaveObj |
| && pCandidate->GetKind() == eSaveKind |
| && pCandidate->GetPolyNum() == nSavePolyNum |
| && pCandidate->GetPointNum() == nSavePointNum) |
| { |
| aHdl.SetFocusHdl(pCandidate); |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| void SdrMarkView::AddCustomHdl() |
| { |
| // add custom handles (used by other apps, e.g. AnchorPos) |
| } |
| |
| void SdrMarkView::SetDragMode(SdrDragMode eMode) |
| { |
| SdrDragMode eMode0=eDragMode; |
| eDragMode=eMode; |
| if (eDragMode==SDRDRAG_RESIZE) eDragMode=SDRDRAG_MOVE; |
| if (eDragMode!=eMode0) { |
| //HMHBOOL bVis=IsMarkHdlShown(); |
| //HMHif (bVis) HideMarkHdl(); |
| ForceRefToMarked(); |
| SetMarkHandles(); |
| //HMHif (bVis) ShowMarkHdl(); |
| { |
| if (AreObjectsMarked()) MarkListHasChanged(); |
| } |
| } |
| } |
| |
| void SdrMarkView::AddDragModeHdl(SdrDragMode eMode) |
| { |
| switch(eMode) |
| { |
| case SDRDRAG_ROTATE: |
| { |
| // add rotation center |
| SdrHdl* pHdl = new SdrHdl(aRef1, HDL_REF1); |
| |
| aHdl.AddHdl(pHdl); |
| |
| break; |
| } |
| case SDRDRAG_MIRROR: |
| { |
| // add mirror axis |
| SdrHdl* pHdl3 = new SdrHdl(aRef2, HDL_REF2); |
| SdrHdl* pHdl2 = new SdrHdl(aRef1, HDL_REF1); |
| SdrHdl* pHdl1 = new SdrHdlLine(*pHdl2, *pHdl3, HDL_MIRX); |
| |
| pHdl1->SetObjHdlNum(1); // fuer Sortierung |
| pHdl2->SetObjHdlNum(2); // fuer Sortierung |
| pHdl3->SetObjHdlNum(3); // fuer Sortierung |
| |
| aHdl.AddHdl(pHdl1); // Linie als erstes, damit als letztes im HitTest |
| aHdl.AddHdl(pHdl2); |
| aHdl.AddHdl(pHdl3); |
| |
| break; |
| } |
| case SDRDRAG_TRANSPARENCE: |
| { |
| // add interactive transparence handle |
| sal_uIntPtr nMarkAnz = GetMarkedObjectCount(); |
| if(nMarkAnz == 1) |
| { |
| SdrObject* pObj = GetMarkedObjectByIndex(0); |
| SdrModel* pModel = GetModel(); |
| const SfxItemSet& rSet = pObj->GetMergedItemSet(); |
| |
| if(SFX_ITEM_SET != rSet.GetItemState(XATTR_FILLFLOATTRANSPARENCE, sal_False)) |
| { |
| // add this item, it's not yet there |
| XFillFloatTransparenceItem aNewItem( |
| (const XFillFloatTransparenceItem&)rSet.Get(XATTR_FILLFLOATTRANSPARENCE)); |
| XGradient aGrad = aNewItem.GetGradientValue(); |
| |
| aNewItem.SetEnabled(sal_True); |
| aGrad.SetStartIntens(100); |
| aGrad.SetEndIntens(100); |
| aNewItem.SetGradientValue(aGrad); |
| |
| // add undo to allow user to take back this step |
| if( pModel->IsUndoEnabled() ) |
| { |
| pModel->BegUndo(SVX_RESSTR(SIP_XA_FILLTRANSPARENCE)); |
| pModel->AddUndo(pModel->GetSdrUndoFactory().CreateUndoAttrObject(*pObj)); |
| pModel->EndUndo(); |
| } |
| |
| //pObj->SetItemAndBroadcast(aNewItem); |
| SfxItemSet aNewSet(pModel->GetItemPool()); |
| aNewSet.Put(aNewItem); |
| pObj->SetMergedItemSetAndBroadcast(aNewSet); |
| } |
| |
| // set values and transform to vector set |
| GradTransformer aGradTransformer; |
| GradTransVector aGradTransVector; |
| GradTransGradient aGradTransGradient; |
| |
| aGradTransGradient.aGradient = ((XFillFloatTransparenceItem&)rSet.Get(XATTR_FILLFLOATTRANSPARENCE)).GetGradientValue(); |
| aGradTransformer.GradToVec(aGradTransGradient, aGradTransVector, pObj); |
| |
| // build handles |
| const Point aTmpPos1(basegfx::fround(aGradTransVector.maPositionA.getX()), basegfx::fround(aGradTransVector.maPositionA.getY())); |
| const Point aTmpPos2(basegfx::fround(aGradTransVector.maPositionB.getX()), basegfx::fround(aGradTransVector.maPositionB.getY())); |
| SdrHdlColor* pColHdl1 = new SdrHdlColor(aTmpPos1, aGradTransVector.aCol1, SDR_HANDLE_COLOR_SIZE_NORMAL, sal_True); |
| SdrHdlColor* pColHdl2 = new SdrHdlColor(aTmpPos2, aGradTransVector.aCol2, SDR_HANDLE_COLOR_SIZE_NORMAL, sal_True); |
| SdrHdlGradient* pGradHdl = new SdrHdlGradient(aTmpPos1, aTmpPos2, sal_False); |
| DBG_ASSERT(pColHdl1 && pColHdl2 && pGradHdl, "Got not all necessary handles!!"); |
| |
| // link them |
| pGradHdl->SetColorHandles(pColHdl1, pColHdl2); |
| pGradHdl->SetObj(pObj); |
| pColHdl1->SetColorChangeHdl(LINK(pGradHdl, SdrHdlGradient, ColorChangeHdl)); |
| pColHdl2->SetColorChangeHdl(LINK(pGradHdl, SdrHdlGradient, ColorChangeHdl)); |
| |
| // insert them |
| aHdl.AddHdl(pColHdl1); |
| aHdl.AddHdl(pColHdl2); |
| aHdl.AddHdl(pGradHdl); |
| } |
| break; |
| } |
| case SDRDRAG_GRADIENT: |
| { |
| // add interactive gradient handle |
| sal_uIntPtr nMarkAnz = GetMarkedObjectCount(); |
| if(nMarkAnz == 1) |
| { |
| SdrObject* pObj = GetMarkedObjectByIndex(0); |
| const SfxItemSet& rSet = pObj->GetMergedItemSet(); |
| XFillStyle eFillStyle = ((XFillStyleItem&)(rSet.Get(XATTR_FILLSTYLE))).GetValue(); |
| |
| if(eFillStyle == XFILL_GRADIENT) |
| { |
| // set values and transform to vector set |
| GradTransformer aGradTransformer; |
| GradTransVector aGradTransVector; |
| GradTransGradient aGradTransGradient; |
| Size aHdlSize(15, 15); |
| |
| aGradTransGradient.aGradient = ((XFillGradientItem&)rSet.Get(XATTR_FILLGRADIENT)).GetGradientValue(); |
| aGradTransformer.GradToVec(aGradTransGradient, aGradTransVector, pObj); |
| |
| // build handles |
| const Point aTmpPos1(basegfx::fround(aGradTransVector.maPositionA.getX()), basegfx::fround(aGradTransVector.maPositionA.getY())); |
| const Point aTmpPos2(basegfx::fround(aGradTransVector.maPositionB.getX()), basegfx::fround(aGradTransVector.maPositionB.getY())); |
| SdrHdlColor* pColHdl1 = new SdrHdlColor(aTmpPos1, aGradTransVector.aCol1, aHdlSize, sal_False); |
| SdrHdlColor* pColHdl2 = new SdrHdlColor(aTmpPos2, aGradTransVector.aCol2, aHdlSize, sal_False); |
| SdrHdlGradient* pGradHdl = new SdrHdlGradient(aTmpPos1, aTmpPos2, sal_True); |
| DBG_ASSERT(pColHdl1 && pColHdl2 && pGradHdl, "Got not all necessary handles!!"); |
| |
| // link them |
| pGradHdl->SetColorHandles(pColHdl1, pColHdl2); |
| pGradHdl->SetObj(pObj); |
| pColHdl1->SetColorChangeHdl(LINK(pGradHdl, SdrHdlGradient, ColorChangeHdl)); |
| pColHdl2->SetColorChangeHdl(LINK(pGradHdl, SdrHdlGradient, ColorChangeHdl)); |
| |
| // insert them |
| aHdl.AddHdl(pColHdl1); |
| aHdl.AddHdl(pColHdl2); |
| aHdl.AddHdl(pGradHdl); |
| } |
| } |
| break; |
| } |
| case SDRDRAG_CROP: |
| { |
| // todo |
| break; |
| } |
| default: break; |
| } |
| } |
| |
| /** handle mouse over effects for handles */ |
| sal_Bool SdrMarkView::MouseMove(const MouseEvent& rMEvt, Window* pWin) |
| { |
| if(aHdl.GetHdlCount()) |
| { |
| SdrHdl* pMouseOverHdl = 0; |
| if( !rMEvt.IsLeaveWindow() && pWin ) |
| { |
| Point aMDPos( pWin->PixelToLogic( rMEvt.GetPosPixel() ) ); |
| pMouseOverHdl = PickHandle(aMDPos); |
| } |
| |
| // notify last mouse over handle that he lost the mouse |
| const sal_uIntPtr nHdlCount = aHdl.GetHdlCount(); |
| |
| for(sal_uIntPtr nHdl = 0; nHdl < nHdlCount; nHdl++ ) |
| { |
| SdrHdl* pCurrentHdl = GetHdl(nHdl); |
| if( pCurrentHdl->mbMouseOver ) |
| { |
| if( pCurrentHdl != pMouseOverHdl ) |
| { |
| pCurrentHdl->mbMouseOver = false; |
| pCurrentHdl->onMouseLeave(); |
| } |
| break; |
| } |
| } |
| |
| // notify current mouse over handle |
| if( pMouseOverHdl /* && !pMouseOverHdl->mbMouseOver */ ) |
| { |
| pMouseOverHdl->mbMouseOver = true; |
| pMouseOverHdl->onMouseEnter(rMEvt); |
| } |
| } |
| return SdrSnapView::MouseMove(rMEvt, pWin); |
| } |
| |
| void SdrMarkView::ForceRefToMarked() |
| { |
| switch(eDragMode) |
| { |
| case SDRDRAG_ROTATE: |
| { |
| Rectangle aR(GetMarkedObjRect()); |
| aRef1 = aR.Center(); |
| |
| break; |
| } |
| |
| case SDRDRAG_MIRROR: |
| { |
| // Erstmal die laenge der Spiegelachsenlinie berechnen |
| long nOutMin=0; |
| long nOutMax=0; |
| long nMinLen=0; |
| long nObjDst=0; |
| long nOutHgt=0; |
| OutputDevice* pOut=GetFirstOutputDevice(); |
| //OutputDevice* pOut=GetWin(0); |
| if (pOut!=NULL) { |
| // Mindestlaenge 50 Pixel |
| nMinLen=pOut->PixelToLogic(Size(0,50)).Height(); |
| // 20 Pixel fuer RefPt-Abstand vom Obj |
| nObjDst=pOut->PixelToLogic(Size(0,20)).Height(); |
| // MinY/MaxY |
| // Abstand zum Rand = Mindestlaenge = 10 Pixel |
| long nDst=pOut->PixelToLogic(Size(0,10)).Height(); |
| nOutMin=-pOut->GetMapMode().GetOrigin().Y(); |
| nOutMax=pOut->GetOutputSize().Height()-1+nOutMin; |
| nOutMin+=nDst; |
| nOutMax-=nDst; |
| // Absolute Mindestlaenge jedoch 10 Pixel |
| if (nOutMax-nOutMin<nDst) { |
| nOutMin+=nOutMax+1; |
| nOutMin/=2; |
| nOutMin-=(nDst+1)/2; |
| nOutMax=nOutMin+nDst; |
| } |
| nOutHgt=nOutMax-nOutMin; |
| // Sonst Mindestlaenge = 1/4 OutHgt |
| long nTemp=nOutHgt/4; |
| if (nTemp>nMinLen) nMinLen=nTemp; |
| } |
| |
| Rectangle aR(GetMarkedObjBoundRect()); |
| Point aCenter(aR.Center()); |
| long nMarkHgt=aR.GetHeight()-1; |
| long nHgt=nMarkHgt+nObjDst*2; // 20 Pixel obej und unten ueberstehend |
| if (nHgt<nMinLen) nHgt=nMinLen; // Mindestlaenge 50 Pixel bzw. 1/4 OutHgt |
| |
| long nY1=aCenter.Y()-(nHgt+1)/2; |
| long nY2=nY1+nHgt; |
| |
| if (pOut!=NULL && nMinLen>nOutHgt) nMinLen=nOutHgt; // evtl. noch etwas verkuerzen |
| |
| if (pOut!=NULL) { // nun vollstaendig in den sichtbaren Bereich schieben |
| if (nY1<nOutMin) { |
| nY1=nOutMin; |
| if (nY2<nY1+nMinLen) nY2=nY1+nMinLen; |
| } |
| if (nY2>nOutMax) { |
| nY2=nOutMax; |
| if (nY1>nY2-nMinLen) nY1=nY2-nMinLen; |
| } |
| } |
| |
| aRef1.X()=aCenter.X(); |
| aRef1.Y()=nY1; |
| aRef2.X()=aCenter.X(); |
| aRef2.Y()=nY2; |
| |
| break; |
| } |
| |
| case SDRDRAG_TRANSPARENCE: |
| case SDRDRAG_GRADIENT: |
| case SDRDRAG_CROP: |
| { |
| Rectangle aRect(GetMarkedObjBoundRect()); |
| aRef1 = aRect.TopLeft(); |
| aRef2 = aRect.BottomRight(); |
| break; |
| } |
| default: break; |
| } |
| } |
| |
| void SdrMarkView::SetRef1(const Point& rPt) |
| { |
| if(eDragMode == SDRDRAG_ROTATE || eDragMode == SDRDRAG_MIRROR) |
| { |
| aRef1 = rPt; |
| SdrHdl* pH = aHdl.GetHdl(HDL_REF1); |
| if(pH) |
| pH->SetPos(rPt); |
| //HMHShowMarkHdl(); |
| } |
| } |
| |
| void SdrMarkView::SetRef2(const Point& rPt) |
| { |
| if(eDragMode == SDRDRAG_MIRROR) |
| { |
| aRef2 = rPt; |
| SdrHdl* pH = aHdl.GetHdl(HDL_REF2); |
| if(pH) |
| pH->SetPos(rPt); |
| //HMHShowMarkHdl(); |
| } |
| } |
| |
| void SdrMarkView::CheckMarked() |
| { |
| for (sal_uIntPtr nm=GetMarkedObjectCount(); nm>0;) { |
| nm--; |
| SdrMark* pM=GetSdrMarkByIndex(nm); |
| SdrObject* pObj=pM->GetMarkedSdrObj(); |
| SdrPageView* pPV=pM->GetPageView(); |
| SdrLayerID nLay=pObj->GetLayer(); |
| sal_Bool bRaus=!pObj->IsInserted(); // Obj geloescht? |
| if (!pObj->Is3DObj()) { |
| bRaus=bRaus || pObj->GetPage()!=pPV->GetPage(); // Obj ploetzlich in anderer Page oder Group |
| } |
| bRaus=bRaus || pPV->GetLockedLayers().IsSet(nLay) || // Layer gesperrt? |
| !pPV->GetVisibleLayers().IsSet(nLay); // Layer nicht sichtbar? |
| |
| if( !bRaus ) |
| bRaus = !pObj->IsVisible(); // not visible objects can not be marked |
| |
| if (!bRaus) { |
| // Joe am 9.3.1997: Gruppierte Objekten koennen nun auch |
| // markiert werden. Nach EnterGroup muessen aber die Objekte |
| // der hoeheren Ebene deselektiert werden. |
| const SdrObjList* pOOL=pObj->GetObjList(); |
| const SdrObjList* pVOL=pPV->GetObjList(); |
| while (pOOL!=NULL && pOOL!=pVOL) { |
| pOOL=pOOL->GetUpList(); |
| } |
| bRaus=pOOL!=pVOL; |
| } |
| |
| if (bRaus) |
| { |
| GetMarkedObjectListWriteAccess().DeleteMark(nm); |
| } |
| else |
| { |
| if (!IsGluePointEditMode()) { // Markierte GluePoints nur im GlueEditMode |
| SdrUShortCont* pPts=pM->GetMarkedGluePoints(); |
| if (pPts!=NULL && pPts->GetCount()!=0) { |
| pPts->Clear(); |
| } |
| } |
| } |
| } |
| |
| // #97995# at least reset the remembered BoundRect to prevent handle |
| // generation if bForceFrameHandles is TRUE. |
| bMarkedObjRectDirty = sal_True; |
| } |
| |
| void SdrMarkView::SetMarkRects() |
| { |
| SdrPageView* pPV = GetSdrPageView(); |
| |
| if(pPV) |
| { |
| pPV->SetHasMarkedObj(GetSnapRectFromMarkedObjects(pPV, pPV->MarkSnap())); |
| GetBoundRectFromMarkedObjects(pPV, pPV->MarkBound()); |
| } |
| } |
| |
| void SdrMarkView::SetFrameHandles(sal_Bool bOn) |
| { |
| if (bOn!=bForceFrameHandles) { |
| sal_Bool bOld=ImpIsFrameHandles(); |
| bForceFrameHandles=bOn; |
| sal_Bool bNew=ImpIsFrameHandles(); |
| if (bNew!=bOld) { |
| AdjustMarkHdl(); //HMHTRUE); |
| MarkListHasChanged(); |
| } |
| } |
| } |
| |
| void SdrMarkView::SetEditMode(SdrViewEditMode eMode) |
| { |
| if (eMode!=eEditMode) { |
| sal_Bool bGlue0=eEditMode==SDREDITMODE_GLUEPOINTEDIT; |
| sal_Bool bEdge0=((SdrCreateView*)this)->IsEdgeTool(); |
| eEditMode0=eEditMode; |
| eEditMode=eMode; |
| sal_Bool bGlue1=eEditMode==SDREDITMODE_GLUEPOINTEDIT; |
| sal_Bool bEdge1=((SdrCreateView*)this)->IsEdgeTool(); |
| // etwas Aufwand um Flackern zu verhindern beim Umschalten |
| // zwischen GlueEdit und EdgeTool |
| if (bGlue1 && !bGlue0) ImpSetGlueVisible2(bGlue1); |
| if (bEdge1!=bEdge0) ImpSetGlueVisible3(bEdge1); |
| if (!bGlue1 && bGlue0) ImpSetGlueVisible2(bGlue1); |
| if (bGlue0 && !bGlue1) UnmarkAllGluePoints(); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| sal_Bool SdrMarkView::IsObjMarkable(SdrObject* pObj, SdrPageView* pPV) const |
| { |
| if (pObj) |
| { |
| if (pObj->IsMarkProtect() || |
| (!bDesignMode && pObj->IsUnoObj())) |
| { |
| // Objekt nicht selektierbar oder |
| // SdrUnoObj nicht im DesignMode |
| return sal_False; |
| } |
| } |
| return pPV!=NULL ? pPV->IsObjMarkable(pObj) : sal_True; |
| } |
| |
| sal_Bool SdrMarkView::IsMarkedObjHit(const Point& rPnt, short nTol) const |
| { |
| sal_Bool bRet=sal_False; |
| nTol=ImpGetHitTolLogic(nTol,NULL); |
| Point aPt(rPnt); |
| for (sal_uIntPtr nm=0; nm<GetMarkedObjectCount() && !bRet; nm++) { |
| SdrMark* pM=GetSdrMarkByIndex(nm); |
| bRet = 0 != CheckSingleSdrObjectHit(aPt,sal_uInt16(nTol),pM->GetMarkedSdrObj(),pM->GetPageView(),0,0); |
| } |
| return bRet; |
| } |
| |
| SdrHdl* SdrMarkView::PickHandle(const Point& rPnt, sal_uIntPtr nOptions, SdrHdl* pHdl0) const |
| { |
| if (bSomeObjChgdFlag) { // ggf. Handles neu berechnen lassen! |
| FlushComeBackTimer(); |
| } |
| sal_Bool bBack=(nOptions & SDRSEARCH_BACKWARD) !=0; |
| sal_Bool bNext=(nOptions & SDRSEARCH_NEXT) !=0; |
| Point aPt(rPnt); |
| return aHdl.IsHdlListHit(aPt,bBack,bNext,pHdl0); |
| } |
| |
| sal_Bool SdrMarkView::MarkObj(const Point& rPnt, short nTol, sal_Bool bToggle, sal_Bool bDeep) |
| { |
| SdrObject* pObj; |
| SdrPageView* pPV; |
| nTol=ImpGetHitTolLogic(nTol,NULL); |
| sal_uIntPtr nOptions=SDRSEARCH_PICKMARKABLE; |
| if (bDeep) nOptions=nOptions|SDRSEARCH_DEEP; |
| sal_Bool bRet=PickObj(rPnt,(sal_uInt16)nTol,pObj,pPV,nOptions); |
| if (bRet) { |
| sal_Bool bUnmark=bToggle && IsObjMarked(pObj); |
| MarkObj(pObj,pPV,bUnmark); |
| } |
| return bRet; |
| } |
| |
| sal_Bool SdrMarkView::MarkNextObj(sal_Bool bPrev) |
| { |
| SdrPageView* pPageView = GetSdrPageView(); |
| |
| if(!pPageView) |
| { |
| return sal_False; |
| } |
| |
| SortMarkedObjects(); |
| sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); |
| sal_uIntPtr nChgMarkNum = ULONG_MAX; // Nummer des zu ersetzenden MarkEntries |
| sal_uIntPtr nSearchObjNum = bPrev ? 0 : ULONG_MAX; |
| if (nMarkAnz!=0) { |
| nChgMarkNum=bPrev ? 0 : sal_uIntPtr(nMarkAnz-1); |
| SdrMark* pM=GetSdrMarkByIndex(nChgMarkNum); |
| OSL_ASSERT(pM!=NULL); |
| if (pM->GetMarkedSdrObj() != NULL) |
| nSearchObjNum = pM->GetMarkedSdrObj()->GetNavigationPosition(); |
| } |
| |
| SdrObject* pMarkObj=NULL; |
| SdrObjList* pSearchObjList=pPageView->GetObjList(); |
| sal_uIntPtr nObjAnz=pSearchObjList->GetObjCount(); |
| if (nObjAnz!=0) { |
| if (nSearchObjNum>nObjAnz) nSearchObjNum=nObjAnz; |
| while (pMarkObj==NULL && ((!bPrev && nSearchObjNum>0) || (bPrev && nSearchObjNum<nObjAnz))) |
| { |
| if (!bPrev) |
| nSearchObjNum--; |
| SdrObject* pSearchObj = pSearchObjList->GetObjectForNavigationPosition(nSearchObjNum); |
| if (IsObjMarkable(pSearchObj,pPageView)) |
| { |
| if (TryToFindMarkedObject(pSearchObj)==CONTAINER_ENTRY_NOTFOUND) |
| { |
| pMarkObj=pSearchObj; |
| } |
| } |
| if (bPrev) nSearchObjNum++; |
| } |
| } |
| |
| if(!pMarkObj) |
| { |
| return sal_False; |
| } |
| |
| if (nChgMarkNum!=ULONG_MAX) |
| { |
| GetMarkedObjectListWriteAccess().DeleteMark(nChgMarkNum); |
| } |
| MarkObj(pMarkObj,pPageView); // ruft auch MarkListHasChanged(), AdjustMarkHdl() |
| return sal_True; |
| } |
| |
| sal_Bool SdrMarkView::MarkNextObj(const Point& rPnt, short nTol, sal_Bool bPrev) |
| { |
| SortMarkedObjects(); |
| nTol=ImpGetHitTolLogic(nTol,NULL); |
| Point aPt(rPnt); |
| SdrMark* pTopMarkHit=NULL; |
| SdrMark* pBtmMarkHit=NULL; |
| sal_uIntPtr nTopMarkHit=0; |
| sal_uIntPtr nBtmMarkHit=0; |
| // oberstes der markierten Objekte suchen, das von rPnt getroffen wird |
| sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); |
| sal_uIntPtr nm=0; |
| for (nm=nMarkAnz; nm>0 && pTopMarkHit==NULL;) { |
| nm--; |
| SdrMark* pM=GetSdrMarkByIndex(nm); |
| if(CheckSingleSdrObjectHit(aPt,sal_uInt16(nTol),pM->GetMarkedSdrObj(),pM->GetPageView(),0,0)) |
| { |
| pTopMarkHit=pM; |
| nTopMarkHit=nm; |
| } |
| } |
| // Nichts gefunden, dann ganz normal ein Obj markieren. |
| if (pTopMarkHit==NULL) return MarkObj(rPnt,sal_uInt16(nTol),sal_False); |
| |
| SdrObject* pTopObjHit=pTopMarkHit->GetMarkedSdrObj(); |
| SdrObjList* pObjList=pTopObjHit->GetObjList(); |
| SdrPageView* pPV=pTopMarkHit->GetPageView(); |
| // unterstes der markierten Objekte suchen, das von rPnt getroffen wird |
| // und auf der gleichen PageView liegt wie pTopMarkHit |
| for (nm=0; nm<nMarkAnz && pBtmMarkHit==NULL; nm++) { |
| SdrMark* pM=GetSdrMarkByIndex(nm); |
| SdrPageView* pPV2=pM->GetPageView(); |
| if (pPV2==pPV && CheckSingleSdrObjectHit(aPt,sal_uInt16(nTol),pM->GetMarkedSdrObj(),pPV2,0,0)) |
| { |
| pBtmMarkHit=pM; |
| nBtmMarkHit=nm; |
| } |
| } |
| if (pBtmMarkHit==NULL) { pBtmMarkHit=pTopMarkHit; nBtmMarkHit=nTopMarkHit; } |
| SdrObject* pBtmObjHit=pBtmMarkHit->GetMarkedSdrObj(); |
| sal_uIntPtr nObjAnz=pObjList->GetObjCount(); |
| |
| // #110988# |
| //sal_uIntPtr nSearchBeg=bPrev ? pBtmObjHit->GetOrdNum()+1 : pTopObjHit->GetOrdNum(); |
| sal_uInt32 nSearchBeg; |
| E3dScene* pScene = NULL; |
| SdrObject* pObjHit = (bPrev) ? pBtmObjHit : pTopObjHit; |
| sal_Bool bRemap = pObjHit->ISA(E3dCompoundObject) |
| ? ((E3dCompoundObject*)pObjHit)->IsAOrdNumRemapCandidate(pScene) |
| : sal_False; |
| |
| if(bPrev) |
| { |
| sal_uInt32 nOrdNumBtm(pBtmObjHit->GetOrdNum()); |
| |
| if(bRemap) |
| { |
| nOrdNumBtm = pScene->RemapOrdNum(nOrdNumBtm); |
| } |
| |
| nSearchBeg = nOrdNumBtm + 1; |
| } |
| else |
| { |
| sal_uInt32 nOrdNumTop(pTopObjHit->GetOrdNum()); |
| |
| if(bRemap) |
| { |
| nOrdNumTop = pScene->RemapOrdNum(nOrdNumTop); |
| } |
| |
| nSearchBeg = nOrdNumTop; |
| } |
| |
| sal_uIntPtr no=nSearchBeg; |
| SdrObject* pFndObj=NULL; |
| //SdrObject* pAktObj=NULL; |
| while (pFndObj==NULL && ((!bPrev && no>0) || (bPrev && no<nObjAnz))) { |
| if (!bPrev) no--; |
| SdrObject* pObj; |
| |
| if(bRemap) |
| { |
| pObj = pObjList->GetObj(pScene->RemapOrdNum(no)); |
| } |
| else |
| { |
| pObj = pObjList->GetObj(no); |
| } |
| |
| if (CheckSingleSdrObjectHit(aPt,sal_uInt16(nTol),pObj,pPV,SDRSEARCH_TESTMARKABLE,0)) |
| { |
| if (TryToFindMarkedObject(pObj)==CONTAINER_ENTRY_NOTFOUND) { |
| pFndObj=pObj; |
| } else { |
| // hier wg. Performance ggf. noch no auf Top bzw. auf Btm stellen |
| } |
| } |
| if (bPrev) no++; |
| } |
| if (pFndObj!=NULL) |
| { |
| GetMarkedObjectListWriteAccess().DeleteMark(bPrev?nBtmMarkHit:nTopMarkHit); |
| GetMarkedObjectListWriteAccess().InsertEntry(SdrMark(pFndObj,pPV)); |
| MarkListHasChanged(); |
| AdjustMarkHdl(); //HMHTRUE); |
| } |
| return pFndObj!=NULL; |
| } |
| |
| sal_Bool SdrMarkView::MarkObj(const Rectangle& rRect, sal_Bool bUnmark) |
| { |
| sal_Bool bFnd=sal_False; |
| Rectangle aR(rRect); |
| SdrObject* pObj; |
| SdrObjList* pObjList; |
| BrkAction(); |
| SdrPageView* pPV = GetSdrPageView(); |
| |
| if(pPV) |
| { |
| pObjList=pPV->GetObjList(); |
| Rectangle aFrm1(aR); |
| sal_uIntPtr nObjAnz=pObjList->GetObjCount(); |
| for (sal_uIntPtr nO=0; nO<nObjAnz; nO++) { |
| pObj=pObjList->GetObj(nO); |
| Rectangle aRect(pObj->GetCurrentBoundRect()); |
| if (aFrm1.IsInside(aRect)) { |
| if (!bUnmark) { |
| if (IsObjMarkable(pObj,pPV)) |
| { |
| GetMarkedObjectListWriteAccess().InsertEntry(SdrMark(pObj,pPV)); |
| bFnd=sal_True; |
| } |
| } else { |
| sal_uIntPtr nPos=TryToFindMarkedObject(pObj); |
| if (nPos!=CONTAINER_ENTRY_NOTFOUND) |
| { |
| GetMarkedObjectListWriteAccess().DeleteMark(nPos); |
| bFnd=sal_True; |
| } |
| } |
| } |
| } |
| } |
| if (bFnd) { |
| SortMarkedObjects(); |
| MarkListHasChanged(); |
| AdjustMarkHdl(); //HMHTRUE); |
| //HMHShowMarkHdl(); |
| } |
| return bFnd; |
| } |
| |
| void SdrMarkView::MarkObj(SdrObject* pObj, SdrPageView* pPV, sal_Bool bUnmark, sal_Bool bImpNoSetMarkHdl) |
| { |
| if (pObj!=NULL && pPV!=NULL && IsObjMarkable(pObj, pPV)) { |
| BrkAction(); |
| if (!bUnmark) |
| { |
| GetMarkedObjectListWriteAccess().InsertEntry(SdrMark(pObj,pPV)); |
| } |
| else |
| { |
| sal_uIntPtr nPos=TryToFindMarkedObject(pObj); |
| if (nPos!=CONTAINER_ENTRY_NOTFOUND) |
| { |
| GetMarkedObjectListWriteAccess().DeleteMark(nPos); |
| } |
| } |
| if (!bImpNoSetMarkHdl) { |
| MarkListHasChanged(); |
| AdjustMarkHdl(); //HMHTRUE); |
| //HMHif (!bSomeObjChgdFlag) { |
| // ShowMarkHdl kommt sonst mit dem AfterPaintTimer |
| //HMHShowMarkHdl(); |
| //HMH} |
| } |
| } |
| } |
| |
| sal_Bool SdrMarkView::IsObjMarked(SdrObject* pObj) const |
| { |
| // nicht so ganz die feine Art: Da FindObject() nicht const ist |
| // muss ich mich hier auf non-const casten. |
| sal_uIntPtr nPos=((SdrMarkView*)this)->TryToFindMarkedObject(pObj); |
| return nPos!=CONTAINER_ENTRY_NOTFOUND; |
| } |
| |
| sal_uInt16 SdrMarkView::GetMarkHdlSizePixel() const |
| { |
| return aHdl.GetHdlSize()*2+1; |
| } |
| |
| void SdrMarkView::SetSolidMarkHdl(sal_Bool bOn) |
| { |
| if (bOn!=aHdl.IsFineHdl()) { |
| //HMHBOOL bMerk=IsMarkHdlShown(); |
| //HMHif (bMerk) HideMarkHdl(); |
| aHdl.SetFineHdl(bOn); |
| //HMHif (bMerk) ShowMarkHdl(); |
| } |
| } |
| |
| void SdrMarkView::SetMarkHdlSizePixel(sal_uInt16 nSiz) |
| { |
| if (nSiz<3) nSiz=3; |
| nSiz/=2; |
| if (nSiz!=aHdl.GetHdlSize()) { |
| //HMHBOOL bMerk=IsMarkHdlShown(); |
| //HMHif (bMerk) HideMarkHdl(); |
| aHdl.SetHdlSize(nSiz); |
| //HMHif (bMerk) ShowMarkHdl(); |
| } |
| } |
| |
| #define SDRSEARCH_IMPISMASTER 0x80000000 /* MasterPage wird gerade durchsucht */ |
| SdrObject* SdrMarkView::CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObject* pObj, SdrPageView* pPV, sal_uIntPtr nOptions, const SetOfByte* pMVisLay) const |
| { |
| if(((nOptions & SDRSEARCH_IMPISMASTER) && pObj->IsNotVisibleAsMaster()) || (!pObj->IsVisible())) |
| { |
| return NULL; |
| } |
| |
| const bool bCheckIfMarkable(nOptions & SDRSEARCH_TESTMARKABLE); |
| const bool bDeep(nOptions & SDRSEARCH_DEEP); |
| const bool bOLE(pObj->ISA(SdrOle2Obj)); |
| const bool bTXT(pObj->ISA(SdrTextObj) && ((SdrTextObj*)pObj)->IsTextFrame()); |
| SdrObject* pRet=NULL; |
| Rectangle aRect(pObj->GetCurrentBoundRect()); |
| sal_uInt16 nTol2(nTol); |
| |
| // double tolerance for OLE, text frames and objects in |
| // active text edit |
| if(bOLE || bTXT || pObj==((SdrObjEditView*)this)->GetTextEditObject()) |
| { |
| nTol2*=2; |
| } |
| |
| aRect.Left ()-=nTol2; // Einmal Toleranz drauf fuer alle Objekte |
| aRect.Top ()-=nTol2; |
| aRect.Right ()+=nTol2; |
| aRect.Bottom()+=nTol2; |
| |
| if (aRect.IsInside(rPnt)) |
| { |
| if ((!bCheckIfMarkable || IsObjMarkable(pObj,pPV))) |
| { |
| SdrObjList* pOL=pObj->GetSubList(); |
| |
| if (pOL!=NULL && pOL->GetObjCount()!=0) |
| { |
| SdrObject* pTmpObj; |
| // OD 30.06.2003 #108784# - adjustment hit point for virtual |
| // objects. |
| Point aPnt( rPnt ); |
| |
| if ( pObj->ISA(SdrVirtObj) ) |
| { |
| Point aOffset = static_cast<SdrVirtObj*>(pObj)->GetOffset(); |
| aPnt.Move( -aOffset.X(), -aOffset.Y() ); |
| } |
| |
| pRet=CheckSingleSdrObjectHit(aPnt,nTol,pOL,pPV,nOptions,pMVisLay,pTmpObj); |
| } |
| else |
| { |
| if(!pMVisLay || pMVisLay->IsSet(pObj->GetLayer())) |
| { |
| pRet = SdrObjectPrimitiveHit(*pObj, rPnt, nTol2, *pPV, &pPV->GetVisibleLayers(), false); |
| } |
| } |
| } |
| } |
| |
| if (!bDeep && pRet!=NULL) |
| { |
| pRet=pObj; |
| } |
| |
| return pRet; |
| } |
| |
| SdrObject* SdrMarkView::CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObjList* pOL, SdrPageView* pPV, sal_uIntPtr nOptions, const SetOfByte* pMVisLay, SdrObject*& rpRootObj) const |
| { |
| sal_Bool bBack=(nOptions & SDRSEARCH_BACKWARD)!=0; |
| SdrObject* pRet=NULL; |
| rpRootObj=NULL; |
| if (pOL!=NULL) |
| { |
| // #110988# |
| sal_Bool bRemap(pOL->GetOwnerObj() && pOL->GetOwnerObj()->ISA(E3dScene)); |
| E3dScene* pRemapScene = (bRemap ? (E3dScene*)pOL->GetOwnerObj() : 0L); |
| |
| sal_uIntPtr nObjAnz=pOL->GetObjCount(); |
| sal_uIntPtr nObjNum=bBack ? 0 : nObjAnz; |
| while (pRet==NULL && (bBack ? nObjNum<nObjAnz : nObjNum>0)) { |
| if (!bBack) nObjNum--; |
| SdrObject* pObj; |
| |
| // #110988# |
| if(bRemap) |
| { |
| pObj = pOL->GetObj(pRemapScene->RemapOrdNum(nObjNum)); |
| } |
| else |
| { |
| pObj = pOL->GetObj(nObjNum); |
| } |
| |
| pRet=CheckSingleSdrObjectHit(rPnt,nTol,pObj,pPV,nOptions,pMVisLay); |
| if (pRet!=NULL) rpRootObj=pObj; |
| if (bBack) nObjNum++; |
| } |
| } |
| return pRet; |
| } |
| |
| sal_Bool SdrMarkView::PickObj(const Point& rPnt, short nTol, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr nOptions) const |
| { |
| return PickObj(rPnt,nTol,rpObj,rpPV,nOptions,NULL,NULL,NULL); |
| } |
| |
| sal_Bool SdrMarkView::PickObj(const Point& rPnt, short nTol, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr nOptions, SdrObject** ppRootObj, sal_uIntPtr* pnMarkNum, sal_uInt16* pnPassNum) const |
| { // Fehlt noch Pass2,Pass3 |
| SortMarkedObjects(); |
| if (ppRootObj!=NULL) *ppRootObj=NULL; |
| if (pnMarkNum!=NULL) *pnMarkNum=CONTAINER_ENTRY_NOTFOUND; |
| if (pnPassNum!=NULL) *pnPassNum=0; |
| rpObj=NULL; |
| rpPV=NULL; |
| sal_Bool bWholePage=(nOptions & SDRSEARCH_WHOLEPAGE) !=0; |
| sal_Bool bMarked=(nOptions & SDRSEARCH_MARKED) !=0; |
| sal_Bool bMasters=!bMarked && (nOptions & SDRSEARCH_ALSOONMASTER) !=0; |
| sal_Bool bBack=(nOptions & SDRSEARCH_BACKWARD) !=0; |
| #if OSL_DEBUG_LEVEL > 0 |
| sal_Bool bNext=(nOptions & SDRSEARCH_NEXT) !=0; (void)bNext; // n.i. |
| sal_Bool bBoundCheckOn2ndPass=(nOptions & SDRSEARCH_PASS2BOUND) !=0; (void)bBoundCheckOn2ndPass;// n.i. |
| sal_Bool bCheckNearestOn3rdPass=(nOptions & SDRSEARCH_PASS3NEAREST) !=0; (void)bCheckNearestOn3rdPass;// n.i. |
| #endif |
| if (nTol<0) nTol=ImpGetHitTolLogic(nTol,NULL); |
| Point aPt(rPnt); |
| SdrObject* pObj=NULL; |
| SdrObject* pHitObj=NULL; |
| SdrPageView* pPV=NULL; |
| if (!bBack && ((SdrObjEditView*)this)->IsTextEditFrameHit(rPnt)) { |
| pObj=((SdrObjEditView*)this)->GetTextEditObject(); |
| pHitObj=pObj; |
| pPV=((SdrObjEditView*)this)->GetTextEditPageView(); |
| } |
| if (bMarked) { |
| sal_uIntPtr nMrkAnz=GetMarkedObjectCount(); |
| sal_uIntPtr nMrkNum=bBack ? 0 : nMrkAnz; |
| while (pHitObj==NULL && (bBack ? nMrkNum<nMrkAnz : nMrkNum>0)) { |
| if (!bBack) nMrkNum--; |
| SdrMark* pM=GetSdrMarkByIndex(nMrkNum); |
| pObj=pM->GetMarkedSdrObj(); |
| pPV=pM->GetPageView(); |
| pHitObj=CheckSingleSdrObjectHit(aPt,nTol,pObj,pPV,nOptions,NULL); |
| if (bBack) nMrkNum++; |
| } |
| } |
| else |
| { |
| pPV = GetSdrPageView(); |
| |
| if(pPV) |
| { |
| SdrPage* pPage=pPV->GetPage(); |
| sal_uInt16 nPgAnz=1; |
| |
| if(bMasters && pPage->TRG_HasMasterPage()) |
| { |
| nPgAnz++; |
| } |
| |
| sal_Bool bExtraPassForWholePage=bWholePage && pPage!=pPV->GetObjList(); |
| if (bExtraPassForWholePage) nPgAnz++; // Suche erst in AktObjList, dann auf der gesamten Page |
| sal_uInt16 nPgNum=bBack ? 0 : nPgAnz; |
| while (pHitObj==NULL && (bBack ? nPgNum<nPgAnz : nPgNum>0)) { |
| sal_uIntPtr nTmpOptions=nOptions; |
| if (!bBack) nPgNum--; |
| const SetOfByte* pMVisLay=NULL; |
| SdrObjList* pObjList=NULL; |
| if (pnPassNum!=NULL) *pnPassNum&=~(SDRSEARCHPASS_MASTERPAGE|SDRSEARCHPASS_INACTIVELIST); |
| if (nPgNum>=nPgAnz-1 || (bExtraPassForWholePage && nPgNum>=nPgAnz-2)) |
| { |
| pObjList=pPV->GetObjList(); |
| if (bExtraPassForWholePage && nPgNum==nPgAnz-2) { |
| pObjList=pPage; |
| if (pnPassNum!=NULL) *pnPassNum|=SDRSEARCHPASS_INACTIVELIST; |
| } |
| } |
| else |
| { |
| // sonst MasterPage |
| SdrPage& rMasterPage = pPage->TRG_GetMasterPage(); |
| pMVisLay = &pPage->TRG_GetMasterPageVisibleLayers(); |
| pObjList = &rMasterPage; |
| |
| if (pnPassNum!=NULL) *pnPassNum|=SDRSEARCHPASS_MASTERPAGE; |
| nTmpOptions=nTmpOptions | SDRSEARCH_IMPISMASTER; |
| } |
| pHitObj=CheckSingleSdrObjectHit(aPt,nTol,pObjList,pPV,nTmpOptions,pMVisLay,pObj); |
| if (bBack) nPgNum++; |
| } |
| } |
| } |
| if (pHitObj!=NULL) { |
| if (ppRootObj!=NULL) *ppRootObj=pObj; |
| if ((nOptions & SDRSEARCH_DEEP) !=0) pObj=pHitObj; |
| if ((nOptions & SDRSEARCH_TESTTEXTEDIT) !=0) { |
| if (!pObj->HasTextEdit() || pPV->GetLockedLayers().IsSet(pObj->GetLayer())) { |
| pObj=NULL; |
| } |
| } |
| if (pObj!=NULL && (nOptions & SDRSEARCH_TESTMACRO) !=0) { |
| SdrObjMacroHitRec aHitRec; |
| aHitRec.aPos=aPt; |
| aHitRec.aDownPos=aPt; |
| aHitRec.nTol=nTol; |
| aHitRec.pVisiLayer=&pPV->GetVisibleLayers(); |
| aHitRec.pPageView=pPV; |
| if (!pObj->HasMacro() || !pObj->IsMacroHit(aHitRec)) pObj=NULL; |
| } |
| if (pObj!=NULL && (nOptions & SDRSEARCH_WITHTEXT) !=0 && pObj->GetOutlinerParaObject()==NULL) pObj=NULL; |
| if (pObj!=NULL && (nOptions & SDRSEARCH_TESTTEXTAREA) !=0) |
| { |
| if(!SdrObjectPrimitiveHit(*pObj, aPt, 0, *pPV, 0, true)) |
| { |
| pObj = 0; |
| } |
| } |
| if (pObj!=NULL) { |
| rpObj=pObj; |
| rpPV=pPV; |
| if (pnPassNum!=NULL) *pnPassNum|=SDRSEARCHPASS_DIRECT; |
| } |
| } |
| return rpObj!=NULL; |
| } |
| |
| sal_Bool SdrMarkView::PickMarkedObj(const Point& rPnt, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr* pnMarkNum, sal_uIntPtr nOptions) const |
| { |
| SortMarkedObjects(); |
| sal_Bool bBoundCheckOn2ndPass=(nOptions & SDRSEARCH_PASS2BOUND) !=0; |
| sal_Bool bCheckNearestOn3rdPass=(nOptions & SDRSEARCH_PASS3NEAREST) !=0; |
| rpObj=NULL; |
| rpPV=NULL; |
| if (pnMarkNum!=NULL) *pnMarkNum=CONTAINER_ENTRY_NOTFOUND; |
| Point aPt(rPnt); |
| sal_uInt16 nTol=(sal_uInt16)nHitTolLog; |
| sal_Bool bFnd=sal_False; |
| sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); |
| sal_uIntPtr nMarkNum; |
| for (nMarkNum=nMarkAnz; nMarkNum>0 && !bFnd;) { |
| nMarkNum--; |
| SdrMark* pM=GetSdrMarkByIndex(nMarkNum); |
| SdrPageView* pPV=pM->GetPageView(); |
| SdrObject* pObj=pM->GetMarkedSdrObj(); |
| bFnd = 0 != CheckSingleSdrObjectHit(aPt,nTol,pObj,pPV,SDRSEARCH_TESTMARKABLE,0); |
| if (bFnd) { |
| rpObj=pObj; |
| rpPV=pPV; |
| if (pnMarkNum!=NULL) *pnMarkNum=nMarkNum; |
| } |
| } |
| if ((bBoundCheckOn2ndPass || bCheckNearestOn3rdPass) && !bFnd) { |
| SdrObject* pBestObj=NULL; |
| SdrPageView* pBestPV=NULL; |
| sal_uIntPtr nBestMarkNum=0; |
| sal_uIntPtr nBestDist=ULONG_MAX; |
| for (nMarkNum=nMarkAnz; nMarkNum>0 && !bFnd;) { |
| nMarkNum--; |
| SdrMark* pM=GetSdrMarkByIndex(nMarkNum); |
| SdrPageView* pPV=pM->GetPageView(); |
| SdrObject* pObj=pM->GetMarkedSdrObj(); |
| Rectangle aRect(pObj->GetCurrentBoundRect()); |
| aRect.Left ()-=nTol; |
| aRect.Top ()-=nTol; |
| aRect.Right ()+=nTol; |
| aRect.Bottom()+=nTol; |
| if (aRect.IsInside(aPt)) { |
| bFnd=sal_True; |
| rpObj=pObj; |
| rpPV=pPV; |
| if (pnMarkNum!=NULL) *pnMarkNum=nMarkNum; |
| } else if (bCheckNearestOn3rdPass) { |
| sal_uIntPtr nDist=0; |
| if (aPt.X()<aRect.Left()) nDist+=aRect.Left()-aPt.X(); |
| if (aPt.X()>aRect.Right()) nDist+=aPt.X()-aRect.Right(); |
| if (aPt.Y()<aRect.Top()) nDist+=aRect.Top()-aPt.Y(); |
| if (aPt.Y()>aRect.Bottom()) nDist+=aPt.Y()-aRect.Bottom(); |
| if (nDist<nBestDist) { |
| pBestObj=pObj; |
| pBestPV=pPV; |
| nBestMarkNum=nMarkNum; |
| } |
| } |
| } |
| if (bCheckNearestOn3rdPass && !bFnd) { |
| rpObj=pBestObj; |
| rpPV=pBestPV; |
| if (pnMarkNum!=NULL) *pnMarkNum=nBestMarkNum; |
| bFnd=pBestObj!=NULL; |
| } |
| } |
| return bFnd; |
| } |
| |
| SdrHitKind SdrMarkView::PickSomething(const Point& rPnt, short nTol) const |
| { |
| nTol=ImpGetHitTolLogic(nTol,NULL); |
| SdrHitKind eRet=SDRHIT_NONE; |
| Point aPt(rPnt); |
| SdrObject* pObj=NULL; |
| SdrPageView* pPV=NULL; |
| if (eRet==SDRHIT_NONE && PickObj(rPnt,sal_uInt16(nTol),pObj,pPV,SDRSEARCH_PICKMARKABLE)) { |
| Rectangle aRct1(aPt-Point(nTol,nTol),aPt+Point(nTol,nTol)); // HitRect fuer Toleranz |
| Rectangle aBR(pObj->GetCurrentBoundRect()); |
| if (aRct1.IsInside(aBR.TopLeft())) eRet=SDRHIT_BOUNDTL; |
| else if (aRct1.IsInside(aBR.TopCenter())) eRet=SDRHIT_BOUNDTC; |
| else if (aRct1.IsInside(aBR.TopRight())) eRet=SDRHIT_BOUNDTR; |
| else if (aRct1.IsInside(aBR.LeftCenter())) eRet=SDRHIT_BOUNDCL; |
| else if (aRct1.IsInside(aBR.RightCenter())) eRet=SDRHIT_BOUNDCR; |
| else if (aRct1.IsInside(aBR.BottomLeft())) eRet=SDRHIT_BOUNDBL; |
| else if (aRct1.IsInside(aBR.BottomCenter())) eRet=SDRHIT_BOUNDBC; |
| else if (aRct1.IsInside(aBR.BottomRight())) eRet=SDRHIT_BOUNDBR; |
| else eRet=SDRHIT_OBJECT; |
| } |
| return eRet; |
| } |
| |
| void SdrMarkView::UnmarkAllObj(SdrPageView* pPV) |
| { |
| if (GetMarkedObjectCount()!=0) { |
| BrkAction(); |
| //HMHBOOL bVis=bHdlShown; |
| //HMHif (bVis) HideMarkHdl(); |
| if (pPV!=NULL) |
| { |
| GetMarkedObjectListWriteAccess().DeletePageView(*pPV); |
| } |
| else |
| { |
| GetMarkedObjectListWriteAccess().Clear(); |
| } |
| pMarkedObj=NULL; |
| pMarkedPV=NULL; |
| MarkListHasChanged(); |
| AdjustMarkHdl(); //HMHTRUE); |
| //HMHif (bVis) ShowMarkHdl(); // ggf. fuer die RefPoints |
| } |
| } |
| |
| void SdrMarkView::MarkAllObj(SdrPageView* _pPV) |
| { |
| BrkAction(); |
| //HMHHideMarkHdl(); |
| |
| if(!_pPV) |
| { |
| _pPV = GetSdrPageView(); |
| } |
| |
| // #i69171# _pPV may still be NULL if there is no SDrPageView (!), e.g. when inserting |
| // other files |
| if(_pPV) |
| { |
| const bool bMarkChg(GetMarkedObjectListWriteAccess().InsertPageView(*_pPV)); |
| |
| if(bMarkChg) |
| { |
| MarkListHasChanged(); |
| } |
| } |
| |
| if(GetMarkedObjectCount()) |
| { |
| AdjustMarkHdl(); //HMHTRUE); |
| //HMHShowMarkHdl(); |
| } |
| } |
| |
| void SdrMarkView::AdjustMarkHdl() //HMHBOOL bRestraintPaint) |
| { |
| //HMHBOOL bVis=bHdlShown; |
| //HMHif (bVis) HideMarkHdl(); |
| CheckMarked(); |
| SetMarkRects(); |
| SetMarkHandles(); |
| //HMHif(bRestraintPaint && bVis) |
| //HMH{ |
| //HMH ShowMarkHdl(); |
| //HMH} |
| } |
| |
| Rectangle SdrMarkView::GetMarkedObjBoundRect() const |
| { |
| Rectangle aRect; |
| for (sal_uIntPtr nm=0; nm<GetMarkedObjectCount(); nm++) { |
| SdrMark* pM=GetSdrMarkByIndex(nm); |
| SdrObject* pO=pM->GetMarkedSdrObj(); |
| Rectangle aR1(pO->GetCurrentBoundRect()); |
| if (aRect.IsEmpty()) aRect=aR1; |
| else aRect.Union(aR1); |
| } |
| return aRect; |
| } |
| |
| const Rectangle& SdrMarkView::GetMarkedObjRect() const |
| { |
| if (bMarkedObjRectDirty) { |
| ((SdrMarkView*)this)->bMarkedObjRectDirty=sal_False; |
| Rectangle aRect; |
| for (sal_uIntPtr nm=0; nm<GetMarkedObjectCount(); nm++) { |
| SdrMark* pM=GetSdrMarkByIndex(nm); |
| SdrObject* pO=pM->GetMarkedSdrObj(); |
| Rectangle aR1(pO->GetSnapRect()); |
| if (aRect.IsEmpty()) aRect=aR1; |
| else aRect.Union(aR1); |
| } |
| ((SdrMarkView*)this)->aMarkedObjRect=aRect; |
| } |
| return aMarkedObjRect; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void SdrMarkView::ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, XubString& rStr, sal_uInt16 nVal, sal_uInt16 nOpt) const |
| { |
| rStr = ImpGetResStr(nStrCacheID); |
| xub_StrLen nPos = rStr.SearchAscii("%1"); |
| |
| if(nPos != STRING_NOTFOUND) |
| { |
| rStr.Erase(nPos, 2); |
| |
| if(nOpt == IMPSDR_POINTSDESCRIPTION) |
| { |
| rStr.Insert(GetDescriptionOfMarkedPoints(), nPos); |
| } |
| else if(nOpt == IMPSDR_GLUEPOINTSDESCRIPTION) |
| { |
| rStr.Insert(GetDescriptionOfMarkedGluePoints(), nPos); |
| } |
| else |
| { |
| rStr.Insert(GetDescriptionOfMarkedObjects(), nPos); |
| } |
| } |
| |
| nPos = rStr.SearchAscii("%2"); |
| |
| if(nPos != STRING_NOTFOUND) |
| { |
| rStr.Erase(nPos, 2); |
| rStr.Insert(UniString::CreateFromInt32(nVal), nPos); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| sal_Bool SdrMarkView::EnterMarkedGroup() |
| { |
| sal_Bool bRet=sal_False; |
| // Es wird nur die erste gefundene Gruppe (also nur in einer PageView) geentert |
| // Weil PageView::EnterGroup ein AdjustMarkHdl ruft. |
| // Das muss ich per Flag mal unterbinden vvvvvvvv |
| SdrPageView* pPV = GetSdrPageView(); |
| |
| if(pPV) |
| { |
| sal_Bool bEnter=sal_False; |
| for (sal_uInt32 nm(GetMarkedObjectCount()); nm > 0 && !bEnter;) |
| { |
| nm--; |
| SdrMark* pM=GetSdrMarkByIndex(nm); |
| if (pM->GetPageView()==pPV) { |
| SdrObject* pObj=pM->GetMarkedSdrObj(); |
| if (pObj->IsGroupObject()) { |
| if (pPV->EnterGroup(pObj)) { |
| bRet=sal_True; |
| bEnter=sal_True; |
| } |
| } |
| } |
| } |
| } |
| return bRet; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void SdrMarkView::MarkListHasChanged() |
| { |
| GetMarkedObjectListWriteAccess().SetNameDirty(); |
| SetEdgesOfMarkedNodesDirty(); // bEdgesOfMarkedNodesDirty=sal_True; |
| |
| bMarkedObjRectDirty=sal_True; |
| bMarkedPointsRectsDirty=sal_True; |
| #ifdef DBG_UTIL |
| if (pItemBrowser!=NULL) pItemBrowser->SetDirty(); |
| #endif |
| sal_Bool bOneEdgeMarked=sal_False; |
| if (GetMarkedObjectCount()==1) { |
| const SdrObject* pObj=GetMarkedObjectByIndex(0); |
| if (pObj->GetObjInventor()==SdrInventor) { |
| sal_uInt16 nIdent=pObj->GetObjIdentifier(); |
| bOneEdgeMarked=nIdent==OBJ_EDGE; |
| } |
| } |
| ImpSetGlueVisible4(bOneEdgeMarked); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void SdrMarkView::SetMoveOutside(sal_Bool bOn) |
| { |
| aHdl.SetMoveOutside(bOn); |
| } |
| |
| sal_Bool SdrMarkView::IsMoveOutside() const |
| { |
| return aHdl.IsMoveOutside(); |
| } |
| |
| void SdrMarkView::SetDesignMode( sal_Bool _bOn ) |
| { |
| if ( bDesignMode != _bOn ) |
| { |
| bDesignMode = _bOn; |
| SdrPageView* pPageView = GetSdrPageView(); |
| if ( pPageView ) |
| pPageView->SetDesignMode( _bOn ); |
| } |
| } |
| |
| // MarkHandles Objektaenderung: |
| // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| // - Bei Notify mit HINT_OBJCHG (oder so) werden die Handles erstmal versteckt |
| // (wenn nicht schon wegen Dragging versteckt). |
| // - XorHdl: Bei ModelHasChanged() werden sie dann wieder angezeigt. |
| // - PaintEvents kommen nun durch. |
| // - Die XorHandles werden z.T. wieder uebermalt. |
| // - Xor: Nach dem Painten werden die Handles im (vom PaintHandler gerufenen) |
| // CompleteRedraw per ToggleShownXor bei gesetzter ClipRegion nochmal gemalt |
| // und damit ist alles in Butter. |
| // - ToggleShownXor macht bei SolidHdl nix weil bHdlShown=FALSE |
| // - Der AfterPaintTimer wird gestartet. |
| // - SolidHdl: Im AfterPaintHandler wird ShowMarkHdl gerufen. |
| // Da die Handles zu diesem Zeitpunkt nicht angezeigt sind wird: |
| // - SaveBackground durchgefuehrt. |
| // - DrawMarkHdl gerufen und bHdlShown gesetzt. |
| // |
| // MarkHandles bei sonstigem Invalidate: |
| // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| // In diesem Fall bekomme ich kein Notify und beim Aufruf des |
| // PaintHandlers->CompleteRedraw() sind auch die SolidHandles sichtbar. |
| |