13334a7e6SAndrew Rist /************************************************************** 2cdf0e10cSrcweir * 33334a7e6SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one 43334a7e6SAndrew Rist * or more contributor license agreements. See the NOTICE file 53334a7e6SAndrew Rist * distributed with this work for additional information 63334a7e6SAndrew Rist * regarding copyright ownership. The ASF licenses this file 73334a7e6SAndrew Rist * to you under the Apache License, Version 2.0 (the 83334a7e6SAndrew Rist * "License"); you may not use this file except in compliance 93334a7e6SAndrew Rist * with the License. You may obtain a copy of the License at 103334a7e6SAndrew Rist * 113334a7e6SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0 123334a7e6SAndrew Rist * 133334a7e6SAndrew Rist * Unless required by applicable law or agreed to in writing, 143334a7e6SAndrew Rist * software distributed under the License is distributed on an 153334a7e6SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 163334a7e6SAndrew Rist * KIND, either express or implied. See the License for the 173334a7e6SAndrew Rist * specific language governing permissions and limitations 183334a7e6SAndrew Rist * under the License. 193334a7e6SAndrew Rist * 203334a7e6SAndrew Rist *************************************************************/ 213334a7e6SAndrew Rist 223334a7e6SAndrew Rist 23cdf0e10cSrcweir 24cdf0e10cSrcweir #ifndef _SVDMRKV_HXX 25cdf0e10cSrcweir #define _SVDMRKV_HXX 26cdf0e10cSrcweir 27cdf0e10cSrcweir #include <svx/svdmark.hxx> 28cdf0e10cSrcweir #include <svx/svdhdl.hxx> 29cdf0e10cSrcweir #include <svx/svdsnpv.hxx> 30cdf0e10cSrcweir #include <svx/svdtypes.hxx> 31cdf0e10cSrcweir #include "svx/svxdllapi.h" 32cdf0e10cSrcweir 33cdf0e10cSrcweir //************************************************************ 34cdf0e10cSrcweir // Defines 35cdf0e10cSrcweir //************************************************************ 36cdf0e10cSrcweir 37cdf0e10cSrcweir // folgendes ist noch nicht bzw. erst zum Teil implementiert: 38cdf0e10cSrcweir #define SDRSEARCH_DEEP 0x0001 /* rekursiv in Gruppenobjekte hinein */ 39cdf0e10cSrcweir #define SDRSEARCH_ALSOONMASTER 0x0002 /* MasterPages werden auch durchsucht */ 40cdf0e10cSrcweir #define SDRSEARCH_WHOLEPAGE 0x0004 /* Nicht nur die ObjList der PageView */ 41cdf0e10cSrcweir #define SDRSEARCH_TESTMARKABLE 0x0008 /* nur markierbare Objekte/Punkte/Handles/... */ 42cdf0e10cSrcweir #define SDRSEARCH_TESTMACRO 0x0010 /* Nur Objekte mit Macro */ 43cdf0e10cSrcweir #define SDRSEARCH_TESTTEXTEDIT 0x0020 /* Nur TextEdit-faehige Objekte */ 44cdf0e10cSrcweir #define SDRSEARCH_WITHTEXT 0x0040 /* Nur Objekte mit Text */ 45cdf0e10cSrcweir #define SDRSEARCH_TESTTEXTAREA 0x0080 /* Den Textbereich von Objekten mit Text (TextEditHit) */ 46cdf0e10cSrcweir #define SDRSEARCH_BACKWARD 0x0100 /* Rueckwaertssuche */ 47cdf0e10cSrcweir #define SDRSEARCH_NEXT 0x0200 /* Suche startet hinter dem uebergebenen Objekt/Punkt/... */ 48cdf0e10cSrcweir #define SDRSEARCH_MARKED 0x0400 /* Nur markierte Objekte/Punkte/... */ 49cdf0e10cSrcweir #define SDRSEARCH_PASS2BOUND 0x0800 /* Wenn nix gefunden, dann neuer 2. Versuch mit BoundRectHit */ 50cdf0e10cSrcweir #define SDRSEARCH_PASS3NEAREST 0x1000 /* Wenn nix gefunden, dann neuer 3. Versuch mit NearestBoundRectHit */ 51cdf0e10cSrcweir 52cdf0e10cSrcweir #define SDRSEARCH_PICKMARKABLE (SDRSEARCH_TESTMARKABLE) 53cdf0e10cSrcweir #define SDRSEARCH_PICKTEXTEDIT (SDRSEARCH_DEEP|SDRSEARCH_TESTMARKABLE|SDRSEARCH_TESTTEXTEDIT) 54cdf0e10cSrcweir #define SDRSEARCH_PICKMACRO (SDRSEARCH_DEEP|SDRSEARCH_ALSOONMASTER|SDRSEARCH_WHOLEPAGE|SDRSEARCH_TESTMACRO) 55cdf0e10cSrcweir 56cdf0e10cSrcweir // SDRSEARCHPASS_... ist Rueckgabeparameterwert bei PickObj(). 57cdf0e10cSrcweir #define SDRSEARCHPASS_DIRECT 0x0000 /* Objekt durch direkten Hit getroffen */ 58cdf0e10cSrcweir #define SDRSEARCHPASS_INACTIVELIST 0x0001 /* Obj auf der Page, nicht jedoch in der AktGroup (bei WHOLEPAGE) */ 59cdf0e10cSrcweir #define SDRSEARCHPASS_MASTERPAGE 0x0002 /* Objekt auf der MasterPage gefunden */ 60cdf0e10cSrcweir #define SDRSEARCHPASS_BOUND 0x0010 /* Objekt erst beim Bound-Check gefunden */ 61cdf0e10cSrcweir #define SDRSEARCHPASS_NEAREST 0x0020 /* Objekt erst beim Nearest-Check gefunden */ 62cdf0e10cSrcweir 63cdf0e10cSrcweir enum SdrHitKind {SDRHIT_NONE, // Nicht getroffen, Schnaps gesoffen 64cdf0e10cSrcweir SDRHIT_OBJECT, // Treffer versenkt 65cdf0e10cSrcweir SDRHIT_BOUNDRECT, // Treffer am BoundRect 66cdf0e10cSrcweir SDRHIT_BOUNDTL, // Treffer am BoundRect TopLeft 67cdf0e10cSrcweir SDRHIT_BOUNDTC, // Treffer am BoundRect TopCenter 68cdf0e10cSrcweir SDRHIT_BOUNDTR, // Treffer am BoundRect TopRight 69cdf0e10cSrcweir SDRHIT_BOUNDCL, // Treffer am BoundRect CenterLeft 70cdf0e10cSrcweir SDRHIT_BOUNDCR, // Treffer am BoundRect CenterRight 71cdf0e10cSrcweir SDRHIT_BOUNDBL, // Treffer am BoundRect BottomLeft 72cdf0e10cSrcweir SDRHIT_BOUNDBC, // Treffer am BoundRect BottomCenter 73cdf0e10cSrcweir SDRHIT_BOUNDBR,/*,*/ // Treffer am BoundRect BottomRight 74cdf0e10cSrcweir /*SDRHIT_REFPOINT*/ // Referenzpunkt (Rotationsachse,Spiegelachse) getroffen 75cdf0e10cSrcweir // ab hier neu am 01-07-1996: 76cdf0e10cSrcweir SDRHIT_HANDLE, // Markierungshandle 77cdf0e10cSrcweir SDRHIT_HELPLINE, // Hilfslinie 78cdf0e10cSrcweir SDRHIT_GLUEPOINT, // Klebepunkt 79cdf0e10cSrcweir SDRHIT_TEXTEDIT, // Offene OutlinerView getroffen 80cdf0e10cSrcweir SDRHIT_TEXTEDITOBJ, // Objekt fuer SdrBeginTextEdit (Textbereich) 81cdf0e10cSrcweir SDRHIT_URLFIELD, // Feld im TextObj getroffen (wird gerade nicht editiert) 82cdf0e10cSrcweir SDRHIT_MACRO, // Objekt fuer BegMacroObj 83cdf0e10cSrcweir SDRHIT_MARKEDOBJECT, // Markiertes Objekt (z.B. zum Draggen) 84cdf0e10cSrcweir SDRHIT_UNMARKEDOBJECT, // nichtmarkiertes Objekt (z.B. zum markieren) 85cdf0e10cSrcweir SDRHIT_CELL}; // hit on a cell inside a table shape (outside of the cells text area) 86cdf0e10cSrcweir 87cdf0e10cSrcweir enum SdrViewEditMode {SDREDITMODE_EDIT, // Auch bekannt aus Pfeil- oder Zeigermodus 88cdf0e10cSrcweir SDREDITMODE_CREATE, // Objekterzeugungswerkzeug 89cdf0e10cSrcweir SDREDITMODE_GLUEPOINTEDIT}; // Klebepunkteditiermodus 90cdf0e10cSrcweir 91cdf0e10cSrcweir #define IMPSDR_MARKOBJDESCRIPTION 0x0000 92cdf0e10cSrcweir #define IMPSDR_POINTSDESCRIPTION 0x0001 93cdf0e10cSrcweir #define IMPSDR_GLUEPOINTSDESCRIPTION 0x0002 94cdf0e10cSrcweir 95cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////////////////////////////////// 96cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////////////////////////////////// 97cdf0e10cSrcweir // 98cdf0e10cSrcweir // @@ @@ @@@@ @@@@@ @@ @@ @@ @@ @@ @@@@@ @@ @@ 99cdf0e10cSrcweir // @@@ @@@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ 100cdf0e10cSrcweir // @@@@@@@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @ @@ 101cdf0e10cSrcweir // @@@@@@@ @@@@@@ @@@@@ @@@@ @@@@@ @@ @@@@ @@@@@@@ 102cdf0e10cSrcweir // @@ @ @@ @@ @@ @@ @@ @@ @@ @@@ @@ @@ @@@@@@@ 103cdf0e10cSrcweir // @@ @@ @@ @@ @@ @@ @@ @@ @@@ @@ @@ @@@ @@@ 104cdf0e10cSrcweir // @@ @@ @@ @@ @@ @@ @@ @@ @ @@ @@@@@ @@ @@ 105cdf0e10cSrcweir // 106cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////////////////////////////////// 107cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////////////////////////////////// 108cdf0e10cSrcweir class ImplMarkingOverlay; 109cdf0e10cSrcweir 110cdf0e10cSrcweir class SVX_DLLPUBLIC SdrMarkView : public SdrSnapView 111cdf0e10cSrcweir { 112cdf0e10cSrcweir friend class SdrPageView; 113cdf0e10cSrcweir 114cdf0e10cSrcweir // #114409#-3 Migrate selections 115cdf0e10cSrcweir ImplMarkingOverlay* mpMarkObjOverlay; 116cdf0e10cSrcweir ImplMarkingOverlay* mpMarkPointsOverlay; 117cdf0e10cSrcweir ImplMarkingOverlay* mpMarkGluePointsOverlay; 118cdf0e10cSrcweir 119cdf0e10cSrcweir protected: 120cdf0e10cSrcweir SdrObject* pMarkedObj; // Wenn nur ein Objekt markiert ist. 121cdf0e10cSrcweir SdrPageView* pMarkedPV; // Wenn alle markierten Objekt auf derselben PageView liegen. 122cdf0e10cSrcweir 123cdf0e10cSrcweir Point aRef1; // Persistent - Drehmittelpunkt/Spiegelachse 124cdf0e10cSrcweir Point aRef2; // Persistent 125cdf0e10cSrcweir Point aLastCrookCenter; // Persistent 126cdf0e10cSrcweir SdrHdlList aHdl; 127cdf0e10cSrcweir sdr::ViewSelection* mpSdrViewSelection; 128cdf0e10cSrcweir 129cdf0e10cSrcweir Rectangle aMarkedObjRect; 130cdf0e10cSrcweir Rectangle aMarkedPointsRect; 131cdf0e10cSrcweir Rectangle aMarkedGluePointsRect; 132cdf0e10cSrcweir 133cdf0e10cSrcweir sal_uInt16 nFrameHandlesLimit; 134cdf0e10cSrcweir sal_uIntPtr mnInsPointNum; // Nummer des InsPoint 135cdf0e10cSrcweir sal_uIntPtr nMarkableObjCount; 136cdf0e10cSrcweir 137cdf0e10cSrcweir SdrDragMode eDragMode; // Persistent 138cdf0e10cSrcweir SdrViewEditMode eEditMode; // Persistent 139cdf0e10cSrcweir SdrViewEditMode eEditMode0; // Persistent 140cdf0e10cSrcweir 141cdf0e10cSrcweir //HMHunsigned bHdlShown : 1; 142cdf0e10cSrcweir unsigned bRefHdlShownOnly : 1; // Spiegelachse waerend Dragging (ni) 143cdf0e10cSrcweir unsigned bDesignMode : 1; // DesignMode fuer SdrUnoObj 144cdf0e10cSrcweir unsigned bForceFrameHandles : 1; // Persistent - FrameDrag auch bei Einzelobjekten 145cdf0e10cSrcweir unsigned bPlusHdlAlways : 1; // Persistent 146cdf0e10cSrcweir unsigned bMarkHdlWhenTextEdit : 1; // Persistent, default=FALSE 147cdf0e10cSrcweir unsigned bInsPolyPoint : 1; // z.Zt InsPolyPointDragging 148cdf0e10cSrcweir unsigned bMarkedObjRectDirty : 1; 149cdf0e10cSrcweir unsigned bMrkPntDirty : 1; 150cdf0e10cSrcweir unsigned bMarkedPointsRectsDirty : 1; 151cdf0e10cSrcweir unsigned bMarkableObjCountDirty : 1; 152cdf0e10cSrcweir 153cdf0e10cSrcweir // flag to completely disable handles at the view 154cdf0e10cSrcweir unsigned mbMarkHandlesHidden : 1; 155cdf0e10cSrcweir 156cdf0e10cSrcweir private: 157cdf0e10cSrcweir SVX_DLLPRIVATE void ImpClearVars(); 158cdf0e10cSrcweir SVX_DLLPRIVATE void ImpSetPointsRects() const; 159cdf0e10cSrcweir void UndirtyMrkPnt() const; 160cdf0e10cSrcweir 161cdf0e10cSrcweir protected: 162cdf0e10cSrcweir virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint); 163cdf0e10cSrcweir virtual void ModelHasChanged(); // Wird von der PaintView gerufen 164cdf0e10cSrcweir virtual void SetMarkHandles(); // aHdl (Liste der Handles) fuellen 165cdf0e10cSrcweir virtual void SetMarkRects(); // Rects an den PageViews 166cdf0e10cSrcweir virtual void CheckMarked(); // MarkList nach Del und Lock Layer durchsuchen... 167cdf0e10cSrcweir virtual void AddDragModeHdl(SdrDragMode eMode); 168cdf0e10cSrcweir virtual sal_Bool MouseMove(const MouseEvent& rMEvt, Window* pWin); 169cdf0e10cSrcweir 170cdf0e10cSrcweir // add custom handles (used by other apps, e.g. AnchorPos) 171cdf0e10cSrcweir virtual void AddCustomHdl(); 172cdf0e10cSrcweir 173cdf0e10cSrcweir void ForceRefToMarked(); ForceUndirtyMrkPnt() const174cdf0e10cSrcweir void ForceUndirtyMrkPnt() const { if (bMrkPntDirty) UndirtyMrkPnt(); } 175cdf0e10cSrcweir 176cdf0e10cSrcweir //HMHvoid ImpShowMarkHdl(bool bNoRefHdl); 177cdf0e10cSrcweir virtual SdrObject* CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObject* pObj, SdrPageView* pPV, sal_uIntPtr nOptions, const SetOfByte* pMVisLay) const; 178cdf0e10cSrcweir virtual SdrObject* CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObjList* pOL, SdrPageView* pPV, sal_uIntPtr nOptions, const SetOfByte* pMVisLay, SdrObject*& rpRootObj) const; 179cdf0e10cSrcweir sal_Bool ImpIsFrameHandles() const; 180cdf0e10cSrcweir void ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, String& rStr, sal_uInt16 nVal=0, sal_uInt16 nOpt=0) const; 181cdf0e10cSrcweir 182cdf0e10cSrcweir // Macht aus einer Winkelangabe in 1/100deg einen String inkl. Grad-Zeichen 183cdf0e10cSrcweir sal_Bool ImpMarkPoint(SdrHdl* pHdl, SdrMark* pMark, sal_Bool bUnmark); 184cdf0e10cSrcweir virtual sal_Bool MarkPoints(const Rectangle* pRect, sal_Bool bUnmark); 185cdf0e10cSrcweir sal_Bool MarkGluePoints(const Rectangle* pRect, sal_Bool bUnmark); 186cdf0e10cSrcweir 187cdf0e10cSrcweir void SetMoveOutside(sal_Bool bOn); 188cdf0e10cSrcweir sal_Bool IsMoveOutside() const; 189cdf0e10cSrcweir 190cdf0e10cSrcweir protected: 191cdf0e10cSrcweir // #i71538# make constructors of SdrView sub-components protected to avoid incomplete incarnations which may get casted to SdrView 192cdf0e10cSrcweir SdrMarkView(SdrModel* pModel1, OutputDevice* pOut = 0L); 193cdf0e10cSrcweir virtual ~SdrMarkView(); 194cdf0e10cSrcweir 195cdf0e10cSrcweir public: 196cdf0e10cSrcweir virtual sal_Bool IsAction() const; 197cdf0e10cSrcweir virtual void MovAction(const Point& rPnt); 198cdf0e10cSrcweir virtual void EndAction(); 199cdf0e10cSrcweir virtual void BckAction(); 200cdf0e10cSrcweir virtual void BrkAction(); 201cdf0e10cSrcweir virtual void TakeActionRect(Rectangle& rRect) const; 202cdf0e10cSrcweir 203cdf0e10cSrcweir virtual void ClearPageView(); 204cdf0e10cSrcweir virtual void HideSdrPage(); 205cdf0e10cSrcweir virtual sal_Bool IsObjMarkable(SdrObject* pObj, SdrPageView* pPV) const; 206cdf0e10cSrcweir 207cdf0e10cSrcweir // Liefert sal_True wenn Objekte, Punkte oder Klebepunkte durch Rahmenaufziehen 208cdf0e10cSrcweir // selektiert werden (solange wie der Rahmen aufgezogen wird). IsMarking() const209cdf0e10cSrcweir sal_Bool IsMarking() const { return IsMarkObj() || IsMarkPoints() || IsMarkGluePoints(); } 210cdf0e10cSrcweir 211cdf0e10cSrcweir // Objekte durch Aufziehen eines Selektionsrahmens markieren 212cdf0e10cSrcweir sal_Bool BegMarkObj(const Point& rPnt, sal_Bool bUnmark = sal_False); 213cdf0e10cSrcweir void MovMarkObj(const Point& rPnt); 214cdf0e10cSrcweir sal_Bool EndMarkObj(); 215cdf0e10cSrcweir void BrkMarkObj(); IsMarkObj() const216cdf0e10cSrcweir sal_Bool IsMarkObj() const { return (0L != mpMarkObjOverlay); } 217cdf0e10cSrcweir 218cdf0e10cSrcweir // DragModes: SDRDRAG_CREATE,SDRDRAG_MOVE,SDRDRAG_RESIZE,SDRDRAG_ROTATE,SDRDRAG_MIRROR,SDRDRAG_SHEAR,SDRDRAG_CROOK 219cdf0e10cSrcweir // Move==Resize 220cdf0e10cSrcweir // Das Interface wird hier evtl noch geaendert wg. Ortho-Drag 221cdf0e10cSrcweir void SetDragMode(SdrDragMode eMode); GetDragMode() const222cdf0e10cSrcweir SdrDragMode GetDragMode() const { return eDragMode; } 223cdf0e10cSrcweir sal_Bool ChkDragMode(SdrDragMode eMode) const; 224cdf0e10cSrcweir void SetFrameHandles(sal_Bool bOn); IsFrameHandles() const225cdf0e10cSrcweir sal_Bool IsFrameHandles() const { return bForceFrameHandles; } 226cdf0e10cSrcweir 227cdf0e10cSrcweir // Limit, ab wann implizit auf FrameHandles umgeschaltet wird. default=50. SetFrameHandlesLimit(sal_uInt16 nAnz)228cdf0e10cSrcweir void SetFrameHandlesLimit(sal_uInt16 nAnz) { nFrameHandlesLimit=nAnz; } GetFrameHandlesLimit() const229cdf0e10cSrcweir sal_uInt16 GetFrameHandlesLimit() const { return nFrameHandlesLimit; } 230cdf0e10cSrcweir 231cdf0e10cSrcweir void SetEditMode(SdrViewEditMode eMode); GetEditMode() const232cdf0e10cSrcweir SdrViewEditMode GetEditMode() const { return eEditMode; } 233cdf0e10cSrcweir SetEditMode(sal_Bool bOn=sal_True)234cdf0e10cSrcweir void SetEditMode(sal_Bool bOn=sal_True) { SetEditMode(bOn?SDREDITMODE_EDIT:SDREDITMODE_CREATE); } IsEditMode() const235cdf0e10cSrcweir sal_Bool IsEditMode() const { return eEditMode==SDREDITMODE_EDIT; } SetCreateMode(sal_Bool bOn=sal_True)236cdf0e10cSrcweir void SetCreateMode(sal_Bool bOn=sal_True) { SetEditMode(bOn?SDREDITMODE_CREATE:SDREDITMODE_EDIT); } IsCreateMode() const237cdf0e10cSrcweir sal_Bool IsCreateMode() const { return eEditMode==SDREDITMODE_CREATE; } SetGluePointEditMode(sal_Bool bOn=sal_True)238cdf0e10cSrcweir void SetGluePointEditMode(sal_Bool bOn=sal_True) { SetEditMode(bOn?SDREDITMODE_GLUEPOINTEDIT:eEditMode0); } IsGluePointEditMode() const239cdf0e10cSrcweir sal_Bool IsGluePointEditMode() const { return eEditMode==SDREDITMODE_GLUEPOINTEDIT;; } 240cdf0e10cSrcweir 241cdf0e10cSrcweir void SetDesignMode(sal_Bool bOn=sal_True); IsDesignMode() const242cdf0e10cSrcweir sal_Bool IsDesignMode() const { return bDesignMode; } 243cdf0e10cSrcweir SetFrameDragSingles(sal_Bool bOn=sal_True)244cdf0e10cSrcweir void SetFrameDragSingles(sal_Bool bOn=sal_True) { SetFrameHandles(bOn); } IsFrameDragSingles() const245cdf0e10cSrcweir sal_Bool IsFrameDragSingles() const { return IsFrameHandles(); } 246cdf0e10cSrcweir 247cdf0e10cSrcweir // Feststellen, ob und wo ein Objekt bzw. ob ein Referenzpunkt 248cdf0e10cSrcweir // (Rotationsmittelpunkt,Spiegelachse) getroffen wird (SW special). 249cdf0e10cSrcweir SdrHitKind PickSomething(const Point& rPnt, short nTol=-2) const; 250cdf0e10cSrcweir sal_Bool HasMarkableObj() const; 251cdf0e10cSrcweir sal_uIntPtr GetMarkableObjCount() const; 252cdf0e10cSrcweir //HMHvoid ShowMarkHdl(bool bNoRefHdl = false); 253cdf0e10cSrcweir //HMHvoid HideMarkHdl(bool bNoRefHdl = false); 254cdf0e10cSrcweir //HMHBOOL IsMarkHdlShown() const { return bHdlShown; } 255cdf0e10cSrcweir 256cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////////////////////////////////// 257cdf0e10cSrcweir // migrate selections 258cdf0e10cSrcweir 259cdf0e10cSrcweir protected: 260cdf0e10cSrcweir // all available changing methods GetMarkedObjectListWriteAccess()261cdf0e10cSrcweir SdrMarkList& GetMarkedObjectListWriteAccess() { return mpSdrViewSelection->GetMarkedObjectListWriteAccess(); } SetEdgesOfMarkedNodesDirty()262cdf0e10cSrcweir void SetEdgesOfMarkedNodesDirty() { mpSdrViewSelection->SetEdgesOfMarkedNodesDirty(); } 263cdf0e10cSrcweir 264cdf0e10cSrcweir public: 265cdf0e10cSrcweir // all available const methods for read access to selection GetMarkedObjectList() const266cdf0e10cSrcweir const SdrMarkList& GetMarkedObjectList() const { return mpSdrViewSelection->GetMarkedObjectList(); } TryToFindMarkedObject(const SdrObject * pObj) const267cdf0e10cSrcweir sal_uIntPtr TryToFindMarkedObject(const SdrObject* pObj) const { return GetMarkedObjectList().FindObject(pObj); } GetSdrPageViewOfMarkedByIndex(sal_uIntPtr nNum) const268cdf0e10cSrcweir SdrPageView* GetSdrPageViewOfMarkedByIndex(sal_uIntPtr nNum) const { return GetMarkedObjectList().GetMark(nNum)->GetPageView(); } GetSdrMarkByIndex(sal_uIntPtr nNum) const269cdf0e10cSrcweir SdrMark* GetSdrMarkByIndex(sal_uIntPtr nNum) const { return GetMarkedObjectList().GetMark(nNum); } GetMarkedObjectByIndex(sal_uIntPtr nNum) const270cdf0e10cSrcweir SdrObject* GetMarkedObjectByIndex(sal_uIntPtr nNum) const { return (GetMarkedObjectList().GetMark(nNum))->GetMarkedSdrObj(); } GetMarkedObjectCount() const271cdf0e10cSrcweir sal_uIntPtr GetMarkedObjectCount() const { return GetMarkedObjectList().GetMarkCount(); } SortMarkedObjects() const272cdf0e10cSrcweir void SortMarkedObjects() const { GetMarkedObjectList().ForceSort(); } AreObjectsMarked() const273cdf0e10cSrcweir sal_Bool AreObjectsMarked() const { return (0L != GetMarkedObjectList().GetMarkCount()); } GetDescriptionOfMarkedObjects() const274cdf0e10cSrcweir String GetDescriptionOfMarkedObjects() const { return GetMarkedObjectList().GetMarkDescription(); } GetDescriptionOfMarkedPoints() const275cdf0e10cSrcweir String GetDescriptionOfMarkedPoints() const { return GetMarkedObjectList().GetPointMarkDescription(); } GetDescriptionOfMarkedGluePoints() const276cdf0e10cSrcweir String GetDescriptionOfMarkedGluePoints() const { return GetMarkedObjectList().GetGluePointMarkDescription(); } GetBoundRectFromMarkedObjects(SdrPageView * pPageView,Rectangle & rRect) const277cdf0e10cSrcweir sal_Bool GetBoundRectFromMarkedObjects(SdrPageView* pPageView, Rectangle& rRect) const { return GetMarkedObjectList().TakeBoundRect(pPageView, rRect); } GetSnapRectFromMarkedObjects(SdrPageView * pPageView,Rectangle & rRect) const278cdf0e10cSrcweir sal_Bool GetSnapRectFromMarkedObjects(SdrPageView* pPageView, Rectangle& rRect) const { return GetMarkedObjectList().TakeSnapRect(pPageView, rRect); } 279cdf0e10cSrcweir 280cdf0e10cSrcweir // Eine Liste aller an markierten Knoten gebundenen Kanten holen, 281cdf0e10cSrcweir // die selbst jedoch nicht markiert sind. GetEdgesOfMarkedNodes() const282cdf0e10cSrcweir const SdrMarkList& GetEdgesOfMarkedNodes() const { return mpSdrViewSelection->GetEdgesOfMarkedNodes(); } GetMarkedEdgesOfMarkedNodes() const283cdf0e10cSrcweir const SdrMarkList& GetMarkedEdgesOfMarkedNodes() const { return mpSdrViewSelection->GetMarkedEdgesOfMarkedNodes(); } GetTransitiveHullOfMarkedObjects() const284cdf0e10cSrcweir const List& GetTransitiveHullOfMarkedObjects() const { return mpSdrViewSelection->GetAllMarkedObjects(); } 285cdf0e10cSrcweir 286cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////////////////////////////////// 287cdf0e10cSrcweir 288cdf0e10cSrcweir // mechanism to complete disable handles at the view. Handles will be hidden and deleted 289cdf0e10cSrcweir // when set, no new ones created, no interaction allowed. Handles will be recreated and shown 290cdf0e10cSrcweir // when reset. Default is false. 291cdf0e10cSrcweir void hideMarkHandles(); 292cdf0e10cSrcweir void showMarkHandles(); areMarkHandlesHidden() const293cdf0e10cSrcweir bool areMarkHandlesHidden() const { return mbMarkHandlesHidden; } 294cdf0e10cSrcweir IsMarkedHit(const Point & rPnt,short nTol=-2) const295cdf0e10cSrcweir sal_Bool IsMarkedHit(const Point& rPnt, short nTol=-2) const { return IsMarkedObjHit(rPnt,nTol); } 296cdf0e10cSrcweir sal_Bool IsMarkedObjHit(const Point& rPnt, short nTol=-2) const; 297cdf0e10cSrcweir 298cdf0e10cSrcweir // Pick: Unterstuetzte Optionen fuer nOptions sind SEARCH_NEXT, SEARCH_BACKWARD (ni) 299cdf0e10cSrcweir SdrHdl* PickHandle(const Point& rPnt, sal_uIntPtr nOptions=0, SdrHdl* pHdl0=NULL) const; 300cdf0e10cSrcweir 301cdf0e10cSrcweir // Pick: Unterstuetzte Optionen fuer nOptions sind: 302cdf0e10cSrcweir // SDRSEARCH_DEEP SDRSEARCH_ALSOONMASTER SDRSEARCH_TESTMARKABLE SDRSEARCH_TESTTEXTEDIT 303cdf0e10cSrcweir // SDRSEARCH_WITHTEXT SDRSEARCH_TESTTEXTAREA SDRSEARCH_BACKWARD SDRSEARCH_MARKED 304cdf0e10cSrcweir // SDRSEARCH_WHOLEPAGE 305cdf0e10cSrcweir virtual sal_Bool PickObj(const Point& rPnt, short nTol, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr nOptions, SdrObject** ppRootObj, sal_uIntPtr* pnMarkNum=NULL, sal_uInt16* pnPassNum=NULL) const; 306cdf0e10cSrcweir virtual sal_Bool PickObj(const Point& rPnt, short nTol, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr nOptions=0) const; 307cdf0e10cSrcweir // sal_Bool PickObj(const Point& rPnt, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr nOptions=0) const { return PickObj(rPnt,nHitTolLog,rpObj,rpPV,nOptions); } 308cdf0e10cSrcweir sal_Bool MarkObj(const Point& rPnt, short nTol=-2, sal_Bool bToggle=sal_False, sal_Bool bDeep=sal_False); 309cdf0e10cSrcweir 310cdf0e10cSrcweir // Pick: Unterstuetzte Optionen fuer nOptions sind SDRSEARCH_PASS2BOUND und SDRSEARCH_PASS3NEAREST 311cdf0e10cSrcweir sal_Bool PickMarkedObj(const Point& rPnt, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr* pnMarkNum=NULL, sal_uIntPtr nOptions=0) const; 312cdf0e10cSrcweir 313cdf0e10cSrcweir // Sucht sich das Oberste der markierten Objekte (O1) und sucht von dort 314cdf0e10cSrcweir // aus in Richtung nach Unten dann das erste nichtmarkierte Objekt (O2). 315cdf0e10cSrcweir // Bei Erfolg wird die Markierung von O1 entfernt, an O2 gesetzt und TRUE 316cdf0e10cSrcweir // returniert. Mit dem Parameter bPrev=sal_True geht die Suche genau in die 317cdf0e10cSrcweir // andere Richtung. 318cdf0e10cSrcweir sal_Bool MarkNextObj(sal_Bool bPrev=sal_False); 319cdf0e10cSrcweir 320cdf0e10cSrcweir // Sucht sich das Oberste der markierten Objekte (O1) das von rPnt/nTol 321cdf0e10cSrcweir // getroffen wird und sucht von dort aus in Richtung nach Unten dann das 322cdf0e10cSrcweir // erste nichtmarkierte Objekt (O2). Bei Erfolg wird die Markierung von 323cdf0e10cSrcweir // O1 entfernt, an O2 gesetzt und sal_True returniert. 324cdf0e10cSrcweir // Mit dem Parameter bPrev=sal_True geht die Suche genau in die andere Richtung. 325cdf0e10cSrcweir sal_Bool MarkNextObj(const Point& rPnt, short nTol=-2, sal_Bool bPrev=sal_False); 326cdf0e10cSrcweir 327cdf0e10cSrcweir // Alle Objekte innerhalb eines rechteckigen Bereichs markieren 328cdf0e10cSrcweir // Markiert werden nur Objekte, die vollstaendig eingeschlossen sind. 329cdf0e10cSrcweir sal_Bool MarkObj(const Rectangle& rRect, sal_Bool bUnmark=sal_False); 330cdf0e10cSrcweir void MarkObj(SdrObject* pObj, SdrPageView* pPV, sal_Bool bUnmark=sal_False, sal_Bool bImpNoSetMarkHdl=sal_False); 331cdf0e10cSrcweir void MarkAllObj(SdrPageView* pPV=NULL); // pPage=NULL => alle angezeigten Seiten 332cdf0e10cSrcweir void UnmarkAllObj(SdrPageView* pPV=NULL); // pPage=NULL => alle angezeigten Seiten 333cdf0e10cSrcweir 334cdf0e10cSrcweir // Diese Funktion kostet etwas Zeit, da die MarkList durchsucht werden muss. 335cdf0e10cSrcweir sal_Bool IsObjMarked(SdrObject* pObj) const; 336cdf0e10cSrcweir // void MarkAll(SdrPageView* pPV=NULL) { MarkAllObj(pPV); } -> replace with inline UnMarkAll(SdrPageView * pPV=NULL)337cdf0e10cSrcweir void UnMarkAll(SdrPageView* pPV=NULL) { UnmarkAllObj(pPV); } 338cdf0e10cSrcweir 339cdf0e10cSrcweir // Groesse der Markierungs-Handles abfragen/setzen. Angabe in Pixel. 340cdf0e10cSrcweir // Der Wert ist als Kantenlaenge zu betrachten. Gerade Werte werden 341cdf0e10cSrcweir // auf Ungerade aufgerundet: 3->3, 4->5, 5->5, 6->7, 7->7, ... 342cdf0e10cSrcweir // Defaultwert ist 7, Mindestwert 3 Pixel. 343cdf0e10cSrcweir sal_uInt16 GetMarkHdlSizePixel() const; 344cdf0e10cSrcweir void SetMarkHdlSizePixel(sal_uInt16 nSiz); 345cdf0e10cSrcweir 346cdf0e10cSrcweir // Die Groesse der Markierungs-Handles wird ueber die jeweilige Aufloesung 347cdf0e10cSrcweir // und die Groesse des Bereichs der markierten Objekte so angepasst, dass 348cdf0e10cSrcweir // sie sich bei einer Frame-Selektion moeglichst nicht ueberschneiden. 349cdf0e10cSrcweir // Dazu muessen die Handles ggf. verkleinert dargestellt werden. Mit der 350cdf0e10cSrcweir // MinMarkHdlSize kann man hierfuer eine Mindestgroesse angeben. 351cdf0e10cSrcweir // Defaultwert ist 3, Mindestwert 3 Pixel. IsSolidMarkHdl() const352cdf0e10cSrcweir sal_Bool IsSolidMarkHdl() const { return aHdl.IsFineHdl(); } 353cdf0e10cSrcweir void SetSolidMarkHdl(sal_Bool bOn); 354cdf0e10cSrcweir 355cdf0e10cSrcweir virtual sal_Bool HasMarkablePoints() const; 356cdf0e10cSrcweir virtual sal_uIntPtr GetMarkablePointCount() const; 357cdf0e10cSrcweir virtual sal_Bool HasMarkedPoints() const; 358cdf0e10cSrcweir virtual sal_uIntPtr GetMarkedPointCount() const; 359cdf0e10cSrcweir 360cdf0e10cSrcweir // Nicht alle Punkte lassen sich markieren: 361cdf0e10cSrcweir virtual sal_Bool IsPointMarkable(const SdrHdl& rHdl) const; 362cdf0e10cSrcweir virtual sal_Bool MarkPoint(SdrHdl& rHdl, sal_Bool bUnmark=sal_False); 363cdf0e10cSrcweir 364cdf0e10cSrcweir /** should only be used from outside svx for special ui elements */ 365cdf0e10cSrcweir sal_Bool MarkPointHelper(SdrHdl* pHdl, SdrMark* pMark, sal_Bool bUnmark); 366cdf0e10cSrcweir 367cdf0e10cSrcweir // alle Punkte innerhalb dieses Rechtecks markieren (Viewkoordinaten) MarkPoints(const Rectangle & rRect,sal_Bool bUnmark=sal_False)368cdf0e10cSrcweir sal_Bool MarkPoints(const Rectangle& rRect, sal_Bool bUnmark=sal_False) { return MarkPoints(&rRect,bUnmark); } UnmarkPoint(SdrHdl & rHdl)369cdf0e10cSrcweir sal_Bool UnmarkPoint(SdrHdl& rHdl) { return MarkPoint(rHdl,sal_True); } UnMarkPoint(SdrHdl & rHdl)370cdf0e10cSrcweir sal_Bool UnMarkPoint(SdrHdl& rHdl) { return MarkPoint(rHdl,sal_True); } IsPointMarked(const SdrHdl & rHdl) const371cdf0e10cSrcweir sal_Bool IsPointMarked(const SdrHdl& rHdl) const { ForceUndirtyMrkPnt(); return &rHdl!=NULL && rHdl.IsSelected(); } MarkAllPoints()372cdf0e10cSrcweir sal_Bool MarkAllPoints() { return MarkPoints(NULL,sal_False); } UnmarkAllPoints()373cdf0e10cSrcweir sal_Bool UnmarkAllPoints() { return MarkPoints(NULL,sal_True); } UnMarkAllPoints()374cdf0e10cSrcweir sal_Bool UnMarkAllPoints() { return MarkPoints(NULL,sal_True); } 375cdf0e10cSrcweir 376cdf0e10cSrcweir // Sucht sich den ersten markierten Punkt (P1) und sucht von dort 377cdf0e10cSrcweir // aus in den ersten nichtmarkierte Punkt (P2). 378cdf0e10cSrcweir // Bei Erfolg wird die Markierung von P1 entfernt, an P2 gesetzt und TRUE 379cdf0e10cSrcweir // returniert. Mit dem Parameter bPrev=sal_True geht die Suche genau in die 380cdf0e10cSrcweir // andere Richtung. 381cdf0e10cSrcweir sal_Bool MarkNextPoint(sal_Bool bPrev=sal_False); 382cdf0e10cSrcweir 383cdf0e10cSrcweir // Sucht sich den ersten markierten Punkt (P1) das von rPnt 384cdf0e10cSrcweir // getroffen wird und sucht von dort aus den 385cdf0e10cSrcweir // ersten nichtmarkierten Punkt (P2). Bei Erfolg wird die Markierung von 386cdf0e10cSrcweir // P1 entfernt, an P2 gesetzt und sal_True returniert. 387cdf0e10cSrcweir // Mit dem Parameter bPrev=sal_True geht die Suche genau in die andere Richtung. 388cdf0e10cSrcweir sal_Bool MarkNextPoint(const Point& rPnt, sal_Bool bPrev=sal_False); 389cdf0e10cSrcweir 390cdf0e10cSrcweir // Die Nummer des passenden Handles raussuchen. Nicht gefunden 391cdf0e10cSrcweir // liefert CONTAINER_ENTRY_NOTFOUND. GetHdlNum(SdrHdl * pHdl) const392cdf0e10cSrcweir sal_uIntPtr GetHdlNum(SdrHdl* pHdl) const { return aHdl.GetHdlNum(pHdl); } GetHdl(sal_uIntPtr nHdlNum) const393cdf0e10cSrcweir SdrHdl* GetHdl(sal_uIntPtr nHdlNum) const { return aHdl.GetHdl(nHdlNum); } GetHdlList() const394cdf0e10cSrcweir const SdrHdlList& GetHdlList() const { return aHdl; } 395cdf0e10cSrcweir 396cdf0e10cSrcweir // Selektionsrahmen fuer Punktmarkierung aufziehen. 397cdf0e10cSrcweir // Wird nur gestartet, wenn HasMarkablePoints() sal_True liefert. 398cdf0e10cSrcweir // sal_Bool BegMarkPoints(const Point& rPnt, OutputDevice* pOut); 399cdf0e10cSrcweir sal_Bool BegMarkPoints(const Point& rPnt, sal_Bool bUnmark = sal_False); 400cdf0e10cSrcweir void MovMarkPoints(const Point& rPnt); 401cdf0e10cSrcweir sal_Bool EndMarkPoints(); 402cdf0e10cSrcweir void BrkMarkPoints(); IsMarkPoints() const403cdf0e10cSrcweir sal_Bool IsMarkPoints() const { return (0L != mpMarkPointsOverlay); } 404cdf0e10cSrcweir 405cdf0e10cSrcweir // Zusatzhandles dauerhaft sichtbar schalten 406cdf0e10cSrcweir void SetPlusHandlesAlwaysVisible(sal_Bool bOn); IsPlusHandlesAlwaysVisible() const407cdf0e10cSrcweir sal_Bool IsPlusHandlesAlwaysVisible() const { return bPlusHdlAlways; } 408cdf0e10cSrcweir 409cdf0e10cSrcweir // Handles sichrbar waerend TextEdit (in doppelter Groesse)? 410cdf0e10cSrcweir // Persistent, default=FALSE SetMarkHdlWhenTextEdit(sal_Bool bOn)411cdf0e10cSrcweir void SetMarkHdlWhenTextEdit(sal_Bool bOn) { bMarkHdlWhenTextEdit=bOn; } IsMarkHdlWhenTextEdit() const412cdf0e10cSrcweir sal_Bool IsMarkHdlWhenTextEdit() const { return bMarkHdlWhenTextEdit; } 413cdf0e10cSrcweir 414cdf0e10cSrcweir sal_Bool HasMarkableGluePoints() const; 415cdf0e10cSrcweir sal_uIntPtr GetMarkableGluePointCount() const; 416cdf0e10cSrcweir sal_Bool HasMarkedGluePoints() const; 417cdf0e10cSrcweir sal_uIntPtr GetMarkedGluePointCount() const; 418cdf0e10cSrcweir 419cdf0e10cSrcweir // Ein Klebepunkt wird eindeutig identifiziert durch das SdrObject 420cdf0e10cSrcweir // (dem er zugehoert) sowie einem sal_uInt16 nId (da jedes SdrObject je 421cdf0e10cSrcweir // mehrere Klebepunkte haben kann. Hier an der View kommt zudem noch 422cdf0e10cSrcweir // eine SdrPageView, die stets korrekt gesetzt sein sollte. 423cdf0e10cSrcweir // Alternativ kann ein Klebepunkt durch ein SdrHdl bezeichnet werden. 424cdf0e10cSrcweir // Die SdrHdl-Instanz beinhaltet dann aller erforderlichen Informationen. 425cdf0e10cSrcweir // Der Klebepunkt ist in diesem Fall dann zwangslaeufig markiert (nur auf 426cdf0e10cSrcweir // markierten Klebepunkten sitzen Anfasser). 427cdf0e10cSrcweir // Achtung: Bei jeder Aenderung des Klebepunktmarkierungsstatus wird die 428cdf0e10cSrcweir // Handleliste erneut berechnet. Alle vorher gemerkten SdrHdl* sind 429cdf0e10cSrcweir // damit ungueltig, ebenso die Punkt-Id's! 430cdf0e10cSrcweir // Pick: Unterstuetzte Optionen fuer nOptions sind SEARCH_NEXT, SEARCH_BACKWARD 431cdf0e10cSrcweir sal_Bool PickGluePoint(const Point& rPnt, SdrObject*& rpObj, sal_uInt16& rnId, SdrPageView*& rpPV, sal_uIntPtr nOptions=0) const; 432cdf0e10cSrcweir sal_Bool MarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, const SdrPageView* pPV, sal_Bool bUnmark=sal_False); UnmarkGluePoint(const SdrObject * pObj,sal_uInt16 nId,const SdrPageView * pPV)433cdf0e10cSrcweir sal_Bool UnmarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, const SdrPageView* pPV) { return MarkGluePoint(pObj,nId,pPV,sal_True); } 434cdf0e10cSrcweir sal_Bool IsGluePointMarked(const SdrObject* pObj, sal_uInt16 nId) const; 435cdf0e10cSrcweir sal_Bool UnmarkGluePoint(const SdrHdl& rHdl); 436cdf0e10cSrcweir 437cdf0e10cSrcweir // Hdl eines markierten GluePoints holen. Nicht markierte 438cdf0e10cSrcweir // GluePoints haben keine Handles 439cdf0e10cSrcweir SdrHdl* GetGluePointHdl(const SdrObject* pObj, sal_uInt16 nId) const; IsGluePoint(const SdrHdl & rHdl) const440cdf0e10cSrcweir sal_Bool IsGluePoint(const SdrHdl& rHdl) const { return &rHdl!=NULL && rHdl.GetKind()==HDL_GLUE; } 441cdf0e10cSrcweir 442cdf0e10cSrcweir // alle Punkte innerhalb dieses Rechtecks markieren (Viewkoordinaten) MarkGluePoints(const Rectangle & rRect)443cdf0e10cSrcweir sal_Bool MarkGluePoints(const Rectangle& rRect) { return MarkGluePoints(&rRect,sal_False); } UnmarkGluePoints(const Rectangle & rRect)444cdf0e10cSrcweir sal_Bool UnmarkGluePoints(const Rectangle& rRect) { return MarkGluePoints(&rRect,sal_True); } MarkAllGluePoints()445cdf0e10cSrcweir sal_Bool MarkAllGluePoints() { return MarkGluePoints(NULL,sal_False); } UnmarkAllGluePoints()446cdf0e10cSrcweir sal_Bool UnmarkAllGluePoints() { return MarkGluePoints(NULL,sal_True); } 447cdf0e10cSrcweir 448cdf0e10cSrcweir // Sucht sich den ersten markierten Klebepunkt (P1) und sucht von dort 449cdf0e10cSrcweir // aus in den ersten nichtmarkierte Klebepunkt (P2). 450cdf0e10cSrcweir // Bei Erfolg wird die Markierung von P1 entfernt, an P2 gesetzt und TRUE 451cdf0e10cSrcweir // returniert. Mit dem Parameter bPrev=sal_True geht die Suche genau in die 452cdf0e10cSrcweir // andere Richtung. 453cdf0e10cSrcweir sal_Bool MarkNextGluePoint(sal_Bool bPrev=sal_False); 454cdf0e10cSrcweir 455cdf0e10cSrcweir // Sucht sich den ersten markierten Klebepunkt (P1) das von rPnt 456cdf0e10cSrcweir // getroffen wird und sucht von dort aus den 457cdf0e10cSrcweir // ersten nichtmarkierten Klebepunkt (P2). Bei Erfolg wird die Markierung 458cdf0e10cSrcweir // von P1 entfernt, an P2 gesetzt und sal_True returniert. 459cdf0e10cSrcweir // Mit dem Parameter bPrev=sal_True geht die Suche genau in die andere Richtung. 460cdf0e10cSrcweir sal_Bool MarkNextGluePoint(const Point& rPnt, sal_Bool bPrev=sal_False); 461cdf0e10cSrcweir 462cdf0e10cSrcweir // Selektionsrahmen fuer Klebepunktmarkierung aufziehen. 463cdf0e10cSrcweir // Wird nur gestartet, wenn HasMarkableGluePoints() sal_True liefert. 464cdf0e10cSrcweir // Der GlueEditMode sal_True wird nicht abgefragt. 465cdf0e10cSrcweir // sal_Bool BegMarkGluePoints(const Point& rPnt, OutputDevice* pOut); 466cdf0e10cSrcweir sal_Bool BegMarkGluePoints(const Point& rPnt, sal_Bool bUnmark = sal_False); 467cdf0e10cSrcweir void MovMarkGluePoints(const Point& rPnt); 468cdf0e10cSrcweir sal_Bool EndMarkGluePoints(); 469cdf0e10cSrcweir void BrkMarkGluePoints(); IsMarkGluePoints() const470cdf0e10cSrcweir sal_Bool IsMarkGluePoints() const { return (0L != mpMarkGluePointsOverlay); } 471cdf0e10cSrcweir 472cdf0e10cSrcweir // bRestraintPaint=sal_False bewirkt, dass die Handles nicht sofort wieder gemalt werden. 473cdf0e10cSrcweir // AdjustMarkHdl wird eh' nur gerufen, wenn was geaendert wurde; was idR ein Invalidate 474cdf0e10cSrcweir // zur Folge hat. Am Ende von des Redraw werden die Handles automatisch gezeichnet. 475cdf0e10cSrcweir // Der Zweck ist, unnoetiges Flackern zu vermeiden. -> Funkt noch nich, deshalb sal_True! 476cdf0e10cSrcweir void AdjustMarkHdl(); //HMHBOOL bRestraintPaint=sal_True); 477cdf0e10cSrcweir 478cdf0e10cSrcweir const Rectangle& GetMarkedObjRect() const; // SnapRects der Objekte, ohne Strichstaerke 479cdf0e10cSrcweir Rectangle GetMarkedObjBoundRect() const; // inkl. Strichstaerke, ueberstehende Fetzen, ... 480cdf0e10cSrcweir const Rectangle& GetMarkedPointsRect() const; // Umschliessendes Rechteck aller markierten Punkte 481cdf0e10cSrcweir const Rectangle& GetMarkedGluePointsRect() const; // Umschliessendes Rechteck aller markierten Klebepunkte GetAllMarkedRect() const482cdf0e10cSrcweir const Rectangle& GetAllMarkedRect() const { return GetMarkedObjRect(); } GetAllMarkedBoundRect() const483cdf0e10cSrcweir Rectangle GetAllMarkedBoundRect() const { return GetMarkedObjBoundRect(); } GetAllMarkedPointsRect() const484cdf0e10cSrcweir const Rectangle& GetAllMarkedPointsRect() const { return GetMarkedPointsRect(); } 485cdf0e10cSrcweir 486cdf0e10cSrcweir // Wird immer dann gerufen, wenn sich die Liste der markierten Objekte 487cdf0e10cSrcweir // moeglicherweise geaendert hat. Wer ueberlaed muss unbedingt auch die 488cdf0e10cSrcweir // Methode der Basisklasse rufen! 489cdf0e10cSrcweir virtual void MarkListHasChanged(); 490cdf0e10cSrcweir 491cdf0e10cSrcweir // Betreten (Editieren) einer evtl markierten Objektgruppe. Sind mehrere 492cdf0e10cSrcweir // Objektgruppen markiert, so wird die Oberste genommen. Anschliessend 493cdf0e10cSrcweir // liegen alle Memberobjekte der Gruppe im direkten Zugriff. Alle anderen 494cdf0e10cSrcweir // Objekte koennen waerendessen nicht bearbeitet werden (bis zum naechsten 495cdf0e10cSrcweir // LeaveGroup()). Bei einer seitenuebergreifenden Markierung wird jede Page 496cdf0e10cSrcweir // separat abgearbeitet. Die Methode liefert sal_True, wenn wenigstens eine 497cdf0e10cSrcweir // Gruppe betreten wurde. 498cdf0e10cSrcweir sal_Bool EnterMarkedGroup(); 499cdf0e10cSrcweir 500cdf0e10cSrcweir // Den Mittelpunkt des letzten Crook-Dragging abholen. Den kann man 501cdf0e10cSrcweir // bei einem anschliessenden Rotate sinnvoll als Drehmittelpunkt setzen. GetLastCrookCenter() const502cdf0e10cSrcweir const Point& GetLastCrookCenter() const { return aLastCrookCenter; } 503cdf0e10cSrcweir 504cdf0e10cSrcweir // Wird automatisch von der DragView beim beenden eines Crook-Drag gesetzt. SetLastCrookCenter(const Point & rPt)505cdf0e10cSrcweir void SetLastCrookCenter(const Point& rPt) { aLastCrookCenter=rPt; } 506cdf0e10cSrcweir 507cdf0e10cSrcweir // Rotationsmittelpunkt bzw. Startpunkt der Spiegelachse GetRef1() const508cdf0e10cSrcweir const Point& GetRef1() const { return aRef1; } 509cdf0e10cSrcweir void SetRef1(const Point& rPt); 510cdf0e10cSrcweir 511cdf0e10cSrcweir // Endpunkt der Spiegelachse GetRef2() const512cdf0e10cSrcweir const Point& GetRef2() const { return aRef1; } 513cdf0e10cSrcweir void SetRef2(const Point& rPt); 514*9b8096d0SSteve Yin void UnmarkObj(SdrObject* pObj); 515cdf0e10cSrcweir }; 516cdf0e10cSrcweir 517cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////////////////////////////////// 518cdf0e10cSrcweir // 519cdf0e10cSrcweir // - Hit-Toleranzen: 520cdf0e10cSrcweir // Die muessen natuerlich immer in logischen Koordinaten angegeben werden. Also 521cdf0e10cSrcweir // immer brav den gewuenschten Pixelwert mit PixelToLogic in Logischen umrechnen. 522cdf0e10cSrcweir // Angenommen ein Wert 100 (logisch) 523cdf0e10cSrcweir // - Bei einer waagerechten Haarlinie (Objekt mit Hoehe 0) waere dann +/-100, 524cdf0e10cSrcweir // also ein vertikaler Bereich von 200 logischen Einheiten sensitiv. 525cdf0e10cSrcweir // - Bei Polygonen wird ein Rect mit der Groesse (200,200) generiert und ein 526cdf0e10cSrcweir // Touch-Test zwischen Poly und diesem Rect durchgefuehrt. 527cdf0e10cSrcweir // - Eine Sonderbehandlung erfahren Objekte, die bei SdrObject::HasEdit()==TRUE 528cdf0e10cSrcweir // liefern (z.B. Textrahmen). Hierbei wird ein weiterer sensitiver Bereich mit 529cdf0e10cSrcweir // einer Breite von 2*Tol (in diesem Beispiel also 200 Einheiten) um das Objekt 530cdf0e10cSrcweir // herumgelegt. Waerend ein Hit direkt ins Objekt die Edit-Methode ruft, 531cdf0e10cSrcweir // ermoeglicht ein Hit in den umliegenden sensitiven Bereich ein Dragging. 532cdf0e10cSrcweir // 533cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////////////////////////////////// 534cdf0e10cSrcweir 535cdf0e10cSrcweir #endif //_SVDMRKV_HXX 536cdf0e10cSrcweir 537