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