summaryrefslogtreecommitdiffstats
path: root/include/svx/svdedtv.hxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-15 05:54:39 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-15 05:54:39 +0000
commit267c6f2ac71f92999e969232431ba04678e7437e (patch)
tree358c9467650e1d0a1d7227a21dac2e3d08b622b2 /include/svx/svdedtv.hxx
parentInitial commit. (diff)
downloadlibreoffice-267c6f2ac71f92999e969232431ba04678e7437e.tar.xz
libreoffice-267c6f2ac71f92999e969232431ba04678e7437e.zip
Adding upstream version 4:24.2.0.upstream/4%24.2.0
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'include/svx/svdedtv.hxx')
-rw-r--r--include/svx/svdedtv.hxx441
1 files changed, 441 insertions, 0 deletions
diff --git a/include/svx/svdedtv.hxx b/include/svx/svdedtv.hxx
new file mode 100644
index 0000000000..1cf9be6fdb
--- /dev/null
+++ b/include/svx/svdedtv.hxx
@@ -0,0 +1,441 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * 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 .
+ */
+
+#ifndef INCLUDED_SVX_SVDEDTV_HXX
+#define INCLUDED_SVX_SVDEDTV_HXX
+
+#include <svx/svdmrkv.hxx>
+#include <svx/xpoly.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/svxdllapi.h>
+#include <svx/svdundo.hxx>
+#include <o3tl/typed_flags_set.hxx>
+
+class SfxUndoAction;
+class SdrUndoAction;
+class SdrUndoGroup;
+class SfxStyleSheet;
+class SdrLayer;
+class SvdProgressInfo;
+
+enum class SdrHorAlign {
+ NONE,
+ Left,
+ Right,
+ Center
+};
+
+enum class SdrVertAlign {
+ NONE,
+ Top,
+ Bottom,
+ Center
+};
+
+enum class SdrMergeMode {
+ Merge,
+ Subtract,
+ Intersect
+};
+
+// Options for InsertObject()
+enum class SdrInsertFlags
+{
+ NONE = 0x0000,
+ DONTMARK = 0x0001, /* object will not be marked (the actual marking remains) */
+ ADDMARK = 0x0002, /* object will be added an existing selection */
+ SETDEFATTR = 0x0004, /* actual attributes (+StyleSheet) are assigned to the object */
+ SETDEFLAYER = 0x0008, /* actual layer is assigned to the object */
+};
+namespace o3tl
+{
+ template<> struct typed_flags<SdrInsertFlags> : is_typed_flags<SdrInsertFlags, 0x0f> {};
+}
+
+class SVXCORE_DLLPUBLIC SdrEditView : public SdrMarkView
+{
+ friend class SdrPageView;
+ friend class SdrDragDistort;
+ friend class SdrDragCrook;
+
+protected:
+
+ // cache the transformation queries, etc. a little
+ bool m_bPossibilitiesDirty : 1;
+ bool m_bReadOnly : 1;
+ bool m_bGroupPossible : 1;
+ bool m_bUnGroupPossible : 1;
+ bool m_bGrpEnterPossible : 1;
+ bool m_bToTopPossible : 1;
+ bool m_bToBtmPossible : 1;
+ bool m_bReverseOrderPossible : 1;
+ bool m_bImportMtfPossible : 1;
+ bool m_bCombinePossible : 1;
+ bool m_bDismantlePossible : 1;
+ bool m_bCombineNoPolyPolyPossible : 1;
+ bool m_bDismantleMakeLinesPossible : 1;
+ bool m_bOrthoDesiredOnMarked : 1;
+ bool m_bOneOrMoreMovable : 1; // at least one object is moveable
+ bool m_bMoreThanOneNoMovRot : 1; // more than one object is not movable nor turnable (Crook)
+ bool m_bContortionPossible : 1; // all polygones (grouped if necessary)
+ bool m_bMoveAllowed : 1;
+ bool m_bResizeFreeAllowed : 1;
+ bool m_bResizePropAllowed : 1;
+ bool m_bRotateFreeAllowed : 1;
+ bool m_bRotate90Allowed : 1;
+ bool m_bMirrorFreeAllowed : 1;
+ bool m_bMirror45Allowed : 1;
+ bool m_bMirror90Allowed : 1;
+ bool m_bShearAllowed : 1;
+ bool m_bEdgeRadiusAllowed : 1;
+ bool m_bTransparenceAllowed : 1;
+ bool m_bCropAllowed : 1;
+ bool m_bGradientAllowed : 1;
+ bool m_bCanConvToPath : 1;
+ bool m_bCanConvToPoly : 1;
+ bool m_bCanConvToContour : 1;
+ bool m_bMoveProtect : 1;
+ bool m_bResizeProtect : 1;
+
+private:
+ SVX_DLLPRIVATE void ImpResetPossibilityFlags();
+
+protected:
+ void ImpBroadcastEdgesOfMarkedNodes();
+
+ // convert the objects marked in poly resp. bezier
+ void ImpConvertTo(bool bPath, bool bLineToArea);
+
+ // converts an object, when positive it removes the old one from its List
+ // and inserts the new one instead. including Undo.
+ // Nor MarkEntry nor ModelChgBroadcast is created.
+ rtl::Reference<SdrObject> ImpConvertOneObj(SdrObject* pObj, bool bPath, bool bLineToArea);
+
+ // set both flags: bToTopPossible and bToBtmPossible.
+ // bToTopPossibleDirty and bToBtmPossibleDirty are reset at the same time
+ void ImpCheckToTopBtmPossible();
+
+ // for CombineMarkedObjects and DismantleMarkedObjects
+ void ImpCopyAttributes(const SdrObject* pSource, SdrObject* pDest) const;
+
+ // for CombineMarkedObjects
+ static bool ImpCanConvertForCombine1(const SdrObject* pObj);
+ static bool ImpCanConvertForCombine(const SdrObject* pObj);
+ static basegfx::B2DPolyPolygon ImpGetPolyPolygon1(const SdrObject* pObj);
+ static basegfx::B2DPolyPolygon ImpGetPolyPolygon(const SdrObject* pObj);
+ static basegfx::B2DPolygon ImpCombineToSinglePolygon(const basegfx::B2DPolyPolygon& rPolyPolygon);
+
+ // for DismantleMarkedObjects
+ static bool ImpCanDismantle(const basegfx::B2DPolyPolygon& rPpolyPpolygon, bool bMakeLines);
+ static bool ImpCanDismantle(const SdrObject* pObj, bool bMakeLines);
+ void ImpDismantleOneObject(const SdrObject* pObj, SdrObjList& rOL, size_t& rPos, SdrPageView* pPV, bool bMakeLines);
+ static void ImpCrookObj(SdrObject* pO, const Point& rRef, const Point& rRad, SdrCrookMode eMode,
+ bool bVertical, bool bNoContortion, bool bRotate, const tools::Rectangle& rMarkRect);
+ static void ImpDistortObj(SdrObject* pO, const tools::Rectangle& rRef, const XPolygon& rDistortedRect, bool bNoContortion);
+ bool ImpDelLayerCheck(SdrObjList const * pOL, SdrLayerID nDelID) const;
+ void ImpDelLayerDelObjs(SdrObjList* pOL, SdrLayerID nDelID);
+
+ // Removes all objects of the MarkList from their ObjLists including Undo.
+ // The entries in rMark remain.
+ // @return a list of objects that must be deleted after the outermost EndUndo
+ std::vector<rtl::Reference<SdrObject>> DeleteMarkedList(SdrMarkList const& rMark); // DeleteMarked -> DeleteMarkedList
+
+ // Check possibilities of all marked objects
+ virtual void CheckPossibilities();
+ void ForcePossibilities() const { if (m_bPossibilitiesDirty || mbSomeObjChgdFlag) const_cast<SdrEditView*>(this)->CheckPossibilities(); }
+
+protected:
+ // #i71538# make constructors of SdrView sub-components protected to avoid incomplete incarnations which may get casted to SdrView
+ SdrEditView(
+ SdrModel& rSdrModel,
+ OutputDevice* pOut);
+
+ virtual ~SdrEditView() override;
+
+public:
+ // each call of an undo-capable method from its view, generates an undo action.
+ // If one wishes to group method calls into one, these calls should be put
+ // between BegUndo() and EndUndo() calls (unlimited).
+ // The comment used for the UndoAction is the first BegUndo(String).
+ // In this case NotifyNewUndoAction is called at the last EndUndo().
+ // NotifyNewUndoAction() is not called for an empty group
+ void BegUndo()
+ {
+ // open undo-grouping
+ GetModel().BegUndo();
+ }
+ void BegUndo(const OUString& rComment)
+ {
+ // open undo-grouping
+ GetModel().BegUndo(rComment);
+ }
+ void BegUndo(const OUString& rComment, const OUString& rObjDescr, SdrRepeatFunc eFunc=SdrRepeatFunc::NONE)
+ {
+ // open undo-grouping
+ GetModel().BegUndo(rComment,rObjDescr,eFunc);
+ }
+
+ void EndUndo(); // close undo-grouping (incl. BroadcastEdges)
+
+ void AddUndo(std::unique_ptr<SdrUndoAction> pUndo)
+ {
+ // add action
+ GetModel().AddUndo(std::move(pUndo));
+ }
+
+ // only after first BegUndo or before last EndUndo:
+ void SetUndoComment(const OUString& rComment, const OUString& rObjDescr)
+ {
+ GetModel().SetUndoComment(rComment,rObjDescr);
+ }
+
+ bool IsUndoEnabled() const;
+
+ /**
+ * Checks if this or other views have an active text edit, if true, end them.
+ */
+ void EndTextEditAllViews() const;
+ void EndTextEditCurrentView(bool bDontDeleteReally = false);
+
+ std::vector< std::unique_ptr<SdrUndoAction> > CreateConnectorUndo( const SdrObject& rO );
+ void AddUndoActions( std::vector< std::unique_ptr<SdrUndoAction> > );
+
+ // Layermanagement with Undo.
+ void InsertNewLayer(const OUString& rName, sal_uInt16 nPos);
+ // Delete a layer including all objects contained
+ void DeleteLayer(const OUString& rName);
+
+ // Marked objects which are outside a page
+ // are assigned to another page; at the moment without undo!!!
+ void ForceMarkedObjToAnotherPage();
+ void ForceMarkedToAnotherPage() { ForceMarkedObjToAnotherPage(); }
+
+ // delete all marked objects
+ void DeleteMarkedObj();
+
+ // Set a logical enclosing rectangle for all marked objects.
+ // It is not guaranteed if this succeeds, as a horizontal
+ // line has always a height of 0
+ void SetMarkedObjRect(const tools::Rectangle& rRect);
+ void MoveMarkedObj(const Size& rSiz, bool bCopy=false);
+ void ResizeMarkedObj(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bCopy=false);
+ void ResizeMultMarkedObj(const Point& rRef, const Fraction& xFact, const Fraction& yFact, const bool bWdh, const bool bHgt);
+ Degree100 GetMarkedObjRotate() const;
+ void RotateMarkedObj(const Point& rRef, Degree100 nAngle, bool bCopy=false);
+ void MirrorMarkedObj(const Point& rRef1, const Point& rRef2, bool bCopy=false);
+ void MirrorMarkedObjHorizontal();
+ void MirrorMarkedObjVertical();
+ Degree100 GetMarkedObjShear() const;
+ void ShearMarkedObj(const Point& rRef, Degree100 nAngle, bool bVShear=false, bool bCopy=false);
+ void CrookMarkedObj(const Point& rRef, const Point& rRad, SdrCrookMode eMode, bool bVertical, bool bNoContortion, bool bCopy=false);
+ void DistortMarkedObj(const tools::Rectangle& rRef, const XPolygon& rDistortedRect, bool bNoContortion, bool bCopy=false);
+
+ // copy marked objects and mark them instead of the old ones
+ void CopyMarkedObj();
+ void SetAllMarkedRect(const tools::Rectangle& rRect) { SetMarkedObjRect(rRect); }
+ void MoveAllMarked(const Size& rSiz, bool bCopy=false) { MoveMarkedObj(rSiz,bCopy); }
+ void ResizeAllMarked(const Point& rRef, const Fraction& xFact, const Fraction& yFact) { ResizeMarkedObj(rRef,xFact,yFact); }
+ void RotateAllMarked(const Point& rRef, Degree100 nAngle) { RotateMarkedObj(rRef,nAngle); }
+ void MirrorAllMarkedHorizontal() { MirrorMarkedObjHorizontal(); }
+ void MirrorAllMarkedVertical() { MirrorMarkedObjVertical(); }
+ void CopyMarked() { CopyMarkedObj(); }
+ bool IsMoveAllowed() const { ForcePossibilities(); return m_bMoveAllowed && !m_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 IsCropAllowed() const;
+ bool IsDistortAllowed(bool bNoContortion=false) const;
+
+ // Consolidate the text from multiple, selected TextObjects,
+ // attempting to identify paragraph fragments and join them together
+ void CombineMarkedTextObjects();
+
+ // Unite several objects to a polygon:
+ // - rectangles/circles/text... are implicitly converted.
+ // - polygones are closed automatically
+ // - attributes and layer are taken from the first object marked
+ // (thus from lowest Z-order).
+ // - group objects are included when all (!) member objects of
+ // the group can be changed. If a group includes for example
+ // a bitmap or an OLE-object, the complete group is not considered.
+ // bNoPolyPoly=TRUE: all is grouped to one single polygon
+ void CombineMarkedObjects(bool bNoPolyPoly = 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(sal_uInt16 SlotID);
+
+ // for setting either the width or height of all selected
+ // objects to the width/height of the last selected object
+ // of the selection
+ void EqualizeMarkedObjects(bool bWidth);
+
+ // Decompose marked polypolygon objects into polygons.
+ // Grouped objects are searched and decomposed, if all member objects are PathObjs.
+ // bMakeLines=TRUE: all polygones are decomposed into single lines resp. bezier segments
+ void DismantleMarkedObjects(bool bMakeLines=false);
+ bool IsCombinePossible(bool bNoPolyPoly=false) const;
+ bool IsDismantlePossible(bool bMakeLines=false) const;
+
+ // Inserts a new, completely constructed object. Subsequently the object belongs to
+ // the model. After insertion the object is marked (if not prevented by nOptions).
+ // Sometimes the object is not inserted, but deleted, this is the case when
+ // the target layer is locked or not visible. In this case
+ // the method returns FALSE.
+ // Amongst others the method does not create an undo-action.
+ bool InsertObjectAtView(SdrObject* pObj, SdrPageView& rPV, SdrInsertFlags nOptions=SdrInsertFlags::NONE);
+
+ // Replace one drawing object by another.
+ // *pNewObj belongs to me, *pOldObj is changed into Undo.
+ // In any case an undo grouping is required and should be applied, e.g.:
+ // aStr+=" replace";
+ // BegUndo(aStr);
+ // ReplaceObject(...);
+
+ // EndUndo();
+ void ReplaceObjectAtView(SdrObject* pOldObj, SdrPageView& rPV, SdrObject* pNewObj, bool bMark=true);
+
+ void SetNotPersistAttrToMarked(const SfxItemSet& rAttr);
+ void MergeNotPersistAttrFromMarked(SfxItemSet& rAttr) const;
+ void MergeAttrFromMarked(SfxItemSet& rAttr, bool bOnlyHardAttr) const;
+ SfxItemSet GetAttrFromMarked(bool bOnlyHardAttr) const;
+ void SetAttrToMarked(const SfxItemSet& rAttr, bool bReplaceAll);
+
+ // geometrical attribute (position, size, rotation angle)
+ // A PageOrigin set at a position is taken into account.
+ SfxItemSet GetGeoAttrFromMarked() const;
+ // In LOK, interactive shape movement uses this function
+ // in that case, margin is not taken into account
+ // and the final position of the shape becomes incorrect
+ // However, "Position and Size" dialog and other cases already add the margins.
+ void SetGeoAttrToMarked(const SfxItemSet& rAttr, bool addPageMargin = false);
+
+ // Returns NULL if:
+ // - nothing is marked,
+ // - no stylesheet is set at the marked object
+ // - point the marked objects to different StyleSheets for multiple selections
+ SfxStyleSheet* GetStyleSheetFromMarked() const;
+
+ // at the moment without undo :(
+ void SetStyleSheetToMarked(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr);
+
+ /* new interface src537 */
+ void GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const;
+
+ void SetAttributes(const SfxItemSet& rSet, bool bReplaceAll);
+ SfxStyleSheet* GetStyleSheet() const; // SfxStyleSheet* GetStyleSheet(bool& rOk) const;
+ void SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr);
+
+ // Group all marked objects to a single group.
+ // Subsequently mark the new group . If the group spawns multiple
+ // pages a group is created per page.
+ // All groups created are subsequently marked.
+ // The method creates SdrObjGroup-instances.
+ void GroupMarked();
+
+ // All marked object groups are dissolved (1 level).
+ // Now all previously marked member objects are marked.
+ // Previously marked objects, which are not group objects, remain marked.
+ void UnGroupMarked();
+
+ bool IsGroupPossible() const { ForcePossibilities(); return m_bGroupPossible; }
+ bool IsUnGroupPossible() const { ForcePossibilities(); return m_bUnGroupPossible; }
+ bool IsGroupEnterPossible() const { ForcePossibilities(); return m_bGrpEnterPossible; }
+
+ // Convert marked objects to polygones/Beziercurves. The bool-functions
+ // return sal_True, if at least one marked object could be converted.
+ // Also member objects of group objects are converted.
+ // For a better description see: SdrObj.HXX
+ bool IsConvertToPathObjPossible() const { ForcePossibilities(); return m_bCanConvToPath; }
+ bool IsConvertToPolyObjPossible() const { ForcePossibilities(); return m_bCanConvToPoly; }
+ bool IsConvertToContourPossible() const { ForcePossibilities(); return m_bCanConvToContour; }
+ void ConvertMarkedToPathObj(bool bLineToArea);
+ void ConvertMarkedToPolyObj();
+
+ // Align all marked objects vertically. Normally the SnapRect of an object is used.
+ void AlignMarkedObjects(SdrHorAlign eHor, SdrVertAlign eVert);
+ bool IsAlignPossible() const;
+
+ // move marked objects "up"
+ void MovMarkedToTop();
+
+ // move marked objects "down"
+ void MovMarkedToBtm();
+
+ // move marked objects "at top"
+ void PutMarkedToTop();
+
+ // move marked objects "at bottom"
+ void PutMarkedToBtm();
+
+ // move marked immediately before the object passed
+ // NULL -> as PutMarkedToTop();
+ void PutMarkedInFrontOfObj(const SdrObject* pRefObj);
+
+ // move marked immediately after object passed
+ // NULL -> as PutMarkedToBtm();
+ void PutMarkedBehindObj(const SdrObject* pRefObj);
+
+ // swap Z-Order of marked objects
+ void ReverseOrderOfMarked();
+
+ // Check if forward, backward is possible.
+ // GetMaxToBtmObj() is only partly taken into account by these methods.
+ // Which means it can happen that IsToTopPossible() returns sal_True,
+ // but MovMarkedToTop() changes nothing (e.g. for multiple selections),
+ // as restriction derived via a view by GetMaxToTopObj() prevents this.
+ bool IsToTopPossible() const { ForcePossibilities(); return m_bToTopPossible; }
+ bool IsToBtmPossible() const { ForcePossibilities(); return m_bToBtmPossible; }
+ bool IsReverseOrderPossible() const { ForcePossibilities(); return m_bReverseOrderPossible; }
+
+ // Using this method the view determines how far an object
+ // can be moved forward or backward (Z-order).
+ // The object returned is not "obsolete". When NULL is
+ // returned there is not such a restriction.
+ virtual SdrObject* GetMaxToTopObj(SdrObject* pObj) const;
+ virtual SdrObject* GetMaxToBtmObj(SdrObject* pObj) const;
+
+ // Next method is called, if via ToTop, ToBtm, ... the
+ // sequence of object has been changed. It is called after
+ // each SdrObjList::SetObjectOrdNum(nOldPos,nNewPos);
+ virtual void ObjOrderChanged(SdrObject* pObj, size_t nOldPos, size_t nNewPos);
+
+ // If one or more objects of the type SdrGrafObj or SdrOle2Obj
+ // are marked and these are capable to deliver a StarView-metafile,
+ // this methods converts the metafile to a drawing object.
+ // The SdrGrafObjs/SdrOle2Objs are replaced by the new objects.
+ void DoImportMarkedMtf(SvdProgressInfo *pProgrInfo=nullptr);
+ bool IsImportMtfPossible() const { ForcePossibilities(); return m_bImportMtfPossible; }
+
+ // override SdrMarkView, for internal use
+ virtual void MarkListHasChanged() override;
+ virtual void ModelHasChanged() override;
+};
+
+#endif // INCLUDED_SVX_SVDEDTV_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */