/* -*- 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 .
*/
// The following is not yet implemented, or just partially: enumclass SdrSearchOptions
{
NONE = 0x0000,
DEEP = 0x0001, /* recursive into group objects */
ALSOONMASTER = 0x0002, /* MasterPages are also scanned */
WHOLEPAGE = 0x0004, /* Not just the ObjList of PageView */
TESTMARKABLE = 0x0008, /* just markable objects/points/handles/... */
TESTMACRO = 0x0010, /* Just objects with macro */
TESTTEXTEDIT = 0x0020, /* Just TextEdit-enabled objects */
MARKED = 0x0040, /* Just marked objects/points/... */
PASS2BOUND = 0x0080, /* In case of empty search results, then 2nd. try with BoundRectHit */
BEFOREMARK = 0x0100, /* if one marked one found, ignore all behind that */
IMPISMASTER = 0x0200, /* MasterPage is being searched right now */
PICKMARKABLE = TESTMARKABLE,
PICKTEXTEDIT = DEEP | TESTMARKABLE | TESTTEXTEDIT,
PICKMACRO = DEEP | ALSOONMASTER | WHOLEPAGE | TESTMACRO,
}; namespace o3tl
{ template<> struct typed_flags<SdrSearchOptions> : is_typed_flags<SdrSearchOptions, 0x03ff> {};
}
enumclass SdrHitKind
{
NONE, // No hit
Object, // Hit
Handle, // Marking handle
HelpLine, // Reference line
Gluepoint, // Gluepoint
TextEdit, // Open OutlinerView was hit
TextEditObj, // Object for SdrBeginTextEdit (Textbereich)
UrlField, // Field in TextObj was hit (while it is currently not edited)
Macro, // Object for BegMacroObj
MarkedObject, // Marked object (e.g. for dragging)
UnmarkedObject, // non-marked Object (e.g. for marking)
Cell // hit on a cell inside a table shape (outside of the cells text area)
};
enumclass SdrViewEditMode {
Edit, // Also known as arrow or pointer mode
Create, // Tool for object creation
GluePointEdit // Gluepoint editing mode
};
protected:
SdrObject* mpMarkedObj; // If not just one object ( i.e. More than one object ) is marked.
SdrPageView* mpMarkedPV; // If all marked objects are situated on the same PageView.
Point maRef1; // Persistent - Rotation center / axis of reflection
Point maRef2; // Persistent
SdrHdlList maHdlList;
bool mbDesignMode : 1; // DesignMode for SdrUnoObj bool mbForceFrameHandles : 1; // Persistent - FrameDrag also for single objects bool mbPlusHdlAlways : 1; // Persistent bool mbInsPolyPoint : 1; // at this time InsPolyPointDragging bool mbMarkedObjRectDirty : 1; bool mbMrkPntDirty : 1; bool mbMarkedPointsRectsDirty : 1;
// flag to completely disable handles at the view bool mbMarkHandlesHidden : 1;
// flag indicating whether all x coordinates are negated or not bool mbNegativeX : 1;
// Helper to get a possible GridOffset from SdrObject
SAL_DLLPRIVATE bool getPossibleGridOffsetForSdrObject(
basegfx::B2DVector& rOffset, const SdrObject* pObj, const SdrPageView* pPV) const;
// Helper to get a possible GridOffset from Position
SAL_DLLPRIVATE bool getPossibleGridOffsetForPosition(
basegfx::B2DVector& rOffset, const basegfx::B2DPoint& rPoint, const SdrPageView* pPV) const;
// Generates a string including degrees symbol, from an angel specification in 1/100deg
SAL_DLLPRIVATE bool ImpMarkPoint(SdrHdl* pHdl, SdrMark* pMark, bool bUnmark); virtualbool MarkPoints(const tools::Rectangle* pRect, bool bUnmark); bool MarkGluePoints(const tools::Rectangle* pRect, bool bUnmark);
SAL_DLLPRIVATE void SetMoveOutside(bool bOn); bool MarkableObjectsExceed( int n ) const;
protected: // #i71538# make constructors of SdrView sub-components protected to avoid incomplete incarnations which may get casted to SdrView
SAL_DLLPRIVATE SdrMarkView(
SdrModel& rSdrModel,
OutputDevice* pOut);
// Returns sal_True if objects, points or gluepoints are selected by drawing a frame // (as long as the frame is drawn). bool IsMarking() const { return IsMarkObj() || IsMarkPoints() || IsMarkGluePoints(); }
/// whether all x coordinates in use are negated or not void SetNegativeX(bool bOn) { mbNegativeX = bOn; } bool IsNegativeX() const { return mbNegativeX; }
SAL_DLLPRIVATE void SetInnerTextAreaForLOKit() const;
// migrate selections
protected: // all available changing methods
SdrMarkList& GetMarkedObjectListWriteAccess() { return maSdrViewSelection.GetMarkedObjectListWriteAccess(); }
public: // all available const methods for read access to selection const SdrMarkList& GetMarkedObjectList() const { return maSdrViewSelection.GetMarkedObjectList(); }
// Get a list of all those links which are connected to marked nodes, // but which are not marked themselves. const SdrMarkList& GetEdgesOfMarkedNodes() const { return maSdrViewSelection.GetEdgesOfMarkedNodes(); } const SdrMarkList& GetMarkedEdgesOfMarkedNodes() const { return maSdrViewSelection.GetMarkedEdgesOfMarkedNodes(); } const std::vector<SdrObject*>& GetTransitiveHullOfMarkedObjects() const { return maSdrViewSelection.GetAllMarkedObjects(); }
// mechanism to complete disable handles at the view. Handles will be hidden and deleted // when set, no new ones created, no interaction allowed. Handles will be recreated and shown // when reset. Default is false. void hideMarkHandles(); void showMarkHandles(); bool areMarkHandlesHidden() const { return mbMarkHandlesHidden; }
bool IsMarkedHit(const Point& rPnt, short nTol=-2) const { return IsMarkedObjHit(rPnt,nTol); } bool IsMarkedObjHit(const Point& rPnt, short nTol=-2) const;
// Pick: Supported options for nOptions are SdrSearchOptions::PASS2BOUND
SAL_DLLPRIVATE bool PickMarkedObj(const Point& rPnt, SdrObject*& rpObj, SdrPageView*& rpPV, SdrSearchOptions nOptions) const;
// Selects the most upper of the marked objects (O1) and scans from there // towards bottom direction, selecting the first non-marked object (O2). // In case of success the marking of O1 is deleted, a marking is created at // O2 and TRUE is returned. With the parameter bPrev=sal_True the scan // direction is turned to the other direction. bool MarkNextObj(bool bPrev=false);
// Selects the most upper of the marked objects which is hit by rPnt/nTol // and scans from there to bottom direction, selecting the first non-marked // object (O2). In case of success the marking of O1 is deleted, a marking // is created at O2 and sal_True is returned. With the parameter // bPrev=sal_True the scan direction is turned to the other direction. bool MarkNextObj(const Point& rPnt, short nTol, bool bPrev);
// Mark all objects within a rectangular area // Just objects are marked which are inclosed completely void MarkObj(const tools::Rectangle& rRect, bool bUnmark); void MarkObj(SdrObject* pObj, SdrPageView* pPV, bool bUnmark = false, bool bDoNoSetMarkHdl = false,
std::vector<basegfx::B2DRectangle> && rSubSelections = std::vector<basegfx::B2DRectangle>()); void MarkAllObj(SdrPageView* pPV=nullptr); // pPage=NULL => all displayed pages void UnmarkAllObj(SdrPageView const * pPV=nullptr); // pPage=NULL => all displayed pages
// This function is time-consuming intensive, as the MarkList has to be scanned. bool IsObjMarked(SdrObject const * pObj) const; void UnMarkAll(SdrPageView const * pPV=nullptr) { UnmarkAllObj(pPV); }
// Request/set the size of the marking handles. Declaration in Pixel. // The value is meant to be the edge length ( link length ). // Pair values are round up to impair values: 3->3, 4->5, 5->5, 6->7, 7->7, ... // Default value is 7, minimum value is 3 Pixels.
sal_uInt16 GetMarkHdlSizePixel() const; void SetMarkHdlSizePixel(sal_uInt16 nSiz);
// There might be points which can't be marked: bool IsPointMarkable(const SdrHdl& rHdl) const; virtualbool MarkPoint(SdrHdl& rHdl, bool bUnmark=false);
/** should only be used from outside svx for special ui elements */ bool MarkPointHelper(SdrHdl* pHdl, SdrMark* pMark, bool bUnmark);
// Selects the first marked point (P1) which is hit by rPnt // and from there it searches the first non-marked point(P2). // In case of success the marking of // P1 is deleted, a mark is set at P2.
SAL_DLLPRIVATE void MarkNextPoint();
// Search for the number of the suitable handle. In case of empty search result, // SAL_MAX_SIZE is returned.
size_t GetHdlNum(SdrHdl const * pHdl) const { return maHdlList.GetHdlNum(pHdl); }
SdrHdl* GetHdl(size_t nHdlNum) const { return maHdlList.GetHdl(nHdlNum); } const SdrHdlList& GetHdlList() const { return maHdlList; }
// Draw a selection frame for marking of points. // This routine will just be started in case that HasMarkablePoints() returns sal_True. bool BegMarkPoints(const Point& rPnt, bool bUnmark = false); void MovMarkPoints(const Point& rPnt); bool EndMarkPoints();
SAL_DLLPRIVATE void BrkMarkPoints(); bool IsMarkPoints() const { return (nullptr != mpMarkPointsOverlay); }
// Select that additional handles are displayed permanently. void SetPlusHandlesAlwaysVisible(bool bOn); bool IsPlusHandlesAlwaysVisible() const { return mbPlusHdlAlways; }
// A gluepoint is clearly identified by the SdrObject // (to which it belongs) as well as by a sal_uInt16 nId (as each SdrObject may consist of // several gluepoints. Here at the View there is an additional // SdrPageView, which should be defined correctly always. // Alternatively a gluepoint may be characterized by a SdrHdl. // In this case the SdrHdl instance consists of all required information. // And in this case, the gluepoint are always is marked by enforcement // (Handlers are just situated at marked gluepoints ) // Attention: With each change of the gluepoint status the handle list is re-calculated. // All previously saved SdrHdl* became invalid by this, the same with the point IDs! bool PickGluePoint(const Point& rPnt, SdrObject*& rpObj, sal_uInt16& rnId, SdrPageView*& rpPV) const; bool MarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, bool bUnmark); void UnmarkGluePoint(const SdrObject* pObj, sal_uInt16 nId) { MarkGluePoint(pObj,nId,true); } bool IsGluePointMarked(const SdrObject* pObj, sal_uInt16 nId) const;
// Get the Hdl (handle) of a marked GluePoint. Non-marked // GluePoints don`t have handles
SdrHdl* GetGluePointHdl(const SdrObject* pObj, sal_uInt16 nId) const;
// Mark all points within this rectangular (View coordinates) bool MarkAllGluePoints() { return MarkGluePoints(nullptr,false); } bool UnmarkAllGluePoints() { return MarkGluePoints(nullptr,true); }
// Selects the first marked point (P1) which is hit by rPnt // and from there it searches the first non-marked point(P2). // In case of success the marking of // P1 is deleted, a mark is set at P2.
SAL_DLLPRIVATE void MarkNextGluePoint();
// Draw a selection frame for gluepoint marking. // This routine will just be started in case that HasMarkablePoints() returns sal_True. // The GlueEditMode sal_True is disregarded. // bool BegMarkGluePoints(const Point& rPnt, OutputDevice* pOut); bool BegMarkGluePoints(const Point& rPnt, bool bUnmark = false);
SAL_DLLPRIVATE void MovMarkGluePoints(const Point& rPnt);
SAL_DLLPRIVATE void EndMarkGluePoints();
SAL_DLLPRIVATE void BrkMarkGluePoints(); bool IsMarkGluePoints() const { return (nullptr != mpMarkGluePointsOverlay); }
// bRestraintPaint=sal_False causes the handles not to be drawn immediately. // AdjustMarkHdl is just called in case of changes; usually this causes an Invalidate // At the end of a redraw the handles are drawn automatically. // The purpose is to avoid unnecessary flickering. -> This does not yet work, that's why sal_True! void AdjustMarkHdl(SfxViewShell* pOtherShell = nullptr); //HMHBOOL bRestraintPaint=sal_True);
const tools::Rectangle& GetMarkedObjRect() const; // SnapRects of Objects, without line width
tools::Rectangle GetMarkedObjBoundRect() const; // incl. line width, overlapping rags, ...
SAL_DLLPRIVATE const tools::Rectangle& GetMarkedPointsRect() const; // Enclosing rectangle of all marked points
SAL_DLLPRIVATE const tools::Rectangle& GetMarkedGluePointsRect() const; // Enclosing rectangle of all marked gluepoints const tools::Rectangle& GetAllMarkedRect() const { return GetMarkedObjRect(); }
tools::Rectangle GetAllMarkedBoundRect() const { return GetMarkedObjBoundRect(); }
// Will be always called, if the list of marked objects might be changed. // If you override this method, be sure that you call the // methods of the base class!
SAL_DLLPRIVATE virtualvoid MarkListHasChanged();
// Entering (Editing) of a maybe marked object group. If there are several // object groups marked, the most upper group is selected. After that // all member objects of the group are directly accessible. All other // objects may not be processed in the meantime (until the next // LeaveGroup()). With markings which overlaps pages, every page is processed // separately. The method returns sal_True, if at least one group was entered. void EnterMarkedGroup();
// Rotation center point and start point of the axis of reflection, respectively const Point& GetRef1() const { return maRef1; }
SAL_DLLPRIVATE void SetRef1(const Point& rPt);
// End point of the axis of reflection const Point& GetRef2() const { return maRef2; }
SAL_DLLPRIVATE void SetRef2(const Point& rPt); /// Get access to the view shell owning this draw view, if any.
SAL_RET_MAYBENULL virtual SfxViewShell* GetSfxViewShell() const;
};
// - Hit tolerances: // It has to be declared in logical coordinates. So please translate the // wanted pixel value with PixelToLogic in Logical values. // Taking as example a logical value of 100: // - For a horizontal hairline (Object with height 0), the generated data is +/-100, i.e. // a vertical area of 200 logical units is sensitive. // - For a polygon, a rectangular of the size (200,200) is generated and a // touch test between Poly and this Rect is processed. // - Objects which respond SdrObject::HasEdit()==TRUE ( e.g. a text frame ), // are specially treated: An additional sensitive area with a width of // 2*Tol (200 units for this example) is created around the object. // When an object is directly hit, the Edit method is called. // In opposite, a hit in the surrounding sensitive area enables Dragging.
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
