LCOV - code coverage report
Current view: top level - include/svx - svdedtv.hxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 27 0.0 %
Date: 2014-04-14 Functions: 0 27 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_SVDEDTV_HXX
      21             : #define INCLUDED_SVX_SVDEDTV_HXX
      22             : 
      23             : #include <svx/svdmrkv.hxx>
      24             : #include <svx/xpoly.hxx>
      25             : #include <svx/svdmodel.hxx>
      26             : #include <svx/svxdllapi.h>
      27             : 
      28             : class SfxUndoAction;
      29             : class SdrUndoAction;
      30             : class SdrUndoGroup;
      31             : class SfxStyleSheet;
      32             : class SdrLayer;
      33             : class SvdProgressInfo;
      34             : 
      35             : enum SdrHorAlign  {
      36             :     SDRHALIGN_NONE,
      37             :     SDRHALIGN_LEFT,
      38             :     SDRHALIGN_RIGHT,
      39             :     SDRHALIGN_CENTER
      40             : };
      41             : 
      42             : enum SdrVertAlign {
      43             :     SDRVALIGN_NONE,
      44             :     SDRVALIGN_TOP,
      45             :     SDRVALIGN_BOTTOM,
      46             :     SDRVALIGN_CENTER
      47             : };
      48             : 
      49             : enum SdrMergeMode {
      50             :     SDR_MERGE_MERGE,
      51             :     SDR_MERGE_SUBSTRACT,
      52             :     SDR_MERGE_INTERSECT
      53             : };
      54             : 
      55             : // Optionen fuer InsertObject()
      56             : #define SDRINSERT_DONTMARK    0x0001 /* Obj wird nicht markiert (aktuelle Markierung bleibt bestehen) */
      57             : #define SDRINSERT_ADDMARK     0x0002 /* Das Obj wird zu einer ggf. bereits bestehenden Selektion hinzumarkiert */
      58             : #define SDRINSERT_SETDEFATTR  0x0004 /* Die aktuellen Attribute (+StyleSheet) werden dem Obj zugewiesen */
      59             : #define SDRINSERT_SETDEFLAYER 0x0008 /* Der aktuelle Layer wird dem Obj zugewiesen */
      60             : #define SDRINSERT_NOBROADCAST 0x0010 /* Einfuegen mit NbcInsertObject() fuer SolidDragging */
      61             : 
      62             : class SVX_DLLPUBLIC SdrEditView: public SdrMarkView
      63             : {
      64             :     friend class                SdrPageView;
      65             :     friend class                SdrDragDistort;
      66             :     friend class                SdrDragCrook;
      67             : 
      68             : protected:
      69             : 
      70             :     // Die Transformationsnachfragen, etc. etwas cachen
      71             :     bool                        bPossibilitiesDirty : 1;
      72             :     bool                        bReadOnly : 1;
      73             :     bool                        bGroupPossible : 1;
      74             :     bool                        bUnGroupPossible : 1;
      75             :     bool                        bGrpEnterPossible : 1;
      76             :     bool                        bDeletePossible : 1;
      77             :     bool                        bToTopPossible : 1;
      78             :     bool                        bToBtmPossible : 1;
      79             :     bool                        bReverseOrderPossible : 1;
      80             :     bool                        bImportMtfPossible : 1;
      81             :     bool                        bCombinePossible : 1;
      82             :     bool                        bDismantlePossible : 1;
      83             :     bool                        bCombineNoPolyPolyPossible : 1;
      84             :     bool                        bDismantleMakeLinesPossible : 1;
      85             :     bool                        bOrthoDesiredOnMarked : 1;
      86             :     bool                        bMoreThanOneNotMovable : 1;   // Es ist mehr als ein Objekt nicht verschiebbar
      87             :     bool                        bOneOrMoreMovable : 1;        // Wenigstens 1 Obj verschiebbar
      88             :     bool                        bMoreThanOneNoMovRot : 1;     // Es ist mehr als ein Objekt nicht verschieb- und drehbar (Crook)
      89             :     bool                        bContortionPossible : 1;      // Alles Polygone (ggf. gruppiert)
      90             :     bool                        bAllPolys : 1;                // Alles Polygone (nicht gruppiert)
      91             :     bool                        bOneOrMorePolys : 1;          // Mindestens 1 Polygon (nicht gruppiert)
      92             :     bool                        bMoveAllowed : 1;
      93             :     bool                        bResizeFreeAllowed : 1;
      94             :     bool                        bResizePropAllowed : 1;
      95             :     bool                        bRotateFreeAllowed : 1;
      96             :     bool                        bRotate90Allowed : 1;
      97             :     bool                        bMirrorFreeAllowed : 1;
      98             :     bool                        bMirror45Allowed : 1;
      99             :     bool                        bMirror90Allowed : 1;
     100             :     bool                        bShearAllowed : 1;
     101             :     bool                        bEdgeRadiusAllowed : 1;
     102             :     bool                        bTransparenceAllowed : 1;
     103             :     bool                        bGradientAllowed : 1;
     104             :     bool                        bCanConvToPath : 1;
     105             :     bool                        bCanConvToPoly : 1;
     106             :     bool                        bCanConvToContour : 1;
     107             :     bool                        bCanConvToPathLineToArea : 1;
     108             :     bool                        bCanConvToPolyLineToArea : 1;
     109             :     bool                        bMoveProtect : 1;
     110             :     bool                        bResizeProtect : 1;
     111             :     // Z-Order von virtuellen Objekten zusammenhalten (Writer)
     112             :     bool                        bBundleVirtObj : 1;
     113             : 
     114             : private:
     115             :     SVX_DLLPRIVATE void ImpClearVars();
     116             :     SVX_DLLPRIVATE void ImpResetPossibilityFlags();
     117             : 
     118             : protected:
     119             :     void ImpBroadcastEdgesOfMarkedNodes();
     120             : 
     121             :     // Konvertierung der markierten Objekte in Poly bzw. Bezier.
     122             :     void ImpConvertTo(bool bPath, bool bLineToArea);
     123             : 
     124             :     // Konvertiert ein Obj, wirft bei Erfolg das alte as seiner Liste und
     125             :     // fuegt das neue an dessen Position ein. Inkl Undo. Es wird weder ein
     126             :     // MarkEntry noch ein ModelChgBroadcast generiert.
     127             :     SdrObject* ImpConvertOneObj(SdrObject* pObj, bool bPath, bool bLineToArea);
     128             : 
     129             :     // Setzen der beiden Flags bToTopPossible und bToBtmPossible.
     130             :     // bToTopPossibleDirty und bToBtmPossibleDirty werden dabei gleichzeitig
     131             :     // zurueckgesetzt.
     132             :     void ImpCheckToTopBtmPossible();
     133             : 
     134             :     // fuer CombineMarkedObjects und DismantleMarkedObjects
     135             :     void ImpCopyAttributes(const SdrObject* pSource, SdrObject* pDest) const;
     136             : 
     137             :     // fuer CombineMarkedObjects
     138             :     bool ImpCanConvertForCombine1(const SdrObject* pObj) const;
     139             :     bool ImpCanConvertForCombine(const SdrObject* pObj) const;
     140             :     basegfx::B2DPolyPolygon ImpGetPolyPolygon1(const SdrObject* pObj, bool bCombine) const;
     141             :     basegfx::B2DPolyPolygon ImpGetPolyPolygon(const SdrObject* pObj, bool bCombine) const;
     142             :     basegfx::B2DPolygon ImpCombineToSinglePolygon(const basegfx::B2DPolyPolygon& rPolyPolygon) const;
     143             : 
     144             :     // fuer DismantleMarkedObjects
     145             :     bool ImpCanDismantle(const basegfx::B2DPolyPolygon& rPpolyPpolygon, bool bMakeLines) const;
     146             :     bool ImpCanDismantle(const SdrObject* pObj, bool bMakeLines) const;
     147             :     void ImpDismantleOneObject(const SdrObject* pObj, SdrObjList& rOL, sal_uIntPtr& rPos, SdrPageView* pPV, bool bMakeLines);
     148             :     void ImpCrookObj(SdrObject* pO, const Point& rRef, const Point& rRad, SdrCrookMode eMode,
     149             :         bool bVertical, bool bNoContortion, bool bRotate, const Rectangle& rMarkRect);
     150             :     void ImpDistortObj(SdrObject* pO, const Rectangle& rRef, const XPolygon& rDistortedRect, bool bNoContortion);
     151             :     bool ImpDelLayerCheck(SdrObjList* pOL, SdrLayerID nDelID) const;
     152             :     void ImpDelLayerDelObjs(SdrObjList* pOL, SdrLayerID nDelID);
     153             : 
     154             :     // Entfernt alle Obj der MarkList aus ihren ObjLists inkl Undo.
     155             :     // Die Eintraege in rMark bleiben erhalten.
     156             :     void DeleteMarkedList(const SdrMarkList& rMark); // DeleteMarked -> DeleteMarkedList
     157             : 
     158             :     // Die Transformationsnachfragen etwas cachen
     159             :     //void ImpCheckMarkTransform() const; veraltet
     160             :     // Checken, was man so mit den markierten Objekten alles machen kann
     161             :     virtual void CheckPossibilities();
     162           0 :     void ForcePossibilities() const { if (bPossibilitiesDirty || bSomeObjChgdFlag) ((SdrEditView*)this)->CheckPossibilities(); }
     163             : 
     164             : protected:
     165             :     // #i71538# make constructors of SdrView sub-components protected to avoid incomplete incarnations which may get casted to SdrView
     166             :     SdrEditView(SdrModel* pModel1, OutputDevice* pOut = 0L);
     167             :     virtual ~SdrEditView();
     168             : 
     169             : public:
     170             :     // Jeder Aufruf einer undofaehigen Methode an der View generiert eine
     171             :     // UndoAction. Moechte man mehrere
     172             :     // Methodenaufrufe zu einer UndoAction zusammenfassen, so kann man diese
     173             :     // mit BegUndo() / EndUndo() klammern (beliebig tief). Als Kommentar der
     174             :     // UndoAction wird der des ersten BegUndo(String) aller Klammerungen
     175             :     // verwendet. NotifyNewUndoAction() wird in diesem Fall erst beim letzten
     176             :     // EndUndo() gerufen. NotifyNewUndoAction() wird nicht gerufen bei einer
     177             :     // leeren Klammerung.
     178           0 :     void BegUndo()                       { pMod->BegUndo();         } // Undo-Klammerung auf
     179           0 :     void BegUndo(const OUString& rComment) { pMod->BegUndo(rComment); } // Undo-Klammerung auf
     180           0 :     void BegUndo(const OUString& rComment, const OUString& rObjDescr, SdrRepeatFunc eFunc=SDRREPFUNC_OBJ_NONE) { pMod->BegUndo(rComment,rObjDescr,eFunc); } // Undo-Klammerung auf
     181             :     void EndUndo();                                                   // Undo-Klammerung zu (inkl BroadcastEdges)
     182           0 :     void AddUndo(SdrUndoAction* pUndo)   { pMod->AddUndo(pUndo);    } // Action hinzufuegen
     183             :     // nur nach dem 1. BegUndo oder vor dem letzten EndUndo:
     184           0 :     void SetUndoComment(const OUString& rComment) { pMod->SetUndoComment(rComment); }
     185           0 :     void SetUndoComment(const OUString& rComment, const OUString& rObjDescr) { pMod->SetUndoComment(rComment,rObjDescr); }
     186             :     bool IsUndoEnabled() const;
     187             : 
     188             :     std::vector< SdrUndoAction* > CreateConnectorUndo( SdrObject& rO );
     189             :     void AddUndoActions( std::vector< SdrUndoAction* >& );
     190             : 
     191             :     // Layerverwaltung. Mit Undo.
     192             :     SdrLayer* InsertNewLayer(const OUString& rName, sal_uInt16 nPos=0xFFFF);
     193             :     // Loeschen eines Layer inkl. aller darauf befindlichen Objekte
     194             :     void      DeleteLayer(const OUString& rName);
     195             :     // Verschieben eines Layer (Layerreihenfolge aendern)
     196             :     void      MoveLayer(const OUString& rName, sal_uInt16 nNewPos);
     197             : 
     198             :     // Markierte Objekte die ausserhalb ihrer Page liegen
     199             :     // werden ggf. einer anderen Page zugewiesen
     200             :     // z.Zt. noch ohne Undo!!!
     201             :     void ForceMarkedObjToAnotherPage();
     202           0 :     void ForceMarkedToAnotherPage()   { ForceMarkedObjToAnotherPage(); }
     203             : 
     204             :     bool IsReadOnly() const { ForcePossibilities(); return bReadOnly; }
     205             : 
     206             :     // Loeschen aller markierten Objekte
     207             :     void DeleteMarkedObj();
     208             :     bool IsDeleteMarkedObjPossible() const { ForcePossibilities(); return bDeletePossible; }
     209             : 
     210             :     // Logisch- umschliessendes Rect aller markierten Objekte setzen.
     211             :     // Das das wirklich geschieht ist nicht garantiert, denn eine
     212             :     // waagerechte Linie hat z.B. immer eine Hoehe von 0.
     213             :     void SetMarkedObjRect(const Rectangle& rRect, bool bCopy=false);
     214             :     void MoveMarkedObj(const Size& rSiz, bool bCopy=false);
     215             :     void ResizeMarkedObj(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bCopy=false);
     216             :     void ResizeMultMarkedObj(const Point& rRef, const Fraction& xFact, const Fraction& yFact, const bool bCopy, const bool bWdh, const bool bHgt);
     217             :     long GetMarkedObjRotate() const;
     218             :     void RotateMarkedObj(const Point& rRef, long nWink, bool bCopy=false);
     219             :     void MirrorMarkedObj(const Point& rRef1, const Point& rRef2, bool bCopy=false);
     220             :     void MirrorMarkedObjHorizontal(bool bCopy=false);
     221             :     void MirrorMarkedObjVertical(bool bCopy=false);
     222             :     long GetMarkedObjShear() const;
     223             :     void ShearMarkedObj(const Point& rRef, long nWink, bool bVShear=false, bool bCopy=false);
     224             :     void CrookMarkedObj(const Point& rRef, const Point& rRad, SdrCrookMode eMode, bool bVertical=false, bool bNoContortion=false, bool bCopy=false);
     225             :     void DistortMarkedObj(const Rectangle& rRef, const XPolygon& rDistortedRect, bool bNoContortion=false, bool bCopy=false);
     226             : 
     227             :     // Markierte Objekte kopieren und anstelle der alten markieren
     228             :     void CopyMarkedObj();
     229           0 :     void SetAllMarkedRect(const Rectangle& rRect, bool bCopy=false) { SetMarkedObjRect(rRect,bCopy); }
     230           0 :     void MoveAllMarked(const Size& rSiz, bool bCopy=false) { MoveMarkedObj   (rSiz,bCopy); }
     231           0 :     void ResizeAllMarked(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bCopy=false) { ResizeMarkedObj (rRef,xFact,yFact,bCopy); }
     232             :     long GetAllMarkedRotate() const { return GetMarkedObjRotate(); }
     233           0 :     void RotateAllMarked(const Point& rRef, long nWink, bool bCopy=false) { RotateMarkedObj(rRef,nWink,bCopy); }
     234             :     void MirrorAllMarked(const Point& rRef1, const Point& rRef2, bool bCopy=false) { MirrorMarkedObj(rRef1,rRef2,bCopy); }
     235           0 :     void MirrorAllMarkedHorizontal(bool bCopy=false) { MirrorMarkedObjHorizontal(bCopy); }
     236           0 :     void MirrorAllMarkedVertical(bool bCopy=false) { MirrorMarkedObjVertical(bCopy); }
     237             :     long GetAllMarkedShear() const { return GetMarkedObjShear(); }
     238             :     void ShearAllMarked(const Point& rRef, long nWink, bool bVShear=false, bool bCopy=false) { ShearMarkedObj(rRef,nWink,bVShear,bCopy); }
     239             :     void CrookAllMarked(const Point& rRef, const Point& rRad, SdrCrookMode eMode, bool bVertical=false, bool bNoContortion=false, bool bCopy=false) { CrookMarkedObj(rRef,rRad,eMode,bVertical,bNoContortion,bCopy); }
     240           0 :     void CopyMarked() { CopyMarkedObj(); }
     241           0 :     bool IsMoveAllowed() const { ForcePossibilities(); return bMoveAllowed && !bMoveProtect; }
     242             :     bool IsResizeAllowed(bool bProp=false) const;
     243             :     bool IsRotateAllowed(bool b90Deg=false) const;
     244             :     bool IsMirrorAllowed(bool b45Deg=false, bool b90Deg=false) const;
     245             :     bool IsTransparenceAllowed() const;
     246             :     bool IsGradientAllowed() const;
     247             :     bool IsShearAllowed() const;
     248             :     bool IsEdgeRadiusAllowed() const;
     249             :     bool IsCrookAllowed(bool bNoContortion=false) const;
     250             :     bool IsDistortAllowed(bool bNoContortion=false) const;
     251             : 
     252             :     // Vereinigen mehrerer Objekte zu einem PolyPolygon:
     253             :     // - Rechtecke/Kreise/Text... werden implizit gewandelt.
     254             :     // - Polylines werden automatisch geschlossen.
     255             :     // - Die Attribute und der Layer werden vom Ersten der markierten Objekte
     256             :     //   uebernommen (also vom untersten der Z-Order).
     257             :     // - Gruppenobjekte werden miteinbezogen, wenn alle! Memberobjekte der
     258             :     //   Gruppe wandelbar sind. Beinhaltet eine Gruppe also beispielsweise
     259             :     //   eine Bitmap oder ein OLE-Objekt, wird die gesamte Gruppe nicht
     260             :     //   beruecksichtigt.
     261             :     // bNoPolyPoly=TRUE: Alles wird zu einem einzigen Polygon zusammengefasst
     262             :     void CombineMarkedObjects(bool bNoPolyPoly = true);
     263             : 
     264             :     // for combining multiple polygons, with direct support of the modes
     265             :     // SID_POLY_MERGE, SID_POLY_SUBSTRACT, SID_POLY_INTERSECT
     266             :     void MergeMarkedObjects(SdrMergeMode eMode);
     267             : 
     268             :     // for distribution dialog function
     269             :     void DistributeMarkedObjects();
     270             : 
     271             :     // Markierte Polypolygonobjekte in Polygone zerlegen
     272             :     // Gruppenobjekte werden durchsucht und zerlegt, wenn es sich bei allen
     273             :     // Memberobjekten um PathObjs handelt.
     274             :     // bMakeLines=TRUE: alle Polygone werden in einzelne Linien bzw.
     275             :     //                  Beziersegmente zerlegt
     276             :     void DismantleMarkedObjects(bool bMakeLines=false);
     277             :     bool IsCombinePossible(bool bNoPolyPoly=false) const;
     278             :     bool IsDismantlePossible(bool bMakeLines=false) const;
     279             : 
     280             :     // Ein neues bereits fertig konstruiertes Obj einfuegen. Das Obj gehoert
     281             :     // anschliessend dem Model. Nach dem Einfuegen wird das neue Objekt
     282             :     // markiert (wenn dies nicht via nOptions unterbunden wird).
     283             :     // U.U. wird das Obj jedoch nicht eingefuegt, sondern deleted, naemlich
     284             :     // wenn der Ziel-Layer gesperrt oder nicht sichtbar ist. In diesem Fall
     285             :     // returniert die Methode mit FALSE.
     286             :     // Die Methode generiert u.a. auch eine Undo-Action.
     287             :     bool InsertObjectAtView(SdrObject* pObj, SdrPageView& rPV, sal_uIntPtr nOptions=0);
     288             : 
     289             :     // Ein Zeichenobjekt durch ein neues ersetzen. *pNewObj gehoert
     290             :     // anschliessend mir, *pOldObj wandert ins Undo.
     291             :     // Sollte in jedem Fall mit einer Undo-Klammerung versehen werden, z.B.:
     292             :     // aStr+=" ersetzen";
     293             :     // BegUndo(aStr);
     294             :     // ReplaceObject(...);
     295             : 
     296             :     // EndUndo();
     297             :     void ReplaceObjectAtView(SdrObject* pOldObj, SdrPageView& rPV, SdrObject* pNewObj, bool bMark=true);
     298             : 
     299             :     void SetNotPersistAttrToMarked(const SfxItemSet& rAttr, bool bReplaceAll);
     300             :     void MergeNotPersistAttrFromMarked(SfxItemSet& rAttr, bool bOnlyHardAttr) const;
     301             :     void MergeAttrFromMarked(SfxItemSet& rAttr, bool bOnlyHardAttr) const;
     302             :     SfxItemSet GetAttrFromMarked(bool bOnlyHardAttr) const;
     303             :     void SetAttrToMarked(const SfxItemSet& rAttr, bool bReplaceAll);
     304             : 
     305             :     // Geometrische Attribute (Position, Groesse, Drehwinkel)
     306             :     // Bei der Position wird ein evtl. gesetzter PageOrigin beruecksichtigt.
     307             :     SfxItemSet GetGeoAttrFromMarked() const;
     308             :     void SetGeoAttrToMarked(const SfxItemSet& rAttr);
     309             : 
     310             :     // Returnt NULL wenn:
     311             :     // - Nix markiert,
     312             :     // - kein StyleSheet an den markierten Objekten gesetzt
     313             :     // - Bei Mehrfachselektion die markierten Objekte auf unterschiedliche
     314             :     //   StyleSheets verweisen.
     315             :     SfxStyleSheet* GetStyleSheetFromMarked() const;
     316             : 
     317             :     // z.Zt. noch ohne Undo :(
     318             :     void SetStyleSheetToMarked(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr);
     319             : 
     320             :     /* new interface src537 */
     321             :     bool GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const;
     322             : 
     323             :     bool SetAttributes(const SfxItemSet& rSet, bool bReplaceAll);
     324             :     SfxStyleSheet* GetStyleSheet() const; // SfxStyleSheet* GetStyleSheet(bool& rOk) const;
     325             :     bool SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr);
     326             : 
     327             :     // Alle markierten Objekte zu einer Gruppe zusammenfassen.
     328             :     // Anschliessend wird die neue Gruppe markiert. Bei einer
     329             :     // seitenuebergreifenden Markierung wird eine Gruppe je Seite erzeugt.
     330             :     // Alle erzeugten Gruppen sind anschliessend markiert.
     331             :     // Ueber pUserGrp kann ein eigenes Gruppenobjekt vorgegeben werden. Dieses
     332             :     // wird  jedoch nicht direkt verwendet, sondern via Clone kopiert.
     333             :     // Wird NULL uebergeben, macht sich die Methode SdrObjGroup-Instanzen.
     334             :     void GroupMarked(const SdrObject* pUserGrp=NULL);
     335             : 
     336             :     // Alle markierten Objektgruppen werden aufgeloesst (1 Level).
     337             :     // Anschliessend sind statt der Gruppenobjekte alle ehemaligen
     338             :     // Memberobjekte der aufgeloesten Gruppen markiert. Waren zum auch Objekte
     339             :     // markiert, die keine Gruppenobjekte sind, so bleiben diese weiterhin
     340             :     // zusaetzlich markiert.
     341             :     void UnGroupMarked();
     342             : 
     343           0 :     bool IsGroupPossible() const { ForcePossibilities(); return bGroupPossible; }
     344           0 :     bool IsUnGroupPossible() const { ForcePossibilities(); return bUnGroupPossible; }
     345           0 :     bool IsGroupEnterPossible() const { ForcePossibilities(); return bGrpEnterPossible; }
     346             : 
     347             :     // Markierte Objekte in Polygone/Bezierkurven verwandeln. Die bool-
     348             :     // Funktionen returnen sal_True, wenn wenigstens eins der markierten
     349             :     // Objekte gewandelt werden kann. Memberobjekte von Gruppenobjekten
     350             :     // werden ebenfalls gewandelt. Naehere Beschreibung siehe SdrObj.HXX.
     351           0 :     bool IsConvertToPathObjPossible(bool bLineToArea) const { ForcePossibilities(); return bLineToArea ? bCanConvToPathLineToArea : bCanConvToPath; }
     352           0 :     bool IsConvertToPolyObjPossible(bool bLineToArea) const { ForcePossibilities(); return bLineToArea ? bCanConvToPolyLineToArea : bCanConvToPoly; }
     353           0 :     bool IsConvertToContourPossible() const { ForcePossibilities(); return bCanConvToContour; }
     354             :     void ConvertMarkedToPathObj(bool bLineToArea);
     355             :     void ConvertMarkedToPolyObj(bool bLineToArea);
     356             : 
     357             :     // Alle markierten Objekte untereinander ausrichten. Normalerweise werden
     358             :     // das SnapRect der Obj verwendet. Ist bBoundRects=sal_True, werden stattdessen
     359             :     // die BoundRects ausgerichtet.
     360             :     void AlignMarkedObjects(SdrHorAlign eHor, SdrVertAlign eVert, bool bBoundRects=false);
     361             :     bool IsAlignPossible() const;
     362             : 
     363             :     // Markierte Objekte etwas nach "oben" holen
     364             :     void MovMarkedToTop();
     365             : 
     366             :     // Markierte Objekte etwas nach "unten" holen
     367             :     void MovMarkedToBtm();
     368             : 
     369             :     // Markierte Objekte ganz nach "oben" stellen
     370             :     void PutMarkedToTop();
     371             : 
     372             :     // Markierte Objekte ganz nach "unten" stellen
     373             :     void PutMarkedToBtm();
     374             : 
     375             :     // Markierte direkt vor das uebergebene Objekt stellen
     376             :     // NULL -> wie PutMarkedToTop();
     377             :     void PutMarkedInFrontOfObj(const SdrObject* pRefObj);
     378             : 
     379             :     // Markierte direkt hinter das uebergebene Objekt stellen
     380             :     // NULL -> wie PutMarkedToBtm();
     381             :     void PutMarkedBehindObj(const SdrObject* pRefObj);
     382             : 
     383             :     // Z-Order der markierten Objekte vertauschen
     384             :     void ReverseOrderOfMarked();
     385             : 
     386             :     // Feststellen, ob nach vorn/hinten stellen moeglich ist
     387             :     // GetMaxToTop/BtmObj() wird von diesen Methoden nur begrenzt
     388             :     // beruecksichtigt, d.h. es kann vorkommen dass IsToTopPossible()
     389             :     // sal_True liefert, MovMarkedToTop() jedoch nichts aendert (z.B. bei
     390             :     // Mehrfachselektion), weil eine von der abgeleiteten View ueber
     391             :     // GetMaxToTopObj() auferlegte Restriktion dies verhindert.
     392           0 :     bool IsToTopPossible() const { ForcePossibilities(); return bToTopPossible; }
     393           0 :     bool IsToBtmPossible() const { ForcePossibilities(); return bToBtmPossible; }
     394           0 :     bool IsReverseOrderPossible() const { ForcePossibilities(); return bReverseOrderPossible; }
     395             : 
     396             :     // Ueber diese Methoden stellt die View fest, wie weit ein Objekt
     397             :     // nach vorn bzw. nach hinten gestellt werden darf (Z-Order). Das
     398             :     // zurueckgegebene Objekt wird dann nicht "ueberholt". Bei Rueckgabe
     399             :     // von NULL (Defaultverhalten) bestehen keine Restriktionen.
     400             :     virtual SdrObject* GetMaxToTopObj(SdrObject* pObj) const;
     401             :     virtual SdrObject* GetMaxToBtmObj(SdrObject* pObj) const;
     402             : 
     403             :     // Folgende Methode wird gerufen, wenn z.B. durch ToTop, ToBtm, ... die
     404             :     // Reihenfolgen der Objekte geaendert wurde. Der Aufruf erfolgt dann nach
     405             :     // jedem SdrObjList::SetObjectOrdNum(nOldPos,nNewPos);
     406             :     virtual void ObjOrderChanged(SdrObject* pObj, sal_uIntPtr nOldPos, sal_uIntPtr nNewPos);
     407             : 
     408             :     // Falls ein oder mehrere Objekte des Types SdrGrafObj oder SdrOle2Obj
     409             :     // markiert sind und diese in der Lage sind ein StarView-Metafile zu
     410             :     // liefern, konvertiert diese Methode das Metafile in Drawingobjekte.
     411             :     // Die SdrGrafObjs/SdrOle2Objs werden dann durch die neue Objekte ersetzt.
     412             :     void DoImportMarkedMtf(SvdProgressInfo *pProgrInfo=NULL);
     413           0 :     bool IsImportMtfPossible() const { ForcePossibilities(); return bImportMtfPossible; }
     414             : 
     415             :     // Wird der Modus VirtualObjectBundling eingeschaltet, werden beim
     416             :     // ToTop/ToBtm virtuelle Objekte die dasselbe Objekt referenzieren
     417             :     // in ihrer Z-Order buendig zusammengehalten (Writer).
     418             :     // Defaulteinstellung ist sal_False=ausgeschaltet.
     419           0 :     void SetVirtualObjectBundling(bool bOn) { bBundleVirtObj=bOn; }
     420             :     bool IsVirtualObjectBundling() const { return bBundleVirtObj; }
     421             : 
     422             :     // von der SdrMarkView ueberladen fuer den internen gebrauch
     423             :     virtual void MarkListHasChanged() SAL_OVERRIDE;
     424             :     virtual void ModelHasChanged() SAL_OVERRIDE;
     425             : };
     426             : 
     427             : #endif // INCLUDED_SVX_SVDEDTV_HXX
     428             : 
     429             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10