LCOV - code coverage report
Current view: top level - libreoffice/solver/unxlngi6.pro/inc/svx - svdmrkv.hxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 4 38 10.5 %
Date: 2012-12-27 Functions: 4 38 10.5 %
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 _SVDMRKV_HXX
      21             : #define _SVDMRKV_HXX
      22             : 
      23             : #include <svx/svdmark.hxx>
      24             : #include <svx/svdhdl.hxx>
      25             : #include <svx/svdsnpv.hxx>
      26             : #include <svx/svdtypes.hxx>
      27             : #include "svx/svxdllapi.h"
      28             : 
      29             : //************************************************************
      30             : //   Defines
      31             : //************************************************************
      32             : 
      33             : // folgendes ist noch nicht bzw. erst zum Teil implementiert:
      34             : #define SDRSEARCH_DEEP         0x0001 /* rekursiv in Gruppenobjekte hinein */
      35             : #define SDRSEARCH_ALSOONMASTER 0x0002 /* MasterPages werden auch durchsucht */
      36             : #define SDRSEARCH_WHOLEPAGE    0x0004 /* Nicht nur die ObjList der PageView */
      37             : #define SDRSEARCH_TESTMARKABLE 0x0008 /* nur markierbare Objekte/Punkte/Handles/... */
      38             : #define SDRSEARCH_TESTMACRO    0x0010 /* Nur Objekte mit Macro */
      39             : #define SDRSEARCH_TESTTEXTEDIT 0x0020 /* Nur TextEdit-faehige Objekte */
      40             : #define SDRSEARCH_WITHTEXT     0x0040 /* Nur Objekte mit Text */
      41             : #define SDRSEARCH_TESTTEXTAREA 0x0080 /* Den Textbereich von Objekten mit Text (TextEditHit) */
      42             : #define SDRSEARCH_BACKWARD     0x0100 /* Rueckwaertssuche */
      43             : #define SDRSEARCH_NEXT         0x0200 /* Suche startet hinter dem uebergebenen Objekt/Punkt/... */
      44             : #define SDRSEARCH_MARKED       0x0400 /* Nur markierte Objekte/Punkte/... */
      45             : #define SDRSEARCH_PASS2BOUND   0x0800 /* Wenn nix gefunden, dann neuer 2. Versuch mit BoundRectHit */
      46             : #define SDRSEARCH_PASS3NEAREST 0x1000 /* Wenn nix gefunden, dann neuer 3. Versuch mit NearestBoundRectHit */
      47             : #define SDRSEARCH_BEFOREMARK   0x2000 /* if one marked one found, ignore all behind that */
      48             : 
      49             : #define SDRSEARCH_PICKMARKABLE (SDRSEARCH_TESTMARKABLE)
      50             : #define SDRSEARCH_PICKTEXTEDIT (SDRSEARCH_DEEP|SDRSEARCH_TESTMARKABLE|SDRSEARCH_TESTTEXTEDIT)
      51             : #define SDRSEARCH_PICKMACRO    (SDRSEARCH_DEEP|SDRSEARCH_ALSOONMASTER|SDRSEARCH_WHOLEPAGE|SDRSEARCH_TESTMACRO)
      52             : 
      53             : // SDRSEARCHPASS_... ist Rueckgabeparameterwert bei PickObj().
      54             : #define SDRSEARCHPASS_DIRECT       0x0000 /* Objekt durch direkten Hit getroffen     */
      55             : #define SDRSEARCHPASS_INACTIVELIST 0x0001 /* Obj auf der Page, nicht jedoch in der AktGroup (bei WHOLEPAGE) */
      56             : #define SDRSEARCHPASS_MASTERPAGE   0x0002 /* Objekt auf der MasterPage gefunden      */
      57             : #define SDRSEARCHPASS_BOUND        0x0010 /* Objekt erst beim Bound-Check gefunden   */
      58             : #define SDRSEARCHPASS_NEAREST      0x0020 /* Objekt erst beim Nearest-Check gefunden */
      59             : 
      60             : enum SdrHitKind {SDRHIT_NONE,      // Nicht getroffen, Schnaps gesoffen
      61             :                  SDRHIT_OBJECT,    // Treffer versenkt
      62             :                  SDRHIT_BOUNDRECT, // Treffer am BoundRect
      63             :                  SDRHIT_BOUNDTL,   // Treffer am BoundRect TopLeft
      64             :                  SDRHIT_BOUNDTC,   // Treffer am BoundRect TopCenter
      65             :                  SDRHIT_BOUNDTR,   // Treffer am BoundRect TopRight
      66             :                  SDRHIT_BOUNDCL,   // Treffer am BoundRect CenterLeft
      67             :                  SDRHIT_BOUNDCR,   // Treffer am BoundRect CenterRight
      68             :                  SDRHIT_BOUNDBL,   // Treffer am BoundRect BottomLeft
      69             :                  SDRHIT_BOUNDBC,   // Treffer am BoundRect BottomCenter
      70             :                  SDRHIT_BOUNDBR,/*,*/ // Treffer am BoundRect BottomRight
      71             :                  /*SDRHIT_REFPOINT*/ // Referenzpunkt (Rotationsachse,Spiegelachse) getroffen
      72             :                  // ab hier neu am 01-07-1996:
      73             :                  SDRHIT_HANDLE,          // Markierungshandle
      74             :                  SDRHIT_HELPLINE,        // Hilfslinie
      75             :                  SDRHIT_GLUEPOINT,       // Klebepunkt
      76             :                  SDRHIT_TEXTEDIT,        // Offene OutlinerView getroffen
      77             :                  SDRHIT_TEXTEDITOBJ,     // Objekt fuer SdrBeginTextEdit (Textbereich)
      78             :                  SDRHIT_URLFIELD,        // Feld im TextObj getroffen (wird gerade nicht editiert)
      79             :                  SDRHIT_MACRO,           // Objekt fuer BegMacroObj
      80             :                  SDRHIT_MARKEDOBJECT,    // Markiertes Objekt (z.B. zum Draggen)
      81             :                  SDRHIT_UNMARKEDOBJECT, // nichtmarkiertes Objekt (z.B. zum markieren)
      82             :                  SDRHIT_CELL};          // hit on a cell inside a table shape (outside of the cells text area)
      83             : 
      84             : enum SdrViewEditMode {SDREDITMODE_EDIT,           // Auch bekannt aus Pfeil- oder Zeigermodus
      85             :                       SDREDITMODE_CREATE,         // Objekterzeugungswerkzeug
      86             :                       SDREDITMODE_GLUEPOINTEDIT}; // Klebepunkteditiermodus
      87             : 
      88             : #define IMPSDR_MARKOBJDESCRIPTION    0x0000
      89             : #define IMPSDR_POINTSDESCRIPTION     0x0001
      90             : #define IMPSDR_GLUEPOINTSDESCRIPTION 0x0002
      91             : 
      92             : ////////////////////////////////////////////////////////////////////////////////////////////////////
      93             : ////////////////////////////////////////////////////////////////////////////////////////////////////
      94             : //
      95             : //  @@   @@  @@@@  @@@@@  @@  @@  @@ @@ @@ @@@@@ @@   @@
      96             : //  @@@ @@@ @@  @@ @@  @@ @@  @@  @@ @@ @@ @@    @@   @@
      97             : //  @@@@@@@ @@  @@ @@  @@ @@ @@   @@ @@ @@ @@    @@ @ @@
      98             : //  @@@@@@@ @@@@@@ @@@@@  @@@@    @@@@@ @@ @@@@  @@@@@@@
      99             : //  @@ @ @@ @@  @@ @@  @@ @@ @@    @@@  @@ @@    @@@@@@@
     100             : //  @@   @@ @@  @@ @@  @@ @@  @@   @@@  @@ @@    @@@ @@@
     101             : //  @@   @@ @@  @@ @@  @@ @@  @@    @   @@ @@@@@ @@   @@
     102             : //
     103             : ////////////////////////////////////////////////////////////////////////////////////////////////////
     104             : ////////////////////////////////////////////////////////////////////////////////////////////////////
     105             : class ImplMarkingOverlay;
     106             : 
     107             : class SVX_DLLPUBLIC SdrMarkView : public SdrSnapView
     108             : {
     109             :     friend class                SdrPageView;
     110             : 
     111             :     // #114409#-3 Migrate selections
     112             :     ImplMarkingOverlay*                                 mpMarkObjOverlay;
     113             :     ImplMarkingOverlay*                                 mpMarkPointsOverlay;
     114             :     ImplMarkingOverlay*                                 mpMarkGluePointsOverlay;
     115             : 
     116             : protected:
     117             :     SdrObject*                  pMarkedObj;       // Wenn nur ein Objekt markiert ist.
     118             :     SdrPageView*                pMarkedPV;        // Wenn alle markierten Objekt auf derselben PageView liegen.
     119             : 
     120             :     Point                       aRef1;            // Persistent - Drehmittelpunkt/Spiegelachse
     121             :     Point                       aRef2;            // Persistent
     122             :     Point                       aLastCrookCenter; // Persistent
     123             :     SdrHdlList                  aHdl;
     124             :     sdr::ViewSelection*         mpSdrViewSelection;
     125             : 
     126             :     Rectangle                   aMarkedObjRect;
     127             :     Rectangle                   aMarkedObjRectNoOffset;
     128             :     Rectangle                   aMarkedPointsRect;
     129             :     Rectangle                   aMarkedGluePointsRect;
     130             : 
     131             :     sal_uInt16                      nFrameHandlesLimit;
     132             :     sal_uIntPtr                 mnInsPointNum;      // Nummer des InsPoint
     133             :     sal_uIntPtr                     nMarkableObjCount;
     134             : 
     135             :     SdrDragMode                 eDragMode;        // Persistent
     136             :     SdrViewEditMode             eEditMode;      // Persistent
     137             :     SdrViewEditMode             eEditMode0;     // Persistent
     138             : 
     139             :     //HMHunsigned                   bHdlShown : 1;
     140             :     unsigned                    bRefHdlShownOnly : 1; // Spiegelachse waerend Dragging (ni)
     141             :     unsigned                    bDesignMode : 1;      // DesignMode fuer SdrUnoObj
     142             :     unsigned                    bForceFrameHandles : 1; // Persistent - FrameDrag auch bei Einzelobjekten
     143             :     unsigned                    bPlusHdlAlways : 1;   // Persistent
     144             :     unsigned                    bMarkHdlWhenTextEdit : 1; // Persistent, default=FALSE
     145             :     unsigned                    bInsPolyPoint : 1;     // z.Zt InsPolyPointDragging
     146             :     unsigned                    bMarkedObjRectDirty : 1;
     147             :     unsigned                    bMrkPntDirty : 1;
     148             :     unsigned                    bMarkedPointsRectsDirty : 1;
     149             :     unsigned                    bMarkableObjCountDirty : 1;
     150             : 
     151             :     // flag to completely disable handles at the view
     152             :     unsigned                    mbMarkHandlesHidden : 1;
     153             : 
     154             : private:
     155             :     SVX_DLLPRIVATE void ImpClearVars();
     156             :     SVX_DLLPRIVATE void ImpSetPointsRects() const;
     157             :     void UndirtyMrkPnt() const;
     158             : 
     159             : protected:
     160             :     virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint);
     161             :     virtual void ModelHasChanged(); // Wird von der PaintView gerufen
     162             :     virtual void SetMarkHandles();                                           // aHdl (Liste der Handles) fuellen
     163             :     virtual void SetMarkRects();                                             // Rects an den PageViews
     164             :     virtual void CheckMarked();                                              // MarkList nach Del und Lock Layer durchsuchen...
     165             :     virtual void AddDragModeHdl(SdrDragMode eMode);
     166             :     virtual sal_Bool MouseMove(const MouseEvent& rMEvt, Window* pWin);
     167             : 
     168             :     // add custom handles (used by other apps, e.g. AnchorPos)
     169             :     virtual void AddCustomHdl();
     170             : 
     171             :     void ForceRefToMarked();
     172           0 :     void ForceUndirtyMrkPnt() const                                       { if (bMrkPntDirty) UndirtyMrkPnt(); }
     173             : 
     174             :     //HMHvoid ImpShowMarkHdl(bool bNoRefHdl);
     175             :     virtual SdrObject* CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObject* pObj, SdrPageView* pPV, sal_uIntPtr nOptions, const SetOfByte* pMVisLay) const;
     176             :     virtual SdrObject* CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObjList* pOL, SdrPageView* pPV, sal_uIntPtr nOptions, const SetOfByte* pMVisLay, SdrObject*& rpRootObj) const;
     177             :     virtual SdrObject* CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObjList* pOL, SdrPageView* pPV, sal_uIntPtr nOptions, const SetOfByte* pMVisLay, SdrObject*& rpRootObj,const SdrMarkList * pMarkList) const;
     178             :     sal_Bool ImpIsFrameHandles() const;
     179             :     void ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, String& rStr, sal_uInt16 nVal=0, sal_uInt16 nOpt=0) const;
     180             : 
     181             :     // Macht aus einer Winkelangabe in 1/100deg einen String inkl. Grad-Zeichen
     182             :     sal_Bool ImpMarkPoint(SdrHdl* pHdl, SdrMark* pMark, sal_Bool bUnmark);
     183             :     virtual sal_Bool MarkPoints(const Rectangle* pRect, sal_Bool bUnmark);
     184             :     sal_Bool MarkGluePoints(const Rectangle* pRect, sal_Bool bUnmark);
     185             : 
     186             :     void SetMoveOutside(sal_Bool bOn);
     187             : 
     188             : protected:
     189             :     // #i71538# make constructors of SdrView sub-components protected to avoid incomplete incarnations which may get casted to SdrView
     190             :     SdrMarkView(SdrModel* pModel1, OutputDevice* pOut = 0L);
     191             :     virtual ~SdrMarkView();
     192             : 
     193             : public:
     194             :     virtual sal_Bool IsAction() const;
     195             :     virtual void MovAction(const Point& rPnt);
     196             :     virtual void EndAction();
     197             :     virtual void BckAction();
     198             :     virtual void BrkAction();
     199             :     virtual void TakeActionRect(Rectangle& rRect) const;
     200             : 
     201             :     virtual void ClearPageView();
     202             :     virtual void HideSdrPage();
     203             :     virtual sal_Bool IsObjMarkable(SdrObject* pObj, SdrPageView* pPV) const;
     204             : 
     205             :     // Liefert sal_True wenn Objekte, Punkte oder Klebepunkte durch Rahmenaufziehen
     206             :     // selektiert werden (solange wie der Rahmen aufgezogen wird).
     207             :     sal_Bool IsMarking() const { return IsMarkObj() || IsMarkPoints() || IsMarkGluePoints(); }
     208             : 
     209             :     // Objekte durch Aufziehen eines Selektionsrahmens markieren
     210             :     sal_Bool BegMarkObj(const Point& rPnt, sal_Bool bUnmark = sal_False);
     211             :     void MovMarkObj(const Point& rPnt);
     212             :     sal_Bool EndMarkObj();
     213             :     void BrkMarkObj();
     214           0 :     sal_Bool IsMarkObj() const { return (0L != mpMarkObjOverlay); }
     215             : 
     216             :     // DragModes: SDRDRAG_CREATE,SDRDRAG_MOVE,SDRDRAG_RESIZE,SDRDRAG_ROTATE,SDRDRAG_MIRROR,SDRDRAG_SHEAR,SDRDRAG_CROOK
     217             :     // Move==Resize
     218             :     // Das Interface wird hier evtl noch geaendert wg. Ortho-Drag
     219             :     void SetDragMode(SdrDragMode eMode);
     220           0 :     SdrDragMode GetDragMode() const { return eDragMode; }
     221             :     sal_Bool ChkDragMode(SdrDragMode eMode) const;
     222             :     void SetFrameHandles(sal_Bool bOn);
     223           0 :     sal_Bool IsFrameHandles() const { return bForceFrameHandles; }
     224             : 
     225             :     // Limit, ab wann implizit auf FrameHandles umgeschaltet wird. default=50.
     226             :     void SetFrameHandlesLimit(sal_uInt16 nAnz) { nFrameHandlesLimit=nAnz; }
     227             :     sal_uInt16 GetFrameHandlesLimit() const { return nFrameHandlesLimit; }
     228             : 
     229             :     void SetEditMode(SdrViewEditMode eMode);
     230           0 :     SdrViewEditMode GetEditMode() const { return eEditMode; }
     231             : 
     232           0 :     void SetEditMode(sal_Bool bOn=sal_True) { SetEditMode(bOn?SDREDITMODE_EDIT:SDREDITMODE_CREATE); }
     233           0 :     sal_Bool IsEditMode() const { return eEditMode==SDREDITMODE_EDIT; }
     234           0 :     void SetCreateMode(sal_Bool bOn=sal_True) { SetEditMode(bOn?SDREDITMODE_CREATE:SDREDITMODE_EDIT); }
     235           0 :     sal_Bool IsCreateMode() const { return eEditMode==SDREDITMODE_CREATE; }
     236           0 :     void SetGluePointEditMode(sal_Bool bOn=sal_True) { SetEditMode(bOn?SDREDITMODE_GLUEPOINTEDIT:eEditMode0); }
     237             :     sal_Bool IsGluePointEditMode() const { return eEditMode==SDREDITMODE_GLUEPOINTEDIT; }
     238             : 
     239             :     void SetDesignMode(sal_Bool bOn=sal_True);
     240           0 :     sal_Bool IsDesignMode() const { return bDesignMode; }
     241             : 
     242         247 :     void SetFrameDragSingles(sal_Bool bOn=sal_True) { SetFrameHandles(bOn); }
     243           0 :     sal_Bool IsFrameDragSingles() const { return IsFrameHandles(); }
     244             : 
     245             : ////////////////////////////////////////////////////////////////////////////////////////////////////
     246             : // migrate selections
     247             : 
     248             : protected:
     249             :     // all available changing methods
     250             :     SdrMarkList& GetMarkedObjectListWriteAccess() { return mpSdrViewSelection->GetMarkedObjectListWriteAccess(); }
     251             :     void SetEdgesOfMarkedNodesDirty() { mpSdrViewSelection->SetEdgesOfMarkedNodesDirty(); }
     252             : 
     253             : public:
     254             :     // all available const methods for read access to selection
     255        8375 :     const SdrMarkList& GetMarkedObjectList() const { return mpSdrViewSelection->GetMarkedObjectList(); }
     256             :     sal_uIntPtr TryToFindMarkedObject(const SdrObject* pObj) const { return GetMarkedObjectList().FindObject(pObj); }
     257             :     SdrPageView* GetSdrPageViewOfMarkedByIndex(sal_uIntPtr nNum) const { return GetMarkedObjectList().GetMark(nNum)->GetPageView(); }
     258           0 :     SdrMark* GetSdrMarkByIndex(sal_uIntPtr nNum) const { return GetMarkedObjectList().GetMark(nNum); }
     259           0 :     SdrObject* GetMarkedObjectByIndex(sal_uIntPtr nNum) const { return (GetMarkedObjectList().GetMark(nNum))->GetMarkedSdrObj(); }
     260           0 :     sal_uIntPtr GetMarkedObjectCount() const { return GetMarkedObjectList().GetMarkCount(); }
     261           0 :     void SortMarkedObjects() const { GetMarkedObjectList().ForceSort(); }
     262         472 :     sal_Bool AreObjectsMarked() const { return (0L != GetMarkedObjectList().GetMarkCount()); }
     263           0 :     String GetDescriptionOfMarkedObjects() const { return GetMarkedObjectList().GetMarkDescription(); }
     264             :     String GetDescriptionOfMarkedPoints() const { return GetMarkedObjectList().GetPointMarkDescription(); }
     265             :     String GetDescriptionOfMarkedGluePoints() const { return GetMarkedObjectList().GetGluePointMarkDescription(); }
     266             :     sal_Bool GetBoundRectFromMarkedObjects(SdrPageView* pPageView, Rectangle& rRect) const { return GetMarkedObjectList().TakeBoundRect(pPageView, rRect); }
     267             :     sal_Bool GetSnapRectFromMarkedObjects(SdrPageView* pPageView, Rectangle& rRect) const { return GetMarkedObjectList().TakeSnapRect(pPageView, rRect); }
     268             : 
     269             :     // Eine Liste aller an markierten Knoten gebundenen Kanten holen,
     270             :     // die selbst jedoch nicht markiert sind.
     271             :     const SdrMarkList& GetEdgesOfMarkedNodes() const { return mpSdrViewSelection->GetEdgesOfMarkedNodes(); }
     272             :     const SdrMarkList& GetMarkedEdgesOfMarkedNodes() const { return mpSdrViewSelection->GetMarkedEdgesOfMarkedNodes(); }
     273             :     const std::vector<SdrObject*>& GetTransitiveHullOfMarkedObjects() const { return mpSdrViewSelection->GetAllMarkedObjects(); }
     274             : 
     275             : ////////////////////////////////////////////////////////////////////////////////////////////////////
     276             : 
     277             :     // mechanism to complete disable handles at the view. Handles will be hidden and deleted
     278             :     // when set, no new ones created, no interaction allowed. Handles will be recreated and shown
     279             :     // when reset. Default is false.
     280             :     void hideMarkHandles();
     281             :     void showMarkHandles();
     282        1977 :     bool areMarkHandlesHidden() const { return mbMarkHandlesHidden; }
     283             : 
     284           0 :     sal_Bool IsMarkedHit(const Point& rPnt, short nTol=-2) const { return IsMarkedObjHit(rPnt,nTol); }
     285             :     sal_Bool IsMarkedObjHit(const Point& rPnt, short nTol=-2) const;
     286             : 
     287             :     // Pick: Unterstuetzte Optionen fuer nOptions sind SEARCH_NEXT, SEARCH_BACKWARD (ni)
     288             :     SdrHdl* PickHandle(const Point& rPnt, sal_uIntPtr nOptions=0, SdrHdl* pHdl0=NULL) const;
     289             : 
     290             :     // Pick: Unterstuetzte Optionen fuer nOptions sind:
     291             :     // SDRSEARCH_DEEP SDRSEARCH_ALSOONMASTER SDRSEARCH_TESTMARKABLE SDRSEARCH_TESTTEXTEDIT
     292             :     // SDRSEARCH_WITHTEXT SDRSEARCH_TESTTEXTAREA SDRSEARCH_BACKWARD SDRSEARCH_MARKED
     293             :     // SDRSEARCH_WHOLEPAGE
     294             :     virtual sal_Bool PickObj(const Point& rPnt, short nTol, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr nOptions, SdrObject** ppRootObj, sal_uIntPtr* pnMarkNum=NULL, sal_uInt16* pnPassNum=NULL) const;
     295             :     virtual sal_Bool PickObj(const Point& rPnt, short nTol, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr nOptions=0) const;
     296             :     // sal_Bool PickObj(const Point& rPnt, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr nOptions=0) const { return PickObj(rPnt,nHitTolLog,rpObj,rpPV,nOptions); }
     297             :     sal_Bool MarkObj(const Point& rPnt, short nTol=-2, sal_Bool bToggle=sal_False, sal_Bool bDeep=sal_False);
     298             : 
     299             :     // Pick: Unterstuetzte Optionen fuer nOptions sind SDRSEARCH_PASS2BOUND und SDRSEARCH_PASS3NEAREST
     300             :     sal_Bool PickMarkedObj(const Point& rPnt, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr* pnMarkNum=NULL, sal_uIntPtr nOptions=0) const;
     301             : 
     302             :     // Sucht sich das Oberste der markierten Objekte (O1) und sucht von dort
     303             :     // aus in Richtung nach Unten dann das erste nichtmarkierte Objekt (O2).
     304             :     // Bei Erfolg wird die Markierung von O1 entfernt, an O2 gesetzt und TRUE
     305             :     // returniert. Mit dem Parameter bPrev=sal_True geht die Suche genau in die
     306             :     // andere Richtung.
     307             :     sal_Bool MarkNextObj(sal_Bool bPrev=sal_False);
     308             : 
     309             :     // Sucht sich das Oberste der markierten Objekte (O1) das von rPnt/nTol
     310             :     // getroffen wird und sucht von dort aus in Richtung nach Unten dann das
     311             :     // erste nichtmarkierte Objekt (O2). Bei Erfolg wird die Markierung von
     312             :     // O1 entfernt, an O2 gesetzt und sal_True returniert.
     313             :     // Mit dem Parameter bPrev=sal_True geht die Suche genau in die andere Richtung.
     314             :     sal_Bool MarkNextObj(const Point& rPnt, short nTol=-2, sal_Bool bPrev=sal_False);
     315             : 
     316             :     // Alle Objekte innerhalb eines rechteckigen Bereichs markieren
     317             :     // Markiert werden nur Objekte, die vollstaendig eingeschlossen sind.
     318             :     sal_Bool MarkObj(const Rectangle& rRect, sal_Bool bUnmark=sal_False);
     319             :     void MarkObj(SdrObject* pObj, SdrPageView* pPV, sal_Bool bUnmark=sal_False, sal_Bool bImpNoSetMarkHdl=sal_False);
     320             :     void MarkAllObj(SdrPageView* pPV=NULL); // pPage=NULL => alle angezeigten Seiten
     321             :     void UnmarkAllObj(SdrPageView* pPV=NULL); // pPage=NULL => alle angezeigten Seiten
     322             : 
     323             :     // Diese Funktion kostet etwas Zeit, da die MarkList durchsucht werden muss.
     324             :     sal_Bool IsObjMarked(SdrObject* pObj) const;
     325             :     // void MarkAll(SdrPageView* pPV=NULL) { MarkAllObj(pPV); } -> replace with inline
     326           0 :     void UnMarkAll(SdrPageView* pPV=NULL) { UnmarkAllObj(pPV); }
     327             : 
     328             :     // Groesse der Markierungs-Handles abfragen/setzen. Angabe in Pixel.
     329             :     // Der Wert ist als Kantenlaenge zu betrachten. Gerade Werte werden
     330             :     // auf Ungerade aufgerundet: 3->3, 4->5, 5->5, 6->7, 7->7, ...
     331             :     // Defaultwert ist 7, Mindestwert 3 Pixel.
     332             :     sal_uInt16 GetMarkHdlSizePixel() const;
     333             :     void SetMarkHdlSizePixel(sal_uInt16 nSiz);
     334             : 
     335             :     virtual sal_Bool HasMarkablePoints() const;
     336             :     virtual sal_uIntPtr GetMarkablePointCount() const;
     337             :     virtual sal_Bool HasMarkedPoints() const;
     338             :     virtual sal_uIntPtr GetMarkedPointCount() const;
     339             : 
     340             :     // Nicht alle Punkte lassen sich markieren:
     341             :     virtual sal_Bool IsPointMarkable(const SdrHdl& rHdl) const;
     342             :     virtual sal_Bool MarkPoint(SdrHdl& rHdl, sal_Bool bUnmark=sal_False);
     343             : 
     344             :     /** should only be used from outside svx for special ui elements */
     345             :     sal_Bool MarkPointHelper(SdrHdl* pHdl, SdrMark* pMark, sal_Bool bUnmark);
     346             : 
     347             :     // alle Punkte innerhalb dieses Rechtecks markieren (Viewkoordinaten)
     348             :     sal_Bool MarkPoints(const Rectangle& rRect, sal_Bool bUnmark=sal_False) { return MarkPoints(&rRect,bUnmark); }
     349           0 :     sal_Bool UnmarkPoint(SdrHdl& rHdl) { return MarkPoint(rHdl,sal_True); }
     350             :     sal_Bool UnMarkPoint(SdrHdl& rHdl) { return MarkPoint(rHdl,sal_True); }
     351           0 :     sal_Bool IsPointMarked(const SdrHdl& rHdl) const { ForceUndirtyMrkPnt(); return &rHdl!=NULL && rHdl.IsSelected(); }
     352           0 :     sal_Bool MarkAllPoints() { return MarkPoints(NULL,sal_False); }
     353           0 :     sal_Bool UnmarkAllPoints() { return MarkPoints(NULL,sal_True); }
     354             :     sal_Bool UnMarkAllPoints() { return MarkPoints(NULL,sal_True); }
     355             : 
     356             :     // Sucht sich den ersten markierten Punkt (P1) das von rPnt
     357             :     // getroffen wird und sucht von dort aus den
     358             :     // ersten nichtmarkierten Punkt (P2). Bei Erfolg wird die Markierung von
     359             :     // P1 entfernt, an P2 gesetzt und sal_True returniert.
     360             :     // Mit dem Parameter bPrev=sal_True geht die Suche genau in die andere Richtung.
     361             :     sal_Bool MarkNextPoint(const Point& rPnt, sal_Bool bPrev=sal_False);
     362             : 
     363             :     // Die Nummer des passenden Handles raussuchen. Nicht gefunden
     364             :     // liefert CONTAINER_ENTRY_NOTFOUND.
     365           0 :     sal_uIntPtr GetHdlNum(SdrHdl* pHdl) const { return aHdl.GetHdlNum(pHdl); }
     366           0 :     SdrHdl* GetHdl(sal_uIntPtr nHdlNum)  const { return aHdl.GetHdl(nHdlNum); }
     367           0 :     const SdrHdlList& GetHdlList() const { return aHdl; }
     368             : 
     369             :     // Selektionsrahmen fuer Punktmarkierung aufziehen.
     370             :     // Wird nur gestartet, wenn HasMarkablePoints() sal_True liefert.
     371             :     // sal_Bool BegMarkPoints(const Point& rPnt, OutputDevice* pOut);
     372             :     sal_Bool BegMarkPoints(const Point& rPnt, sal_Bool bUnmark = sal_False);
     373             :     void MovMarkPoints(const Point& rPnt);
     374             :     sal_Bool EndMarkPoints();
     375             :     void BrkMarkPoints();
     376           0 :     sal_Bool IsMarkPoints() const { return (0L != mpMarkPointsOverlay); }
     377             : 
     378             :     // Zusatzhandles dauerhaft sichtbar schalten
     379             :     void SetPlusHandlesAlwaysVisible(sal_Bool bOn);
     380           0 :     sal_Bool IsPlusHandlesAlwaysVisible() const { return bPlusHdlAlways; }
     381             : 
     382             :     // Handles sichrbar waerend TextEdit (in doppelter Groesse)?
     383             :     // Persistent, default=FALSE
     384           0 :     void SetMarkHdlWhenTextEdit(sal_Bool bOn) { bMarkHdlWhenTextEdit=bOn; }
     385             :     sal_Bool IsMarkHdlWhenTextEdit() const { return bMarkHdlWhenTextEdit; }
     386             : 
     387             :     sal_Bool HasMarkableGluePoints() const;
     388             :     sal_Bool HasMarkedGluePoints() const;
     389             : 
     390             :     // Ein Klebepunkt wird eindeutig identifiziert durch das SdrObject
     391             :     // (dem er zugehoert) sowie einem sal_uInt16 nId (da jedes SdrObject je
     392             :     // mehrere Klebepunkte haben kann. Hier an der View kommt zudem noch
     393             :     // eine SdrPageView, die stets korrekt gesetzt sein sollte.
     394             :     // Alternativ kann ein Klebepunkt durch ein SdrHdl bezeichnet werden.
     395             :     // Die SdrHdl-Instanz beinhaltet dann aller erforderlichen Informationen.
     396             :     // Der Klebepunkt ist in diesem Fall dann zwangslaeufig markiert (nur auf
     397             :     // markierten Klebepunkten sitzen Anfasser).
     398             :     // Achtung: Bei jeder Aenderung des Klebepunktmarkierungsstatus wird die
     399             :     // Handleliste erneut berechnet. Alle vorher gemerkten SdrHdl* sind
     400             :     // damit ungueltig, ebenso die Punkt-Id's!
     401             :     // Pick: Unterstuetzte Optionen fuer nOptions sind SEARCH_NEXT, SEARCH_BACKWARD
     402             :     sal_Bool PickGluePoint(const Point& rPnt, SdrObject*& rpObj, sal_uInt16& rnId, SdrPageView*& rpPV, sal_uIntPtr nOptions=0) const;
     403             :     sal_Bool MarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, const SdrPageView* pPV, sal_Bool bUnmark=sal_False);
     404           0 :     sal_Bool UnmarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, const SdrPageView* pPV) { return MarkGluePoint(pObj,nId,pPV,sal_True); }
     405             :     sal_Bool IsGluePointMarked(const SdrObject* pObj, sal_uInt16 nId) const;
     406             : 
     407             :     // Hdl eines markierten GluePoints holen. Nicht markierte
     408             :     // GluePoints haben keine Handles
     409             :     SdrHdl* GetGluePointHdl(const SdrObject* pObj, sal_uInt16 nId) const;
     410             :     sal_Bool IsGluePoint(const SdrHdl& rHdl) const { return &rHdl!=NULL && rHdl.GetKind()==HDL_GLUE; }
     411             : 
     412             :     // alle Punkte innerhalb dieses Rechtecks markieren (Viewkoordinaten)
     413             :     sal_Bool MarkGluePoints(const Rectangle& rRect) { return MarkGluePoints(&rRect,sal_False); }
     414             :     sal_Bool UnmarkGluePoints(const Rectangle& rRect) { return MarkGluePoints(&rRect,sal_True); }
     415             :     sal_Bool MarkAllGluePoints() { return MarkGluePoints(NULL,sal_False); }
     416           0 :     sal_Bool UnmarkAllGluePoints() { return MarkGluePoints(NULL,sal_True); }
     417             : 
     418             :     // Sucht sich den ersten markierten Klebepunkt (P1) das von rPnt
     419             :     // getroffen wird und sucht von dort aus den
     420             :     // ersten nichtmarkierten Klebepunkt (P2). Bei Erfolg wird die Markierung
     421             :     // von P1 entfernt, an P2 gesetzt und sal_True returniert.
     422             :     // Mit dem Parameter bPrev=sal_True geht die Suche genau in die andere Richtung.
     423             :     sal_Bool MarkNextGluePoint(const Point& rPnt, sal_Bool bPrev=sal_False);
     424             : 
     425             :     // Selektionsrahmen fuer Klebepunktmarkierung aufziehen.
     426             :     // Wird nur gestartet, wenn HasMarkableGluePoints() sal_True liefert.
     427             :     // Der GlueEditMode sal_True wird nicht abgefragt.
     428             :     // sal_Bool BegMarkGluePoints(const Point& rPnt, OutputDevice* pOut);
     429             :     sal_Bool BegMarkGluePoints(const Point& rPnt, sal_Bool bUnmark = sal_False);
     430             :     void MovMarkGluePoints(const Point& rPnt);
     431             :     sal_Bool EndMarkGluePoints();
     432             :     void BrkMarkGluePoints();
     433             :     sal_Bool IsMarkGluePoints() const { return (0L != mpMarkGluePointsOverlay); }
     434             : 
     435             :     // bRestraintPaint=sal_False bewirkt, dass die Handles nicht sofort wieder gemalt werden.
     436             :     // AdjustMarkHdl wird eh' nur gerufen, wenn was geaendert wurde; was idR ein Invalidate
     437             :     // zur Folge hat. Am Ende von des Redraw werden die Handles automatisch gezeichnet.
     438             :     // Der Zweck ist, unnoetiges Flackern zu vermeiden. -> Funkt noch nich, deshalb sal_True!
     439             :     void AdjustMarkHdl(); //HMHBOOL bRestraintPaint=sal_True);
     440             : 
     441             :     const Rectangle& GetMarkedObjRect() const; // SnapRects der Objekte, ohne Strichstaerke
     442             :     Rectangle GetMarkedObjBoundRect() const;   // inkl. Strichstaerke, ueberstehende Fetzen, ...
     443             :     const Rectangle& GetMarkedPointsRect() const;     // Umschliessendes Rechteck aller markierten Punkte
     444             :     const Rectangle& GetMarkedGluePointsRect() const; // Umschliessendes Rechteck aller markierten Klebepunkte
     445           0 :     const Rectangle& GetAllMarkedRect() const { return GetMarkedObjRect(); }
     446           0 :     Rectangle GetAllMarkedBoundRect() const { return GetMarkedObjBoundRect(); }
     447             :     const Rectangle& GetAllMarkedPointsRect() const  { return GetMarkedPointsRect(); }
     448             :     Point GetGridOffset() const;
     449             : 
     450             :     // Wird immer dann gerufen, wenn sich die Liste der markierten Objekte
     451             :     // moeglicherweise geaendert hat. Wer ueberlaed muss unbedingt auch die
     452             :     // Methode der Basisklasse rufen!
     453             :     virtual void MarkListHasChanged();
     454             : 
     455             :     // Betreten (Editieren) einer evtl markierten Objektgruppe. Sind mehrere
     456             :     // Objektgruppen markiert, so wird die Oberste genommen. Anschliessend
     457             :     // liegen alle Memberobjekte der Gruppe im direkten Zugriff. Alle anderen
     458             :     // Objekte koennen waerendessen nicht bearbeitet werden (bis zum naechsten
     459             :     // LeaveGroup()). Bei einer seitenuebergreifenden Markierung wird jede Page
     460             :     // separat abgearbeitet. Die Methode liefert sal_True, wenn wenigstens eine
     461             :     // Gruppe betreten wurde.
     462             :     sal_Bool EnterMarkedGroup();
     463             : 
     464             :     // Den Mittelpunkt des letzten Crook-Dragging abholen. Den kann man
     465             :     // bei einem anschliessenden Rotate sinnvoll als Drehmittelpunkt setzen.
     466             :     const Point& GetLastCrookCenter() const { return aLastCrookCenter; }
     467             : 
     468             :     // Wird automatisch von der DragView beim beenden eines Crook-Drag gesetzt.
     469             :     void SetLastCrookCenter(const Point& rPt) { aLastCrookCenter=rPt; }
     470             : 
     471             :     // Rotationsmittelpunkt bzw. Startpunkt der Spiegelachse
     472           0 :     const Point& GetRef1() const { return aRef1; }
     473             :     void SetRef1(const Point& rPt);
     474             : 
     475             :     // Endpunkt der Spiegelachse
     476             :     const Point& GetRef2() const { return aRef1; }
     477             :     void SetRef2(const Point& rPt);
     478             : };
     479             : 
     480             : ////////////////////////////////////////////////////////////////////////////////////////////////////
     481             : //
     482             : // - Hit-Toleranzen:
     483             : //   Die muessen natuerlich immer in logischen Koordinaten angegeben werden. Also
     484             : //   immer brav den gewuenschten Pixelwert mit PixelToLogic in Logischen umrechnen.
     485             : //   Angenommen ein Wert 100 (logisch)
     486             : //   - Bei einer waagerechten Haarlinie (Objekt mit Hoehe 0) waere dann +/-100,
     487             : //     also ein vertikaler Bereich von 200 logischen Einheiten sensitiv.
     488             : //   - Bei Polygonen wird ein Rect mit der Groesse (200,200) generiert und ein
     489             : //     Touch-Test zwischen Poly und diesem Rect durchgefuehrt.
     490             : //   - Eine Sonderbehandlung erfahren Objekte, die bei SdrObject::HasEdit()==TRUE
     491             : //     liefern (z.B. Textrahmen). Hierbei wird ein weiterer sensitiver Bereich mit
     492             : //     einer Breite von 2*Tol (in diesem Beispiel also 200 Einheiten) um das Objekt
     493             : //     herumgelegt. Waerend ein Hit direkt ins Objekt die Edit-Methode ruft,
     494             : //     ermoeglicht ein Hit in den umliegenden sensitiven Bereich ein Dragging.
     495             : //
     496             : ////////////////////////////////////////////////////////////////////////////////////////////////////
     497             : 
     498             : #endif //_SVDMRKV_HXX
     499             : 
     500             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10