diff options
Diffstat (limited to 'svx/inc/svx/svdedtv.hxx')
| -rw-r--r-- | svx/inc/svx/svdedtv.hxx | 473 |
1 files changed, 473 insertions, 0 deletions
diff --git a/svx/inc/svx/svdedtv.hxx b/svx/inc/svx/svdedtv.hxx new file mode 100644 index 000000000000..98e76bf28969 --- /dev/null +++ b/svx/inc/svx/svdedtv.hxx @@ -0,0 +1,473 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef _SVDEDTV_HXX +#define _SVDEDTV_HXX + +#include <svx/svdmrkv.hxx> +#include <svx/xpoly.hxx> +#include <svx/svdmodel.hxx> +#include "svx/svxdllapi.h" + +//************************************************************ +// Vorausdeklarationen +//************************************************************ + +class SfxUndoAction; +class SdrUndoAction; +class SdrUndoGroup; +class SfxStyleSheet; +class SdrLayer; +class SvdProgressInfo; + +//************************************************************ +// Defines +//************************************************************ + +enum SdrHorAlign { + SDRHALIGN_NONE, + SDRHALIGN_LEFT, + SDRHALIGN_RIGHT, + SDRHALIGN_CENTER +}; + +enum SdrVertAlign { + SDRVALIGN_NONE, + SDRVALIGN_TOP, + SDRVALIGN_BOTTOM, + SDRVALIGN_CENTER +}; + +enum SdrMergeMode { + SDR_MERGE_MERGE, + SDR_MERGE_SUBSTRACT, + SDR_MERGE_INTERSECT +}; + +// Optionen fuer InsertObject() +#define SDRINSERT_DONTMARK 0x0001 /* Obj wird nicht markiert (aktuelle Markierung bleibt bestehen) */ +#define SDRINSERT_ADDMARK 0x0002 /* Das Obj wird zu einer ggf. bereits bestehenden Selektion hinzumarkiert */ +#define SDRINSERT_SETDEFATTR 0x0004 /* Die aktuellen Attribute (+StyleSheet) werden dem Obj zugewiesen */ +#define SDRINSERT_SETDEFLAYER 0x0008 /* Der aktuelle Layer wird dem Obj zugewiesen */ +#define SDRINSERT_NOBROADCAST 0x0010 /* Einfuegen mit NbcInsertObject() fuer SolidDragging */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// +// +// @@@@@ @@@@@ @@ @@@@@@ @@ @@ @@ @@@@@ @@ @@ +// @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ +// @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @ @@ +// @@@@ @@ @@ @@ @@ @@@@@ @@ @@@@ @@@@@@@ +// @@ @@ @@ @@ @@ @@@ @@ @@ @@@@@@@ +// @@ @@ @@ @@ @@ @@@ @@ @@ @@@ @@@ +// @@@@@ @@@@@ @@ @@ @ @@ @@@@@ @@ @@ +// +//////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +class SVX_DLLPUBLIC SdrEditView: public SdrMarkView +{ + friend class SdrPageView; + friend class SdrDragDistort; + friend class SdrDragCrook; + +protected: + + // Die Transformationsnachfragen, etc. etwas cachen + unsigned bPossibilitiesDirty : 1; + unsigned bReadOnly : 1; + unsigned bGroupPossible : 1; + unsigned bUnGroupPossible : 1; + unsigned bGrpEnterPossible : 1; + unsigned bDeletePossible : 1; + unsigned bToTopPossible : 1; + unsigned bToBtmPossible : 1; + unsigned bReverseOrderPossible : 1; + unsigned bImportMtfPossible : 1; + unsigned bCombinePossible : 1; + unsigned bDismantlePossible : 1; + unsigned bCombineNoPolyPolyPossible : 1; + unsigned bDismantleMakeLinesPossible : 1; + unsigned bOrthoDesiredOnMarked : 1; + unsigned bMoreThanOneNotMovable : 1; // Es ist mehr als ein Objekt nicht verschiebbar + unsigned bOneOrMoreMovable : 1; // Wenigstens 1 Obj verschiebbar + unsigned bMoreThanOneNoMovRot : 1; // Es ist mehr als ein Objekt nicht verschieb- und drehbar (Crook) + unsigned bContortionPossible : 1; // Alles Polygone (ggf. gruppiert) + unsigned bAllPolys : 1; // Alles Polygone (nicht gruppiert) + unsigned bOneOrMorePolys : 1; // Mindestens 1 Polygon (nicht gruppiert) + unsigned bMoveAllowed : 1; + unsigned bResizeFreeAllowed : 1; + unsigned bResizePropAllowed : 1; + unsigned bRotateFreeAllowed : 1; + unsigned bRotate90Allowed : 1; + unsigned bMirrorFreeAllowed : 1; + unsigned bMirror45Allowed : 1; + unsigned bMirror90Allowed : 1; + unsigned bShearAllowed : 1; + unsigned bEdgeRadiusAllowed : 1; + unsigned bTransparenceAllowed : 1; + unsigned bGradientAllowed : 1; + unsigned bCanConvToPath : 1; + unsigned bCanConvToPoly : 1; + unsigned bCanConvToContour : 1; + unsigned bCanConvToPathLineToArea : 1; + unsigned bCanConvToPolyLineToArea : 1; + unsigned bMoveProtect : 1; + unsigned bResizeProtect : 1; + // Z-Order von virtuellen Objekten zusammenhalten (Writer) + unsigned bBundleVirtObj : 1; + +private: + SVX_DLLPRIVATE void ImpClearVars(); + SVX_DLLPRIVATE void ImpResetPossibilityFlags(); + +protected: + void ImpBroadcastEdgesOfMarkedNodes(); + + // Konvertierung der markierten Objekte in Poly bzw. Bezier. + void ImpConvertTo(BOOL bPath, BOOL bLineToArea); + + // Konvertiert ein Obj, wirft bei Erfolg das alte as seiner Liste und + // fuegt das neue an dessen Position ein. Inkl Undo. Es wird weder ein + // MarkEntry noch ein ModelChgBroadcast generiert. + SdrObject* ImpConvertOneObj(SdrObject* pObj, BOOL bPath, BOOL bLineToArea); + + // Setzen der beiden Flags bToTopPossible und bToBtmPossible. + // bToTopPossibleDirty und bToBtmPossibleDirty werden dabei gleichzeitig + // zurueckgesetzt. + void ImpCheckToTopBtmPossible(); + + // fuer den Writer werden virtuelle Objekte buendig zusammengehalten (Z-Order) + void ImpBundleVirtObjOfMarkList(); + + // fuer CombineMarkedObjects und DismantleMarkedObjects + void ImpCopyAttributes(const SdrObject* pSource, SdrObject* pDest) const; + + // fuer CombineMarkedObjects + sal_Bool ImpCanConvertForCombine1(const SdrObject* pObj) const; + sal_Bool ImpCanConvertForCombine(const SdrObject* pObj) const; + basegfx::B2DPolyPolygon ImpGetPolyPolygon1(const SdrObject* pObj, sal_Bool bCombine) const; + basegfx::B2DPolyPolygon ImpGetPolyPolygon(const SdrObject* pObj, sal_Bool bCombine) const; + basegfx::B2DPolygon ImpCombineToSinglePolygon(const basegfx::B2DPolyPolygon& rPolyPolygon) const; + + // fuer DismantleMarkedObjects + sal_Bool ImpCanDismantle(const basegfx::B2DPolyPolygon& rPpolyPpolygon, sal_Bool bMakeLines) const; + sal_Bool ImpCanDismantle(const SdrObject* pObj, sal_Bool bMakeLines) const; + void ImpDismantleOneObject(const SdrObject* pObj, SdrObjList& rOL, ULONG& rPos, SdrPageView* pPV, BOOL bMakeLines); + void ImpCrookObj(SdrObject* pO, const Point& rRef, const Point& rRad, SdrCrookMode eMode, + BOOL bVertical, BOOL bNoContortion, BOOL bRotate, const Rectangle& rMarkRect); + void ImpDistortObj(SdrObject* pO, const Rectangle& rRef, const XPolygon& rDistortedRect, BOOL bNoContortion); + BOOL ImpDelLayerCheck(SdrObjList* pOL, SdrLayerID nDelID) const; + void ImpDelLayerDelObjs(SdrObjList* pOL, SdrLayerID nDelID); + + // Entfernt alle Obj der MarkList aus ihren ObjLists inkl Undo. + // Die Eintraege in rMark bleiben erhalten. + void DeleteMarkedList(const SdrMarkList& rMark); // DeleteMarked -> DeleteMarkedList + + // Die Transformationsnachfragen etwas cachen + //void ImpCheckMarkTransform() const; veraltet + // Checken, was man so mit den markierten Objekten alles machen kann + virtual void CheckPossibilities(); + void ForcePossibilities() const { if (bPossibilitiesDirty || bSomeObjChgdFlag) ((SdrEditView*)this)->CheckPossibilities(); } + +protected: + // #i71538# make constructors of SdrView sub-components protected to avoid incomplete incarnations which may get casted to SdrView + SdrEditView(SdrModel* pModel1, OutputDevice* pOut = 0L); + virtual ~SdrEditView(); + +public: + // Jeder Aufruf einer undofaehigen Methode an der View generiert eine + // UndoAction. Moechte man mehrere + // Methodenaufrufe zu einer UndoAction zusammenfassen, so kann man diese + // mit BegUndo() / EndUndo() klammern (beliebig tief). Als Kommentar der + // UndoAction wird der des ersten BegUndo(String) aller Klammerungen + // verwendet. NotifyNewUndoAction() wird in diesem Fall erst beim letzten + // EndUndo() gerufen. NotifyNewUndoAction() wird nicht gerufen bei einer + // leeren Klammerung. +#ifndef WIN + void BegUndo() { pMod->BegUndo(); } // Undo-Klammerung auf + void BegUndo(const String& rComment) { pMod->BegUndo(rComment); } // Undo-Klammerung auf + void BegUndo(const String& rComment, const String& rObjDescr, SdrRepeatFunc eFunc=SDRREPFUNC_OBJ_NONE) { pMod->BegUndo(rComment,rObjDescr,eFunc); } // Undo-Klammerung auf + void BegUndo(SdrUndoGroup* pUndoGrp) { pMod->BegUndo(pUndoGrp); } // Undo-Klammerung auf + void EndUndo(); // Undo-Klammerung zu (inkl BroadcastEdges) + void AddUndo(SdrUndoAction* pUndo) { pMod->AddUndo(pUndo); } // Action hinzufuegen + // nur nach dem 1. BegUndo oder vor dem letzten EndUndo: + void SetUndoComment(const String& rComment) { pMod->SetUndoComment(rComment); } + void SetUndoComment(const String& rComment, const String& rObjDescr) { pMod->SetUndoComment(rComment,rObjDescr); } +#else // ifndef WIN + void BegUndo(); + void BegUndo(const String& rComment); + void BegUndo(const String& rComment, const String& rObjDescr, SdrRepeatFunc eFunc=SDRREPFUNC_OBJ_NONE); + void BegUndo(SdrUndoGroup* pUndoGrp); + void EndUndo(); // Undo-Klammerung zu (inkl BroadcastEdges) + void AddUndo(SdrUndoAction* pUndo); + // nur nach dem 1. BegUndo oder vor dem letzten EndUndo: + void SetUndoComment(const String& rComment); + void SetUndoComment(const String& rComment, const String& rObjDescr); +#endif + bool IsUndoEnabled() const; + + std::vector< SdrUndoAction* > CreateConnectorUndo( SdrObject& rO ); + void AddUndoActions( std::vector< SdrUndoAction* >& ); + + // Layerverwaltung. Mit Undo. + SdrLayer* InsertNewLayer(const String& rName, USHORT nPos=0xFFFF); + // Loeschen eines Layer inkl. aller darauf befindlichen Objekte + void DeleteLayer(const String& rName); + // Verschieben eines Layer (Layerreihenfolge aendern) + void MoveLayer(const String& rName, USHORT nNewPos); + + // Markierte Objekte die ausserhalb ihrer Page liegen + // werden ggf. einer anderen Page zugewiesen + // z.Zt. noch ohne Undo!!! + void ForceMarkedObjToAnotherPage(); + void ForceMarkedToAnotherPage() { ForceMarkedObjToAnotherPage(); } + + BOOL IsReadOnly() const { ForcePossibilities(); return bReadOnly; } + + // Loeschen aller markierten Objekte + void DeleteMarkedObj(); + BOOL IsDeleteMarkedObjPossible() const { ForcePossibilities(); return bDeletePossible; } + + // Logisch- umschliessendes Rect aller markierten Objekte setzen. + // Das das wirklich geschieht ist nicht garantiert, denn eine + // waagerechte Linie hat z.B. immer eine Hoehe von 0. + void SetMarkedObjRect(const Rectangle& rRect, BOOL bCopy=FALSE); + void MoveMarkedObj(const Size& rSiz, bool bCopy=false); + void ResizeMarkedObj(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bCopy=false); + long GetMarkedObjRotate() const; + void RotateMarkedObj(const Point& rRef, long nWink, bool bCopy=false); + void MirrorMarkedObj(const Point& rRef1, const Point& rRef2, bool bCopy=false); + void MirrorMarkedObjHorizontal(BOOL bCopy=FALSE); + void MirrorMarkedObjVertical(BOOL bCopy=FALSE); + long GetMarkedObjShear() const; + void ShearMarkedObj(const Point& rRef, long nWink, bool bVShear=false, bool bCopy=false); + void CrookMarkedObj(const Point& rRef, const Point& rRad, SdrCrookMode eMode, bool bVertical=false, bool bNoContortion=false, bool bCopy=false); + void DistortMarkedObj(const Rectangle& rRef, const XPolygon& rDistortedRect, bool bNoContortion=false, bool bCopy=false); + + // Markierte Objekte kopieren und anstelle der alten markieren + void CopyMarkedObj(); + void SetAllMarkedRect(const Rectangle& rRect, BOOL bCopy=FALSE) { SetMarkedObjRect(rRect,bCopy); } + void MoveAllMarked(const Size& rSiz, BOOL bCopy=FALSE) { MoveMarkedObj (rSiz,bCopy); } + void ResizeAllMarked(const Point& rRef, const Fraction& xFact, const Fraction& yFact, BOOL bCopy=FALSE) { ResizeMarkedObj (rRef,xFact,yFact,bCopy); } + long GetAllMarkedRotate() const { return GetMarkedObjRotate(); } + void RotateAllMarked(const Point& rRef, long nWink, BOOL bCopy=FALSE) { RotateMarkedObj(rRef,nWink,bCopy); } + void MirrorAllMarked(const Point& rRef1, const Point& rRef2, BOOL bCopy=FALSE) { MirrorMarkedObj(rRef1,rRef2,bCopy); } + void MirrorAllMarkedHorizontal(BOOL bCopy=FALSE) { MirrorMarkedObjHorizontal(bCopy); } + void MirrorAllMarkedVertical(BOOL bCopy=FALSE) { MirrorMarkedObjVertical(bCopy); } + long GetAllMarkedShear() const { return GetMarkedObjShear(); } + void ShearAllMarked(const Point& rRef, long nWink, BOOL bVShear=FALSE, BOOL bCopy=FALSE) { ShearMarkedObj(rRef,nWink,bVShear,bCopy); } + 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); } + void CopyMarked() { CopyMarkedObj(); } + BOOL IsMoveAllowed() const { ForcePossibilities(); return bMoveAllowed && !bMoveProtect; } + BOOL IsResizeAllowed(BOOL bProp=FALSE) const; + BOOL IsRotateAllowed(BOOL b90Deg=FALSE) const; + BOOL IsMirrorAllowed(BOOL b45Deg=FALSE, BOOL b90Deg=FALSE) const; + BOOL IsTransparenceAllowed() const; + BOOL IsGradientAllowed() const; + BOOL IsShearAllowed() const; + BOOL IsEdgeRadiusAllowed() const; + BOOL IsCrookAllowed(BOOL bNoContortion=FALSE) const; + BOOL IsDistortAllowed(BOOL bNoContortion=FALSE) const; + + // Vereinigen mehrerer Objekte zu einem PolyPolygon: + // - Rechtecke/Kreise/Text... werden implizit gewandelt. + // - Polylines werden automatisch geschlossen. + // - Die Attribute und der Layer werden vom Ersten der markierten Objekte + // uebernommen (also vom untersten der Z-Order). + // - Gruppenobjekte werden miteinbezogen, wenn alle! Memberobjekte der + // Gruppe wandelbar sind. Beinhaltet eine Gruppe also beispielsweise + // eine Bitmap oder ein OLE-Objekt, wird die gesamte Gruppe nicht + // beruecksichtigt. + // bNoPolyPoly=TRUE: Alles wird zu einem einzigen Polygon zusammengefasst + void CombineMarkedObjects(sal_Bool bNoPolyPoly = sal_True); + + // for combining multiple polygons, with direct support of the modes + // SID_POLY_MERGE, SID_POLY_SUBSTRACT, SID_POLY_INTERSECT + void MergeMarkedObjects(SdrMergeMode eMode); + + // for distribution dialog function + void DistributeMarkedObjects(); + + // Markierte Polypolygonobjekte in Polygone zerlegen + // Gruppenobjekte werden durchsucht und zerlegt, wenn es sich bei allen + // Memberobjekten um PathObjs handelt. + // bMakeLines=TRUE: alle Polygone werden in einzelne Linien bzw. + // Beziersegmente zerlegt + void DismantleMarkedObjects(BOOL bMakeLines=FALSE); + BOOL IsCombinePossible(BOOL bNoPolyPoly=FALSE) const; + BOOL IsDismantlePossible(BOOL bMakeLines=FALSE) const; + + // Ein neues bereits fertig konstruiertes Obj einfuegen. Das Obj gehoert + // anschliessend dem Model. Nach dem Einfuegen wird das neue Objekt + // markiert (wenn dies nicht via nOptions unterbunden wird). + // U.U. wird das Obj jedoch nicht eingefuegt, sondern deleted, naemlich + // wenn der Ziel-Layer gesperrt oder nicht sichtbar ist. In diesem Fall + // returniert die Methode mit FALSE. + // Die Methode generiert u.a. auch eine Undo-Action. + BOOL InsertObjectAtView(SdrObject* pObj, SdrPageView& rPV, ULONG nOptions=0); + + // Ein Zeichenobjekt durch ein neues ersetzen. *pNewObj gehoert + // anschliessend mir, *pOldObj wandert ins Undo. + // Sollte in jedem Fall mit einer Undo-Klammerung versehen werden, z.B.: + // aStr+=" ersetzen"; + // BegUndo(aStr); + // ReplaceObject(...); + // ... + // EndUndo(); + void ReplaceObjectAtView(SdrObject* pOldObj, SdrPageView& rPV, SdrObject* pNewObj, BOOL bMark=TRUE); + + void SetNotPersistAttrToMarked(const SfxItemSet& rAttr, BOOL bReplaceAll); + void MergeNotPersistAttrFromMarked(SfxItemSet& rAttr, BOOL bOnlyHardAttr) const; + void MergeAttrFromMarked(SfxItemSet& rAttr, BOOL bOnlyHardAttr) const; + SfxItemSet GetAttrFromMarked(BOOL bOnlyHardAttr) const; + void SetAttrToMarked(const SfxItemSet& rAttr, BOOL bReplaceAll); + + // Geometrische Attribute (Position, Groesse, Drehwinkel) + // Bei der Position wird ein evtl. gesetzter PageOrigin beruecksichtigt. + SfxItemSet GetGeoAttrFromMarked() const; + void SetGeoAttrToMarked(const SfxItemSet& rAttr); + + // Returnt NULL wenn: + // - Nix markiert, + // - kein StyleSheet an den markierten Objekten gesetzt + // - Bei Mehrfachselektion die markierten Objekte auf unterschiedliche + // StyleSheets verweisen. + SfxStyleSheet* GetStyleSheetFromMarked() const; + + // z.Zt. noch ohne Undo :( + void SetStyleSheetToMarked(SfxStyleSheet* pStyleSheet, BOOL bDontRemoveHardAttr); + + /* new interface src537 */ + BOOL GetAttributes(SfxItemSet& rTargetSet, BOOL bOnlyHardAttr) const; + + BOOL SetAttributes(const SfxItemSet& rSet, BOOL bReplaceAll); + SfxStyleSheet* GetStyleSheet() const; // SfxStyleSheet* GetStyleSheet(BOOL& rOk) const; + BOOL SetStyleSheet(SfxStyleSheet* pStyleSheet, BOOL bDontRemoveHardAttr); + + // Alle markierten Objekte zu einer Gruppe zusammenfassen. + // Anschliessend wird die neue Gruppe markiert. Bei einer + // seitenuebergreifenden Markierung wird eine Gruppe je Seite erzeugt. + // Alle erzeugten Gruppen sind anschliessend markiert. + // Ueber pUserGrp kann ein eigenes Gruppenobjekt vorgegeben werden. Dieses + // wird jedoch nicht direkt verwendet, sondern via Clone kopiert. + // Wird NULL uebergeben, macht sich die Methode SdrObjGroup-Instanzen. + void GroupMarked(const SdrObject* pUserGrp=NULL); + + // Alle markierten Objektgruppen werden aufgeloesst (1 Level). + // Anschliessend sind statt der Gruppenobjekte alle ehemaligen + // Memberobjekte der aufgeloesten Gruppen markiert. Waren zum auch Objekte + // markiert, die keine Gruppenobjekte sind, so bleiben diese weiterhin + // zusaetzlich markiert. + void UnGroupMarked(); + + BOOL IsGroupPossible() const { ForcePossibilities(); return bGroupPossible; } + BOOL IsUnGroupPossible() const { ForcePossibilities(); return bUnGroupPossible; } + BOOL IsGroupEnterPossible() const { ForcePossibilities(); return bGrpEnterPossible; } + + // Markierte Objekte in Polygone/Bezierkurven verwandeln. Die BOOL- + // Funktionen returnen TRUE, wenn wenigstens eins der markierten + // Objekte gewandelt werden kann. Memberobjekte von Gruppenobjekten + // werden ebenfalls gewandelt. Naehere Beschreibung siehe SdrObj.HXX. + BOOL IsConvertToPathObjPossible(BOOL bLineToArea) const { ForcePossibilities(); return BOOL(bLineToArea ? bCanConvToPathLineToArea : bCanConvToPath); } + BOOL IsConvertToPolyObjPossible(BOOL bLineToArea) const { ForcePossibilities(); return BOOL(bLineToArea ? bCanConvToPolyLineToArea : bCanConvToPoly); } + BOOL IsConvertToContourPossible() const { ForcePossibilities(); return bCanConvToContour; } + void ConvertMarkedToPathObj(BOOL bLineToArea); + void ConvertMarkedToPolyObj(BOOL bLineToArea); + + // Alle markierten Objekte untereinander ausrichten. Normalerweise werden + // das SnapRect der Obj verwendet. Ist bBoundRects=TRUE, werden stattdessen + // die BoundRects ausgerichtet. + void AlignMarkedObjects(SdrHorAlign eHor, SdrVertAlign eVert, BOOL bBoundRects=FALSE); + BOOL IsAlignPossible() const; + + // Markierte Objekte etwas nach "oben" holen + void MovMarkedToTop(); + + // Markierte Objekte etwas nach "unten" holen + void MovMarkedToBtm(); + + // Markierte Objekte ganz nach "oben" stellen + void PutMarkedToTop(); + + // Markierte Objekte ganz nach "unten" stellen + void PutMarkedToBtm(); + + // Markierte direkt vor das uebergebene Objekt stellen + // NULL -> wie PutMarkedToTop(); + void PutMarkedInFrontOfObj(const SdrObject* pRefObj); + + // Markierte direkt hinter das uebergebene Objekt stellen + // NULL -> wie PutMarkedToBtm(); + void PutMarkedBehindObj(const SdrObject* pRefObj); + + // Z-Order der markierten Objekte vertauschen + void ReverseOrderOfMarked(); + + // Feststellen, ob nach vorn/hinten stellen moeglich ist + // GetMaxToTop/BtmObj() wird von diesen Methoden nur begrenzt + // beruecksichtigt, d.h. es kann vorkommen dass IsToTopPossible() + // TRUE liefert, MovMarkedToTop() jedoch nichts aendert (z.B. bei + // Mehrfachselektion), weil eine von der abgeleiteten View ueber + // GetMaxToTopObj() auferlegte Restriktion dies verhindert. + BOOL IsToTopPossible() const { ForcePossibilities(); return bToTopPossible; } + BOOL IsToBtmPossible() const { ForcePossibilities(); return bToBtmPossible; } + BOOL IsReverseOrderPossible() const { ForcePossibilities(); return bReverseOrderPossible; } + + // Ueber diese Methoden stellt die View fest, wie weit ein Objekt + // nach vorn bzw. nach hinten gestellt werden darf (Z-Order). Das + // zurueckgegebene Objekt wird dann nicht "ueberholt". Bei Rueckgabe + // von NULL (Defaultverhalten) bestehen keine Restriktionen. + virtual SdrObject* GetMaxToTopObj(SdrObject* pObj) const; + virtual SdrObject* GetMaxToBtmObj(SdrObject* pObj) const; + + // Folgende Methode wird gerufen, wenn z.B. durch ToTop, ToBtm, ... die + // Reihenfolgen der Objekte geaendert wurde. Der Aufruf erfolgt dann nach + // jedem SdrObjList::SetObjectOrdNum(nOldPos,nNewPos); + virtual void ObjOrderChanged(SdrObject* pObj, ULONG nOldPos, ULONG nNewPos); + + // Falls ein oder mehrere Objekte des Types SdrGrafObj oder SdrOle2Obj + // markiert sind und diese in der Lage sind ein StarView-Metafile zu + // liefern, konvertiert diese Methode das Metafile in Drawingobjekte. + // Die SdrGrafObjs/SdrOle2Objs werden dann durch die neue Objekte ersetzt. + void DoImportMarkedMtf(SvdProgressInfo *pProgrInfo=NULL); + BOOL IsImportMtfPossible() const { ForcePossibilities(); return bImportMtfPossible; } + + // Wird der Modus VirtualObjectBundling eingeschaltet, werden beim + // ToTop/ToBtm virtuelle Objekte die dasselbe Objekt referenzieren + // in ihrer Z-Order buendig zusammengehalten (Writer). + // Defaulteinstellung ist FALSE=ausgeschaltet. + void SetVirtualObjectBundling(BOOL bOn) { bBundleVirtObj=bOn; } + BOOL IsVirtualObjectBundling() const { return bBundleVirtObj; } + + // von der SdrMarkView ueberladen fuer den internen gebrauch + virtual void MarkListHasChanged(); + virtual void ModelHasChanged(); +}; + +#endif //_SVDEDTV_HXX + |