LCOV - code coverage report
Current view: top level - include/svx - svddrgv.hxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 34 0.0 %
Date: 2014-04-14 Functions: 0 34 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             :     bool                        bFramDrag : 1;        // currently frame dragging
      47             :     bool                        bDragSpecial : 1;     // currently Special Obj-dragging
      48             :     bool                        bMarkedHitMovesAlways : 1; // Persistent
      49             :     bool                        bDragLimit : 1;      // Limit on SnapRect instead of BoundRect
      50             :     bool                        bDragHdl : 1;        // TRUE: RefPt is slid
      51             :     bool                        bDragStripes : 1;    // Persistent
      52             :     bool                        bMirrRefDragObj : 1; // Persistent - During the drag, show the mirror axis of the mirrored objects as Xor
      53             :     bool                        mbSolidDragging : 1;  // allow solid create/drag of objects
      54             :     bool                        bMouseHideWhileDraggingPoints : 1;
      55             :     bool                        bResizeAtCenter : 1;
      56             :     bool                        bCrookAtCenter : 1;
      57             :     bool                        bDragWithCopy : 1;
      58             :     bool                        bInsGluePoint : 1;
      59             :     bool                        bInsObjPointMode : 1;
      60             :     bool                        bInsGluePointMode : 1;
      61             :     bool                        bNoDragXorPolys : 1;
      62             :     bool                        bAutoVertexCon : 1;  // Automatische Konnektorgenerierung an den Scheitelpunkten
      63             :     bool                        bAutoCornerCon : 1;  // Automatische Konnektorgenerierung an den Eckpunkten
      64             :     bool                        bRubberEdgeDragging : 1;
      65             :     bool                        bDetailedEdgeDragging : 1;
      66             : 
      67             : private:
      68             :     SVX_DLLPRIVATE void ImpClearVars();
      69             : 
      70             : protected:
      71             :     virtual void SetMarkHandles() SAL_OVERRIDE;
      72             :     void ShowDragObj();
      73             :     void HideDragObj();
      74             :     bool ImpBegInsObjPoint(bool bIdxZwang, sal_uInt32 nIdx, const Point& rPnt, 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 bool IsAction() const SAL_OVERRIDE;
      83             :     virtual void MovAction(const Point& rPnt) SAL_OVERRIDE;
      84             :     virtual void EndAction() SAL_OVERRIDE;
      85             :     virtual void BckAction() SAL_OVERRIDE;
      86             :     virtual void BrkAction() SAL_OVERRIDE;
      87             :     virtual void TakeActionRect(Rectangle& rRect) const SAL_OVERRIDE;
      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             :     bool TakeDragObjAnchorPos(Point& rPos, bool bTopRight = 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 bool BegDragObj(const Point& rPnt, OutputDevice* pOut=NULL, SdrHdl* pHdl=NULL, short nMinMov=-3, SdrDragMethod* pForcedMeth=NULL);
     105             :     void MovDragObj(const Point& rPnt);
     106             :     bool EndDragObj(bool bCopy=false);
     107             :     void BrkDragObj();
     108           0 :     bool IsDragObj() const { return mpCurrentSdrDragMethod && !bInsPolyPoint && !bInsGluePoint; }
     109           0 :     SdrHdl* GetDragHdl() const { return pDragHdl; }
     110           0 :     SdrDragMethod* GetDragMethod() const { return mpCurrentSdrDragMethod; }
     111           0 :     bool IsDraggingPoints() const { return eDragHdl==HDL_POLY; }
     112           0 :     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           0 :     void SetDragWithCopy(bool bOn) { bDragWithCopy = bOn; }
     118           0 :     bool IsDragWithCopy() const { return bDragWithCopy; }
     119             : 
     120           0 :     void SetInsertGluePoint(bool bOn) { bInsGluePoint = bOn; }
     121           0 :     bool IsInsertGluePoint() const { return bInsGluePoint; }
     122             : 
     123             :     // Interaktives einfuegen eines neuen Punktes. nIdx=0 => vor dem ersten Punkt.
     124             :     bool IsInsObjPointPossible() const;
     125           0 :     bool BegInsObjPoint(const Point& rPnt, bool bNewObj) { return ImpBegInsObjPoint(false, 0L, rPnt, bNewObj, 0L); }
     126           0 :     void MovInsObjPoint(const Point& rPnt) { MovDragObj(rPnt); }
     127             :     bool EndInsObjPoint(SdrCreateCmd eCmd);
     128             :     void BrkInsObjPoint() { BrkDragObj(); }
     129           0 :     bool IsInsObjPoint() const { return mpCurrentSdrDragMethod && bInsPolyPoint; }
     130             : 
     131             :     // Fuer die App zum Verwalten des Status. GetPreferredPointer() wird
     132             :     // spaeter vielleicht einen passenden Pointer dafuer liefern
     133           0 :     void SetInsObjPointMode(bool bOn) { bInsObjPointMode = bOn; }
     134           0 :     bool IsInsObjPointMode() const { return bInsObjPointMode; }
     135             : 
     136             :     bool IsInsGluePointPossible() const;
     137             :     bool BegInsGluePoint(const Point& rPnt);
     138             :     void MovInsGluePoint(const Point& rPnt) { MovDragObj(rPnt); }
     139             :     bool EndInsGluePoint() { return EndDragObj(); }
     140             :     void BrkInsGluePoint() { BrkDragObj(); }
     141           0 :     bool IsInsGluePoint() const { return mpCurrentSdrDragMethod && bInsGluePoint; }
     142             : 
     143             :     // Fuer die App zum Verwalten des Status. GetPreferredPointer() wird
     144             :     // spaeter vielleicht einen passenden Pointer dafuer liefern
     145           0 :     void SetInsGluePointMode(bool bOn) { bInsGluePointMode = bOn; }
     146           0 :     bool IsInsGluePointMode() const { return bInsGluePointMode; }
     147             : 
     148             :     // Begrenzungslinien ueber's gesamte Win waehrend des Draggens
     149             :     // Persistent. Default=FALSE.
     150             :     void SetDragStripes(bool bOn);
     151           0 :     bool IsDragStripes() const { return bDragStripes; }
     152             : 
     153             :     // Handles waehrend des Draggens verstecken
     154             :     //HMHvoid SetDragHdlHide(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(bool bOn) { bMouseHideWhileDraggingPoints = bOn; }
     160           0 :     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(bool bOn);
     170           0 :     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           0 :     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           0 :     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(bool bOn) { bAutoVertexCon = bOn; }
     194           0 :     bool IsAutoVertexConnectors() const { return bAutoVertexCon; }
     195             : 
     196             :     // Verbinder an Objektecken ankleben
     197             :     // Default=sal_False=Nein
     198             :     void SetAutoCornerConnectors(bool bOn) { bAutoCornerCon = bOn; }
     199           0 :     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           0 :     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           0 :     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           0 :     void SetMarkedHitMovesAlways(bool bOn) { bMarkedHitMovesAlways = bOn; }
     234           0 :     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(bool bOn) { bMirrRefDragObj = bOn; }
     239             :     bool IsMirrRefDragObj() const { return bMirrRefDragObj; }
     240             : 
     241             :     bool IsOrthoDesired() const;
     242             : 
     243             :     // Beim Resize die Mitte als Referenz
     244             :     // Default=FALSE.
     245           0 :     bool IsResizeAtCenter() const { return bResizeAtCenter; }
     246           0 :     void SetResizeAtCenter(bool bOn) { bResizeAtCenter = bOn; }
     247             : 
     248             :     // Symmetrisches Crook
     249             :     // Default=FALSE.
     250           0 :     bool IsCrookAtCenter() const { return bCrookAtCenter; }
     251           0 :     void SetCrookAtCenter(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           0 :     void SetWorkArea(const Rectangle& rRect) { aMaxWorkArea=rRect; }
     265           0 :     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 bool TakeDragLimit(SdrDragMode eMode, Rectangle& rRect) const;
     280             : };
     281             : 
     282             : #endif // INCLUDED_SVX_SVDDRGV_HXX
     283             : 
     284             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10