| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef _SVDDRGV_HXX |
| #define _SVDDRGV_HXX |
| |
| #include "svx/svxdllapi.h" |
| #include <svx/svdxcgv.hxx> |
| |
| //************************************************************ |
| // Vorausdeklarationen |
| //************************************************************ |
| |
| class SdrUndoGeoObj; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // |
| // @@@@@ @@@@@ @@@@ @@@@ @@ @@ @@ @@@@@ @@ @@ |
| // @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ |
| // @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @ @@ |
| // @@ @@ @@@@@ @@@@@@ @@ @@@ @@@@@ @@ @@@@ @@@@@@@ |
| // @@ @@ @@ @@ @@ @@ @@ @@ @@@ @@ @@ @@@@@@@ |
| // @@ @@ @@ @@ @@ @@ @@ @@ @@@ @@ @@ @@@ @@@ |
| // @@@@@ @@ @@ @@ @@ @@@@@ @ @@ @@@@@ @@ @@ |
| // |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| class ImpSdrDragViewExtraData; |
| |
| class SVX_DLLPUBLIC SdrDragView: public SdrExchangeView |
| { |
| friend class SdrPageView; |
| friend class SdrDragMethod; |
| |
| protected: |
| SdrHdl* pDragHdl; |
| SdrDragMethod* mpCurrentSdrDragMethod; |
| SdrUndoGeoObj* pInsPointUndo; |
| Rectangle aDragLimit; |
| XubString aInsPointUndoStr; |
| SdrMarkList aFollowingEdges; // Wenn Knoten gedraggd werden, sollen alle Kanten als Xor folgen |
| SdrHdlKind eDragHdl; |
| |
| sal_uIntPtr nDragXorPolyLimit; |
| sal_uIntPtr nDragXorPointLimit; |
| sal_uInt16 nRubberEdgeDraggingLimit; |
| sal_uInt16 nDetailedEdgeDraggingLimit; |
| |
| unsigned bFramDrag : 1; // z.Zt. FrameDrag |
| unsigned bDragSpecial : 1; // z.Zt. Special Obj-Dragging |
| unsigned bMarkedHitMovesAlways : 1; // Persistent |
| unsigned bDragLimit : 1; // Limit auf SnapRect statt BoundRect |
| unsigned bDragHdl : 1; // TRUE: RefPt wird verschoben |
| unsigned bDragStripes : 1; // Persistent |
| unsigned bMirrRefDragObj : 1; // Persistent - Waehrend des Draggens der Spiegelachse die gespiegelten Objekte als Xor zeigen |
| unsigned mbSolidDragging : 1; // allow solid create/drag of objects |
| unsigned bMouseHideWhileDraggingPoints : 1; |
| unsigned bResizeAtCenter : 1; |
| unsigned bCrookAtCenter : 1; |
| unsigned bDragWithCopy : 1; |
| unsigned bInsGluePoint : 1; |
| unsigned bInsObjPointMode : 1; |
| unsigned bInsGluePointMode : 1; |
| unsigned bNoDragXorPolys : 1; |
| unsigned bAutoVertexCon : 1; // Automatische Konnektorgenerierung an den Scheitelpunkten |
| unsigned bAutoCornerCon : 1; // Automatische Konnektorgenerierung an den Eckpunkten |
| unsigned bRubberEdgeDragging : 1; |
| unsigned bDetailedEdgeDragging : 1; |
| |
| private: |
| SVX_DLLPRIVATE void ImpClearVars(); |
| SVX_DLLPRIVATE void ImpMakeDragAttr(); |
| SVX_DLLPRIVATE void ImpDelDragAttr(); |
| |
| protected: |
| virtual void SetMarkHandles(); |
| void ShowDragObj(); |
| void HideDragObj(); |
| sal_Bool ImpBegInsObjPoint(sal_Bool bIdxZwang, sal_uInt32 nIdx, const Point& rPnt, sal_Bool bNewObj, OutputDevice* pOut); |
| |
| protected: |
| // #i71538# make constructors of SdrView sub-components protected to avoid incomplete incarnations which may get casted to SdrView |
| SdrDragView(SdrModel* pModel1, OutputDevice* pOut = 0L); |
| virtual ~SdrDragView(); |
| |
| public: |
| virtual sal_Bool IsAction() const; |
| virtual void MovAction(const Point& rPnt); |
| virtual void EndAction(); |
| virtual void BckAction(); |
| virtual void BrkAction(); |
| virtual void TakeActionRect(Rectangle& rRect) const; |
| |
| // Spezialimplementation fuer den Writer: |
| // TakeDragObjAnchorPos() liefert die Position an der ein Objekt |
| // beim Draggen einer Einfachselektion ungefaehr landet wenn es |
| // "losgelassen" wird (EndDrag). |
| // In der Regel ist das die linke obere Ecke des zu erwartenden neuen |
| // SnapRects. Ausnahme: CaptionObj. Dort ist es die Position des |
| // "Schwanzendes". |
| // Bei Returncode sal_False konnte ich die Position nicht bestimmen |
| // (z.B. Punktverschiebung, Mehrfachselektion, Schieben der |
| // Spiegelschse, ...) |
| sal_Bool TakeDragObjAnchorPos(Point& rPos, sal_Bool bTopRight = sal_False ) const; |
| |
| // Wird pForcedMeth uebergeben, so wird pHdl, ... nicht ausgewerten, sondern diese |
| // Drag-Methode verwendet. Die Instanz geht dabei ins Eigentum der View ueber und |
| // wird zum Ende des Draggings destruiert. |
| virtual sal_Bool BegDragObj(const Point& rPnt, OutputDevice* pOut=NULL, SdrHdl* pHdl=NULL, short nMinMov=-3, SdrDragMethod* pForcedMeth=NULL); |
| void MovDragObj(const Point& rPnt); |
| sal_Bool EndDragObj(sal_Bool bCopy=sal_False); |
| void BrkDragObj(); |
| sal_Bool IsDragObj() const { return mpCurrentSdrDragMethod && !bInsPolyPoint && !bInsGluePoint; } |
| SdrHdl* GetDragHdl() const { return pDragHdl; } |
| SdrDragMethod* GetDragMethod() const { return mpCurrentSdrDragMethod; } |
| sal_Bool IsDraggingPoints() const { return eDragHdl==HDL_POLY; } |
| sal_Bool IsDraggingGluePoints() const { return eDragHdl==HDL_GLUE; } |
| |
| // Wer das beim BegDrag oder mittendrin schon festlegen will. |
| // (Wird bei jedem BegDrag auf sal_False zurueckgesetzt, also nach |
| // BegDrag setzen.) |
| void SetDragWithCopy(sal_Bool bOn) { bDragWithCopy = bOn; } |
| sal_Bool IsDragWithCopy() const { return bDragWithCopy; } |
| |
| void SetInsertGluePoint(sal_Bool bOn) { bInsGluePoint = bOn; } |
| sal_Bool IsInsertGluePoint() const { return bInsGluePoint; } |
| |
| // Interaktives einfuegen eines neuen Punktes. nIdx=0 => vor dem ersten Punkt. |
| sal_Bool IsInsObjPointPossible() const; |
| sal_Bool IsInsPointPossible() const { return IsInsObjPointPossible(); } |
| sal_Bool BegInsObjPoint(const Point& rPnt, sal_Bool bNewObj) { return ImpBegInsObjPoint(sal_False, 0L, rPnt, bNewObj, 0L); } |
| void MovInsObjPoint(const Point& rPnt) { MovDragObj(rPnt); } |
| sal_Bool EndInsObjPoint(SdrCreateCmd eCmd); |
| void BrkInsObjPoint() { BrkDragObj(); } |
| sal_Bool IsInsObjPoint() const { return mpCurrentSdrDragMethod && bInsPolyPoint; } |
| |
| // Fuer die App zum Verwalten des Status. GetPreferedPointer() wird |
| // spaeter vielleicht einen passenden Pointer dafuer liefern |
| void SetInsObjPointMode(sal_Bool bOn) { bInsObjPointMode = bOn; } |
| sal_Bool IsInsObjPointMode() const { return bInsObjPointMode; } |
| |
| sal_Bool IsInsGluePointPossible() const; |
| sal_Bool BegInsGluePoint(const Point& rPnt); |
| void MovInsGluePoint(const Point& rPnt) { MovDragObj(rPnt); } |
| sal_Bool EndInsGluePoint() { return EndDragObj(); } |
| void BrkInsGluePoint() { BrkDragObj(); } |
| sal_Bool IsInsGluePoint() const { return mpCurrentSdrDragMethod && bInsGluePoint; } |
| |
| // Fuer die App zum Verwalten des Status. GetPreferedPointer() wird |
| // spaeter vielleicht einen passenden Pointer dafuer liefern |
| void SetInsGluePointMode(sal_Bool bOn) { bInsGluePointMode = bOn; } |
| sal_Bool IsInsGluePointMode() const { return bInsGluePointMode; } |
| |
| // Begrenzungslinien ueber's gesamte Win waehrend des Draggens |
| // Persistent. Default=FALSE. |
| void SetDragStripes(sal_Bool bOn); |
| sal_Bool IsDragStripes() const { return bDragStripes; } |
| |
| // Handles waehrend des Draggens verstecken |
| //HMHvoid SetDragHdlHide(sal_Bool bOn); |
| //HMHBOOL IsDragHdlHide() const { return bNoDragHdl; } |
| |
| // Beim Draggen von Polygonpunkten und Klebepunkten |
| // die Maus verstecken. Default=FALSE |
| void SetMouseHideWhileDraggingPoints(sal_Bool bOn) { bMouseHideWhileDraggingPoints = bOn; } |
| sal_Bool IsMouseHideWhileDraggingPoints() const { return bMouseHideWhileDraggingPoints; } |
| |
| // Beim Draggen werden i.d.R. die Konturen der markierten Objekte |
| // als Xor-Polygone dargestellt. Wird dieses Flag hier gesetzt, |
| // wird (z.B. bei Mehrfachselektion) nur ein Xor-Frame gezeichnet. |
| // Bei objektspeziefischem Dragging (Polygonpunkte,Eckenradius,... |
| // hat diese Einstellung keine Auswirkung. |
| // Auch waerend des Draggens umschaltbar. |
| // Default=Off |
| void SetNoDragXorPolys(sal_Bool bOn); |
| sal_Bool IsNoDragXorPolys() const { return bNoDragXorPolys; } |
| |
| // Uebersteigt die Anzahl der markierten Objekte den hier eingestellten |
| // Wert, wird implizit (temporaer) auf NoDragPolys geschaltet. |
| // PolyPolygone etc werden entsprechend als mehrere Objekte gewertet. |
| // Default=100 |
| void SetDragXorPolyLimit(sal_uIntPtr nObjAnz) { nDragXorPolyLimit=nObjAnz; } |
| sal_uIntPtr GetDragXorPolyLimit() const { return nDragXorPolyLimit; } |
| |
| // Wie DragXorPolyLimit, jedoch bezogen auf die Gesamtpunktanzahl |
| // aller Polygone. Default=500. |
| // Auf NoDragPolys wird (temporaer) geschaltet, wenn eins der Limits |
| // ueberstiegen wird. |
| void SetDragXorPointLimit(sal_uIntPtr nPntAnz) { nDragXorPointLimit=nPntAnz; } |
| sal_uIntPtr GetDragXorPointLimit() const { return nDragXorPointLimit; } |
| |
| void SetSolidDragging(bool bOn); |
| bool IsSolidDragging() const; |
| |
| // Dragging/Creating von Verbindern: |
| // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| // Verbinder an Objektscheitelpunkte ankleben |
| // Default=sal_True=Ja |
| void SetAutoVertexConnectors(sal_Bool bOn) { bAutoVertexCon = bOn; } |
| sal_Bool IsAutoVertexConnectors() const { return bAutoVertexCon; } |
| |
| // Verbinder an Objektecken ankleben |
| // Default=sal_False=Nein |
| void SetAutoCornerConnectors(sal_Bool bOn) { bAutoCornerCon = bOn; } |
| sal_Bool IsAutoCornerConnectors() const { return bAutoCornerCon; } |
| |
| // Dragging von verbundenen Objekten (Nodes): |
| // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| // DetailedEdgeDraggingLimit: Wie RubberEdgeDraggingLimit, jedoch bezieht |
| // sich dieses Limit auf die detalierte Darstellung, d.h. nicht nur |
| // Gummibaender sondern komplette Neuberechnunen sind beim Draggen sichtbar. |
| // Diese detalierte Darstellung ist eh nur beim MoveDrag moeglich. |
| // Defaultwert ist 10 |
| void SetDetailedEdgeDragging(sal_Bool bOn); // Default an |
| sal_Bool IsDetailedEdgeDragging() const { return bDetailedEdgeDragging; } |
| |
| void SetDetailedEdgeDraggingLimit(sal_uInt16 nEdgeObjAnz); |
| sal_uInt16 GetDetailedEdgeDraggingLimit() const { return nDetailedEdgeDraggingLimit; } |
| |
| // EdgeDraggingLimit: Sind mehr als nEdgeObjAnz Kanten betroffen, werden |
| // diese beim interaktiven Draggen nicht mit angezeigt. |
| // Gemeint sind hier die "Gummibaender", die weniger Rechenzeit benoetigen |
| // als die kompletten Neuberechnungen beim DetailedEdgeDragging. |
| // Defaultwert ist 100 |
| void SetRubberEdgeDragging(sal_Bool bOn); // Default an |
| sal_Bool IsRubberEdgeDragging() const { return bRubberEdgeDragging; } |
| |
| void SetRubberEdgeDraggingLimit(sal_uInt16 nEdgeObjAnz); |
| sal_uInt16 GetRubberEdgeDraggingLimit() const { return nRubberEdgeDraggingLimit; } |
| |
| // Verbinderhandling also zu deutsch wie folgt (bei Defaulteinstellungen): |
| // - Sind bis max 10 Verbinder betroffen werden diese bei jedem |
| // MouseMove neu berechnet |
| // - Sind zwischen 11 und 100 Verbinder betroffen werden die |
| // Verbindungen beim Draggen als gerade Linien dargestellt. |
| // - Bei mehr als 100 betroffenen Verbindern wird beim Draggen nichts |
| // mehr gezeichnet was auf Verbinder hinweist. |
| |
| // Ist ein spezieller Dragmode eingeschaltet, wie Rotate, Mirror oder Crook, |
| // dann leitet ein Hit auf das markierte Objekt genau dieses Dragging ein. |
| // Setzt man MarkedHitMovesAlways auf sal_True, so leitet ein Hit auf das |
| // markierte Objekt immer ein Moven ein, unabhaengig vom gesetzten DragMode. |
| // Dieses Flag ist persistent und sollte von der App fuer den Anwender |
| // konfigurierbar sein! |
| void SetMarkedHitMovesAlways(sal_Bool bOn) { bMarkedHitMovesAlways = bOn; } |
| sal_Bool IsMarkedHitMovesAlways() const { return bMarkedHitMovesAlways; } |
| |
| // Beim Draggen der Spiegelachse das Spiegelbild der markierten Objekte |
| // als Xor darstellen? Persistent. Noch nicht implementiert. Default TRUE. |
| void SetMirrRefDragObj(sal_Bool bOn) { bMirrRefDragObj = bOn; } |
| sal_Bool IsMirrRefDragObj() const { return bMirrRefDragObj; } |
| |
| sal_Bool IsOrthoDesired() const; |
| |
| // Beim Resize die Mitte als Referenz |
| // Default=FALSE. |
| sal_Bool IsResizeAtCenter() const { return bResizeAtCenter; } |
| void SetResizeAtCenter(sal_Bool bOn) { bResizeAtCenter = bOn; } |
| |
| // Symmetrisches Crook |
| // Default=FALSE. |
| sal_Bool IsCrookAtCenter() const { return bCrookAtCenter; } |
| void SetCrookAtCenter(sal_Bool bOn) { bCrookAtCenter = bOn; } |
| |
| // Begrenzung des Arbeitsbereichs. Die Begrenzung bezieht sich auf die |
| // View, nicht auf die einzelnen PageViews. Von der View wird diese |
| // Begrenzung nur bei Interaktionen wie Dragging und Create ausgewertet. |
| // Bei von der App algorithmisch oder UI-gesteuerte Aktionen (SetGeoAttr, |
| // MoveMarkedObj, ...) muss die App dieses Limit selbst beruecksichtigen. |
| // Ferner ist dieses Limit als Grob-Limit zu sehen. U.U. koennen Objekte |
| // (z.B. beim Drehen) nicht exakt bis an dieses Limit herangedraggt werden, |
| // koennen Objekte durch Rundungsfehler doch etwas ueberstehen, ... . |
| // Default=EmptyRect=keine Begrenzung. |
| // erst z.T. impl. |
| // (besser in die DragView?) |
| void SetWorkArea(const Rectangle& rRect) { aMaxWorkArea=rRect; } |
| const Rectangle& GetWorkArea() const { return aMaxWorkArea; } |
| |
| |
| // Das DragLimit ist bezogen auf die Page des Objekts. |
| // (Oder auf die View??? Muss ich mal^^^^recherchieren. Joe.) |
| // sal_False=Kein Limit. |
| // Das Rueckgabe-Rect muss absolute Koordinaten enthalten. Der Maximale |
| // Dragbereich wird von der View dann so gewaehlt, dass das SnapRect des |
| // Objekts bis Maximal auf die Kante des LimitRects gemoved bzw. gesized |
| // wird. Bei Objekten wie Bezierkurven, gedrehten Rechtecken ist zu beachten |
| // das durch anschliessende Neuberechnung des SnapRects (bei Resize) |
| // Rundungsfehler auftreten koennen, wodurch das LimitRect minnimal |
| // ueberschritten werden koennte... |
| // Implementiert fuer Move und Resize. |
| virtual sal_Bool TakeDragLimit(SdrDragMode eMode, Rectangle& rRect) const; |
| }; |
| |
| #endif //_SVDDRGV_HXX |
| |
