include/svx/svddrgv.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_SVX_SVDDRGV_HXX
  21 #define INCLUDED_SVX_SVDDRGV_HXX
  22
  23 #include <svx/svxdllapi.h>
  24 #include <svx/svdxcgv.hxx>
  25
  26 class SdrUndoGeoObj;
  27
  28 class SVX_DLLPUBLIC SdrDragView: public SdrExchangeView
  29 {
  30     friend class                SdrPageView;
  31     friend class                SdrDragMethod;
  32
  33 protected:
  34     SdrHdl*                     pDragHdl;
  35     SdrDragMethod*              mpCurrentSdrDragMethod;
  36     SdrUndoGeoObj*              pInsPointUndo;
  37     Rectangle                   aDragLimit;
  38     OUString               aInsPointUndoStr;
  39     SdrMarkList                 aFollowingEdges; // If nodes are dragged, all edges should follow as Xor
  40     SdrHdlKind                  eDragHdl;
  41
  42     sal_uIntPtr                     nDragXorPolyLimit;
  43     sal_uIntPtr                     nDragXorPointLimit;
  44     sal_uInt16                      nDetailedEdgeDraggingLimit;
  45
  46     unsigned                    bFramDrag : 1;        // currently frame dragging
  47     unsigned                    bDragSpecial : 1;     // currently Special Obj-dragging
  48     unsigned                    bMarkedHitMovesAlways : 1; // Persistent
  49     unsigned                    bDragLimit : 1;      // Limit on SnapRect instead of BoundRect
  50     unsigned                    bDragHdl : 1;        // TRUE: RefPt is slid
  51     unsigned                    bDragStripes : 1;    // Persistent
  52     unsigned                    bMirrRefDragObj : 1; // Persistent - During the drag, show the mirror axis of the mirrored objects as Xor
  53     unsigned                    mbSolidDragging : 1;  // allow solid create/drag of objects
  54     unsigned                    bMouseHideWhileDraggingPoints : 1;
  55     unsigned                    bResizeAtCenter : 1;
  56     unsigned                    bCrookAtCenter : 1;
  57     unsigned                    bDragWithCopy : 1;
  58     unsigned                    bInsGluePoint : 1;
  59     unsigned                    bInsObjPointMode : 1;
  60     unsigned                    bInsGluePointMode : 1;
  61     unsigned                    bNoDragXorPolys : 1;
  62     unsigned                    bAutoVertexCon : 1;  // Automatische Konnektorgenerierung an den Scheitelpunkten
  63     unsigned                    bAutoCornerCon : 1;  // Automatische Konnektorgenerierung an den Eckpunkten
  64     unsigned                    bRubberEdgeDragging : 1;
  65     unsigned                    bDetailedEdgeDragging : 1;
  66
  67 private:
  68     SVX_DLLPRIVATE void ImpClearVars();
  69
  70 protected:
  71     virtual void SetMarkHandles();
  72     void ShowDragObj();
  73     void HideDragObj();
  74     sal_Bool ImpBegInsObjPoint(sal_Bool bIdxZwang, sal_uInt32 nIdx, const Point& rPnt, sal_Bool bNewObj, OutputDevice* pOut);
  75
  76 protected:
  77     // #i71538# make constructors of SdrView sub-components protected to avoid incomplete incarnations which may get casted to SdrView
  78     SdrDragView(SdrModel* pModel1, OutputDevice* pOut = 0L);
  79     virtual ~SdrDragView();
  80
  81 public:
  82     virtual sal_Bool IsAction() const;
  83     virtual void MovAction(const Point& rPnt);
  84     virtual void EndAction();
  85     virtual void BckAction();
  86     virtual void BrkAction();
  87     virtual void TakeActionRect(Rectangle& rRect) const;
  88
  89     // Spezialimplementation fuer den Writer:
  90     // TakeDragObjAnchorPos() liefert die Position an der ein Objekt
  91     // beim Draggen einer Einfachselektion ungefaehr landet wenn es
  92     // "losgelassen" wird (EndDrag).
  93     // In der Regel ist das die linke obere Ecke des zu erwartenden neuen
  94     // SnapRects. Ausnahme: CaptionObj. Dort ist es die Position des
  95     // "Schwanzendes".
  96     // Bei Returncode sal_False konnte ich die Position nicht bestimmen
  97     // (z.B. Punktverschiebung, Mehrfachselektion, Schieben der
  98     // Spiegelschse, ...)
  99     sal_Bool TakeDragObjAnchorPos(Point& rPos, sal_Bool bTopRight = sal_False ) const;
 100
 101     // Wird pForcedMeth uebergeben, so wird pHdl, ... nicht ausgewerten, sondern diese
 102     // Drag-Methode verwendet. Die Instanz geht dabei ins Eigentum der View ueber und
 103     // wird zum Ende des Draggings destruiert.
 104     virtual sal_Bool BegDragObj(const Point& rPnt, OutputDevice* pOut=NULL, SdrHdl* pHdl=NULL, short nMinMov=-3, SdrDragMethod* pForcedMeth=NULL);
 105     void MovDragObj(const Point& rPnt);
 106     sal_Bool EndDragObj(sal_Bool bCopy=sal_False);
 107     void BrkDragObj();
 108     sal_Bool IsDragObj() const { return mpCurrentSdrDragMethod && !bInsPolyPoint && !bInsGluePoint; }
 109     SdrHdl* GetDragHdl() const { return pDragHdl; }
 110     SdrDragMethod* GetDragMethod() const { return mpCurrentSdrDragMethod; }
 111     sal_Bool IsDraggingPoints() const { return eDragHdl==HDL_POLY; }
 112     sal_Bool IsDraggingGluePoints() const { return eDragHdl==HDL_GLUE; }
 113
 114     // Wer das beim BegDrag oder mittendrin schon festlegen will.
 115     // (Wird bei jedem BegDrag auf sal_False zurueckgesetzt, also nach
 116     // BegDrag setzen.)
 117     void SetDragWithCopy(sal_Bool bOn) { bDragWithCopy = bOn; }
 118     sal_Bool IsDragWithCopy() const { return bDragWithCopy; }
 119
 120     void SetInsertGluePoint(sal_Bool bOn) { bInsGluePoint = bOn; }
 121     sal_Bool IsInsertGluePoint() const { return bInsGluePoint; }
 122
 123     // Interaktives einfuegen eines neuen Punktes. nIdx=0 => vor dem ersten Punkt.
 124     bool IsInsObjPointPossible() const;
 125     sal_Bool BegInsObjPoint(const Point& rPnt, sal_Bool bNewObj) { return ImpBegInsObjPoint(sal_False, 0L, rPnt, bNewObj, 0L); }
 126     void MovInsObjPoint(const Point& rPnt) { MovDragObj(rPnt); }
 127     sal_Bool EndInsObjPoint(SdrCreateCmd eCmd);
 128     void BrkInsObjPoint() { BrkDragObj(); }
 129     sal_Bool IsInsObjPoint() const { return mpCurrentSdrDragMethod && bInsPolyPoint; }
 130
 131     // Fuer die App zum Verwalten des Status. GetPreferedPointer() wird
 132     // spaeter vielleicht einen passenden Pointer dafuer liefern
 133     void SetInsObjPointMode(sal_Bool bOn) { bInsObjPointMode = bOn; }
 134     sal_Bool IsInsObjPointMode() const { return bInsObjPointMode; }
 135
 136     sal_Bool IsInsGluePointPossible() const;
 137     sal_Bool BegInsGluePoint(const Point& rPnt);
 138     void MovInsGluePoint(const Point& rPnt) { MovDragObj(rPnt); }
 139     sal_Bool EndInsGluePoint() { return EndDragObj(); }
 140     void BrkInsGluePoint() { BrkDragObj(); }
 141     sal_Bool IsInsGluePoint() const { return mpCurrentSdrDragMethod && bInsGluePoint; }
 142
 143     // Fuer die App zum Verwalten des Status. GetPreferedPointer() wird
 144     // spaeter vielleicht einen passenden Pointer dafuer liefern
 145     void SetInsGluePointMode(sal_Bool bOn) { bInsGluePointMode = bOn; }
 146     sal_Bool IsInsGluePointMode() const { return bInsGluePointMode; }
 147
 148     // Begrenzungslinien ueber's gesamte Win waehrend des Draggens
 149     // Persistent. Default=FALSE.
 150     void SetDragStripes(sal_Bool bOn);
 151     sal_Bool IsDragStripes() const { return bDragStripes; }
 152
 153     // Handles waehrend des Draggens verstecken
 154     //HMHvoid SetDragHdlHide(sal_Bool bOn);
 155     //HMHBOOL IsDragHdlHide() const { return bNoDragHdl; }
 156
 157     // Beim Draggen von Polygonpunkten und Klebepunkten
 158     // die Maus verstecken. Default=FALSE
 159     void SetMouseHideWhileDraggingPoints(sal_Bool bOn) { bMouseHideWhileDraggingPoints = bOn; }
 160     sal_Bool IsMouseHideWhileDraggingPoints() const { return bMouseHideWhileDraggingPoints; }
 161
 162     // Beim Draggen werden i.d.R. die Konturen der markierten Objekte
 163     // als Xor-Polygone dargestellt. Wird dieses Flag hier gesetzt,
 164     // wird (z.B. bei Mehrfachselektion) nur ein Xor-Frame gezeichnet.
 165     // Bei objektspeziefischem Dragging (Polygonpunkte,Eckenradius,...
 166     // hat diese Einstellung keine Auswirkung.
 167     // Auch waerend des Draggens umschaltbar.
 168     // Default=Off
 169     void SetNoDragXorPolys(sal_Bool bOn);
 170     sal_Bool IsNoDragXorPolys() const { return bNoDragXorPolys; }
 171
 172     // Uebersteigt die Anzahl der markierten Objekte den hier eingestellten
 173     // Wert, wird implizit (temporaer) auf NoDragPolys geschaltet.
 174     // PolyPolygone etc werden entsprechend als mehrere Objekte gewertet.
 175     // Default=100
 176     void  SetDragXorPolyLimit(sal_uIntPtr nObjAnz) { nDragXorPolyLimit=nObjAnz; }
 177     sal_uIntPtr GetDragXorPolyLimit() const { return nDragXorPolyLimit; }
 178
 179     // Wie DragXorPolyLimit, jedoch bezogen auf die Gesamtpunktanzahl
 180     // aller Polygone. Default=500.
 181     // Auf NoDragPolys wird (temporaer) geschaltet, wenn eins der Limits
 182     // ueberstiegen wird.
 183     void  SetDragXorPointLimit(sal_uIntPtr nPntAnz) { nDragXorPointLimit=nPntAnz; }
 184     sal_uIntPtr GetDragXorPointLimit() const { return nDragXorPointLimit; }
 185
 186     void SetSolidDragging(bool bOn);
 187     bool IsSolidDragging() const;
 188
 189     // Dragging/Creating von Verbindern:
 190     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 191     // Verbinder an Objektscheitelpunkte ankleben
 192     // Default=sal_True=Ja
 193     void SetAutoVertexConnectors(sal_Bool bOn) { bAutoVertexCon = bOn; }
 194     sal_Bool IsAutoVertexConnectors() const { return bAutoVertexCon; }
 195
 196     // Verbinder an Objektecken ankleben
 197     // Default=sal_False=Nein
 198     void SetAutoCornerConnectors(sal_Bool bOn) { bAutoCornerCon = bOn; }
 199     sal_Bool IsAutoCornerConnectors() const { return bAutoCornerCon; }
 200
 201     // Dragging von verbundenen Objekten (Nodes):
 202     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 203     // DetailedEdgeDraggingLimit: Wie RubberEdgeDraggingLimit, jedoch bezieht
 204     // sich dieses Limit auf die detalierte Darstellung, d.h. nicht nur
 205     // Gummibaender sondern komplette Neuberechnunen sind beim Draggen sichtbar.
 206     // Diese detalierte Darstellung ist eh nur beim MoveDrag moeglich.
 207     // Defaultwert ist 10
 208     sal_Bool IsDetailedEdgeDragging() const { return bDetailedEdgeDragging; }
 209
 210     sal_uInt16 GetDetailedEdgeDraggingLimit() const { return nDetailedEdgeDraggingLimit; }
 211
 212     // EdgeDraggingLimit: Sind mehr als nEdgeObjAnz Kanten betroffen, werden
 213     // diese beim interaktiven Draggen nicht mit angezeigt.
 214     // Gemeint sind hier die "Gummibaender", die weniger Rechenzeit benoetigen
 215     // als die kompletten Neuberechnungen beim DetailedEdgeDragging.
 216     // Defaultwert ist 100
 217     sal_Bool IsRubberEdgeDragging() const { return bRubberEdgeDragging; }
 218
 219     // Verbinderhandling also zu deutsch wie folgt (bei Defaulteinstellungen):
 220     // - Sind bis max 10 Verbinder betroffen werden diese bei jedem
 221     //   MouseMove neu berechnet
 222     // - Sind zwischen 11 und 100 Verbinder betroffen werden die
 223     //   Verbindungen beim Draggen als gerade Linien dargestellt.
 224     // - Bei mehr als 100 betroffenen Verbindern wird beim Draggen nichts
 225     //   mehr gezeichnet was auf Verbinder hinweist.
 226
 227     // Ist ein spezieller Dragmode eingeschaltet, wie Rotate, Mirror oder Crook,
 228     // dann leitet ein Hit auf das markierte Objekt genau dieses Dragging ein.
 229     // Setzt man MarkedHitMovesAlways auf sal_True, so leitet ein Hit auf das
 230     // markierte Objekt immer ein Moven ein, unabhaengig vom gesetzten DragMode.
 231     // Dieses Flag ist persistent und sollte von der App fuer den Anwender
 232     // konfigurierbar sein!
 233     void SetMarkedHitMovesAlways(sal_Bool bOn) { bMarkedHitMovesAlways = bOn; }
 234     sal_Bool IsMarkedHitMovesAlways() const { return bMarkedHitMovesAlways; }
 235
 236     // Beim Draggen der Spiegelachse das Spiegelbild der markierten Objekte
 237     // als Xor darstellen? Persistent. Noch nicht implementiert. Default TRUE.
 238     void SetMirrRefDragObj(sal_Bool bOn) { bMirrRefDragObj = bOn; }
 239     sal_Bool IsMirrRefDragObj() const { return bMirrRefDragObj; }
 240
 241     sal_Bool IsOrthoDesired() const;
 242
 243     // Beim Resize die Mitte als Referenz
 244     // Default=FALSE.
 245     sal_Bool IsResizeAtCenter() const { return bResizeAtCenter; }
 246     void SetResizeAtCenter(sal_Bool bOn) { bResizeAtCenter = bOn; }
 247
 248     // Symmetrisches Crook
 249     // Default=FALSE.
 250     sal_Bool IsCrookAtCenter() const { return bCrookAtCenter; }
 251     void SetCrookAtCenter(sal_Bool bOn) { bCrookAtCenter = bOn; }
 252
 253     // Begrenzung des Arbeitsbereichs. Die Begrenzung bezieht sich auf die
 254     // View, nicht auf die einzelnen PageViews. Von der View wird diese
 255     // Begrenzung nur bei Interaktionen wie Dragging und Create ausgewertet.
 256     // Bei von der App algorithmisch oder UI-gesteuerte Aktionen (SetGeoAttr,
 257     // MoveMarkedObj, ...) muss die App dieses Limit selbst beruecksichtigen.
 258     // Ferner ist dieses Limit als Grob-Limit zu sehen. U.U. koennen Objekte
 259     // (z.B. beim Drehen) nicht exakt bis an dieses Limit herangedraggt werden,
 260     // koennen Objekte durch Rundungsfehler doch etwas ueberstehen, ... .
 261     // Default=EmptyRect=keine Begrenzung.
 262     // erst z.T. impl.
 263     // (besser in die DragView?)
 264     void SetWorkArea(const Rectangle& rRect) { aMaxWorkArea=rRect; }
 265     const Rectangle& GetWorkArea() const { return aMaxWorkArea; }
 266
 267
 268     // Das DragLimit ist bezogen auf die Page des Objekts.
 269     // (Oder auf die View??? Muss ich mal^^^^recherchieren. Joe.)
 270     // sal_False=Kein Limit.
 271     // Das Rueckgabe-Rect muss absolute Koordinaten enthalten. Der Maximale
 272     // Dragbereich wird von der View dann so gewaehlt, dass das SnapRect des
 273     // Objekts bis Maximal auf die Kante des LimitRects gemoved bzw. gesized
 274     // wird. Bei Objekten wie Bezierkurven, gedrehten Rechtecken ist zu beachten
 275     // das durch anschliessende Neuberechnung des SnapRects (bei Resize)
 276     // Rundungsfehler auftreten koennen, wodurch das LimitRect minnimal
 277     // ueberschritten werden koennte...
 278     // Implementiert fuer Move und Resize.
 279     virtual sal_Bool TakeDragLimit(SdrDragMode eMode, Rectangle& rRect) const;
 280 };
 281
 282 #endif // INCLUDED_SVX_SVDDRGV_HXX
 283
 284 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */