From 98b4c3303e95fa076acc2ebaf195346f7545d107 Mon Sep 17 00:00:00 2001 From: Rolf Hemmerling Date: Sat, 15 Jun 2013 19:25:20 +0100 Subject: Translate German comments Change-Id: I1e852ec6961f11b9b5047442d974063496750440 --- include/svx/svdmrkv.hxx | 314 ++++++++++++++++++++++++------------------------ 1 file changed, 155 insertions(+), 159 deletions(-) diff --git a/include/svx/svdmrkv.hxx b/include/svx/svdmrkv.hxx index 133a438bd58f..1591b2a2e44e 100644 --- a/include/svx/svdmrkv.hxx +++ b/include/svx/svdmrkv.hxx @@ -30,60 +30,59 @@ // Defines //************************************************************ -// folgendes ist noch nicht bzw. erst zum Teil implementiert: -#define SDRSEARCH_DEEP 0x0001 /* rekursiv in Gruppenobjekte hinein */ -#define SDRSEARCH_ALSOONMASTER 0x0002 /* MasterPages werden auch durchsucht */ -#define SDRSEARCH_WHOLEPAGE 0x0004 /* Nicht nur die ObjList der PageView */ -#define SDRSEARCH_TESTMARKABLE 0x0008 /* nur markierbare Objekte/Punkte/Handles/... */ -#define SDRSEARCH_TESTMACRO 0x0010 /* Nur Objekte mit Macro */ -#define SDRSEARCH_TESTTEXTEDIT 0x0020 /* Nur TextEdit-faehige Objekte */ -#define SDRSEARCH_WITHTEXT 0x0040 /* Nur Objekte mit Text */ -#define SDRSEARCH_TESTTEXTAREA 0x0080 /* Den Textbereich von Objekten mit Text (TextEditHit) */ -#define SDRSEARCH_BACKWARD 0x0100 /* Rueckwaertssuche */ -#define SDRSEARCH_NEXT 0x0200 /* Suche startet hinter dem uebergebenen Objekt/Punkt/... */ -#define SDRSEARCH_MARKED 0x0400 /* Nur markierte Objekte/Punkte/... */ -#define SDRSEARCH_PASS2BOUND 0x0800 /* Wenn nix gefunden, dann neuer 2. Versuch mit BoundRectHit */ -#define SDRSEARCH_PASS3NEAREST 0x1000 /* Wenn nix gefunden, dann neuer 3. Versuch mit NearestBoundRectHit */ +// The following is not yet implemented, or just particially: +#define SDRSEARCH_DEEP 0x0001 /* recursive into group objects */ +#define SDRSEARCH_ALSOONMASTER 0x0002 /* MasterPages are also scanned */ +#define SDRSEARCH_WHOLEPAGE 0x0004 /* Not just the ObjList of PageView */ +#define SDRSEARCH_TESTMARKABLE 0x0008 /* just markable Objekte/Punkte/Handles/... */ +#define SDRSEARCH_TESTMACRO 0x0010 /* Just objects with macro */ +#define SDRSEARCH_TESTTEXTEDIT 0x0020 /* Just TextEdit-enabed objects */ +#define SDRSEARCH_WITHTEXT 0x0040 /* Just objects with text */ +#define SDRSEARCH_TESTTEXTAREA 0x0080 /* The textarea of objects with text (TextEditHit) */ +#define SDRSEARCH_BACKWARD 0x0100 /* Backwards search */ +#define SDRSEARCH_NEXT 0x0200 /* Search starts behind the transfered object/point/... */ +#define SDRSEARCH_MARKED 0x0400 /* Just marked objects/points/... */ +#define SDRSEARCH_PASS2BOUND 0x0800 /* In case of empty search results, then 2nd. try with BoundRectHit */ +#define SDRSEARCH_PASS3NEAREST 0x1000 /* In case of empty search results, then new 3rd. Try with NearestBoundRectHit */ #define SDRSEARCH_BEFOREMARK 0x2000 /* if one marked one found, ignore all behind that */ #define SDRSEARCH_PICKMARKABLE (SDRSEARCH_TESTMARKABLE) #define SDRSEARCH_PICKTEXTEDIT (SDRSEARCH_DEEP|SDRSEARCH_TESTMARKABLE|SDRSEARCH_TESTTEXTEDIT) #define SDRSEARCH_PICKMACRO (SDRSEARCH_DEEP|SDRSEARCH_ALSOONMASTER|SDRSEARCH_WHOLEPAGE|SDRSEARCH_TESTMACRO) -// SDRSEARCHPASS_... ist Rueckgabeparameterwert bei PickObj(). -#define SDRSEARCHPASS_DIRECT 0x0000 /* Objekt durch direkten Hit getroffen */ -#define SDRSEARCHPASS_INACTIVELIST 0x0001 /* Obj auf der Page, nicht jedoch in der AktGroup (bei WHOLEPAGE) */ -#define SDRSEARCHPASS_MASTERPAGE 0x0002 /* Objekt auf der MasterPage gefunden */ -#define SDRSEARCHPASS_BOUND 0x0010 /* Objekt erst beim Bound-Check gefunden */ -#define SDRSEARCHPASS_NEAREST 0x0020 /* Objekt erst beim Nearest-Check gefunden */ - -enum SdrHitKind {SDRHIT_NONE, // Nicht getroffen, Schnaps gesoffen - SDRHIT_OBJECT, // Treffer versenkt - SDRHIT_BOUNDRECT, // Treffer am BoundRect - SDRHIT_BOUNDTL, // Treffer am BoundRect TopLeft - SDRHIT_BOUNDTC, // Treffer am BoundRect TopCenter - SDRHIT_BOUNDTR, // Treffer am BoundRect TopRight - SDRHIT_BOUNDCL, // Treffer am BoundRect CenterLeft - SDRHIT_BOUNDCR, // Treffer am BoundRect CenterRight - SDRHIT_BOUNDBL, // Treffer am BoundRect BottomLeft - SDRHIT_BOUNDBC, // Treffer am BoundRect BottomCenter - SDRHIT_BOUNDBR,/*,*/ // Treffer am BoundRect BottomRight - /*SDRHIT_REFPOINT*/ // Referenzpunkt (Rotationsachse,Spiegelachse) getroffen - // ab hier neu am 01-07-1996: - SDRHIT_HANDLE, // Markierungshandle - SDRHIT_HELPLINE, // Hilfslinie - SDRHIT_GLUEPOINT, // Klebepunkt - SDRHIT_TEXTEDIT, // Offene OutlinerView getroffen - SDRHIT_TEXTEDITOBJ, // Objekt fuer SdrBeginTextEdit (Textbereich) - SDRHIT_URLFIELD, // Feld im TextObj getroffen (wird gerade nicht editiert) - SDRHIT_MACRO, // Objekt fuer BegMacroObj - SDRHIT_MARKEDOBJECT, // Markiertes Objekt (z.B. zum Draggen) - SDRHIT_UNMARKEDOBJECT, // nichtmarkiertes Objekt (z.B. zum markieren) +// SDRSEARCHPASS_... is return parameter value at PickObj(). +#define SDRSEARCHPASS_DIRECT 0x0000 /* Object is hit by 'direct hit' */ +#define SDRSEARCHPASS_INACTIVELIST 0x0001 /* Obj is on the page, but not in the AktGroup (at WHOLEPAGE) */ +#define SDRSEARCHPASS_MASTERPAGE 0x0002 /* Object was found on the MasterPage */ +#define SDRSEARCHPASS_BOUND 0x0010 /* Object found, butjust after Bound-Check gefunden */ +#define SDRSEARCHPASS_NEAREST 0x0020 /* Object found, but just after Nearest-Check */ + +enum SdrHitKind {SDRHIT_NONE, // No hit + SDRHIT_OBJECT, // Hit + SDRHIT_BOUNDRECT, // Hit at BoundRect + SDRHIT_BOUNDTL, // Hit at BoundRect TopLeft + SDRHIT_BOUNDTC, // Hit at BoundRect TopCenter + SDRHIT_BOUNDTR, // Hit at BoundRect TopRight + SDRHIT_BOUNDCL, // Hit at BoundRect CenterLeft + SDRHIT_BOUNDCR, // Hit at BoundRect CenterRight + SDRHIT_BOUNDBL, // Hit at BoundRect BottomLeft + SDRHIT_BOUNDBC, // Hit at BoundRect BottomCenter + SDRHIT_BOUNDBR,/*,*/ // Hit at BoundRect BottomRight + /*SDRHIT_REFPOINT*/ // Reference point (Rotation axis, axis of reflextion) hit + SDRHIT_HANDLE, // Marking handle + SDRHIT_HELPLINE, // Reference line + SDRHIT_GLUEPOINT, // Glue point + SDRHIT_TEXTEDIT, // Open OutlinerView was hit + SDRHIT_TEXTEDITOBJ, // Object for SdrBeginTextEdit (Textbereich) + SDRHIT_URLFIELD, // Field im TextObj was hit (while it is currently not edited) + SDRHIT_MACRO, // Object for BegMacroObj + SDRHIT_MARKEDOBJECT, // Marked object (e.g. for dragging) + SDRHIT_UNMARKEDOBJECT, // non-marked Object (e.g. for marking) SDRHIT_CELL}; // hit on a cell inside a table shape (outside of the cells text area) -enum SdrViewEditMode {SDREDITMODE_EDIT, // Auch bekannt aus Pfeil- oder Zeigermodus - SDREDITMODE_CREATE, // Objekterzeugungswerkzeug - SDREDITMODE_GLUEPOINTEDIT}; // Klebepunkteditiermodus +enum SdrViewEditMode {SDREDITMODE_EDIT, // Also known as arrow or pointer mode + SDREDITMODE_CREATE, // Tool for object creation + SDREDITMODE_GLUEPOINTEDIT}; // Glue point editing mode #define IMPSDR_MARKOBJDESCRIPTION 0x0000 #define IMPSDR_POINTSDESCRIPTION 0x0001 @@ -114,10 +113,10 @@ class SVX_DLLPUBLIC SdrMarkView : public SdrSnapView ImplMarkingOverlay* mpMarkGluePointsOverlay; protected: - SdrObject* pMarkedObj; // Wenn nur ein Objekt markiert ist. - SdrPageView* pMarkedPV; // Wenn alle markierten Objekt auf derselben PageView liegen. + SdrObject* pMarkedObj; // If not just one object ( i.e. More than one object ) is marked. + SdrPageView* pMarkedPV; // If all marked obects are situated on the same PageView. - Point aRef1; // Persistent - Drehmittelpunkt/Spiegelachse + Point aRef1; // Persistent - Rotation center / axis of reflection Point aRef2; // Persistent Point aLastCrookCenter; // Persistent SdrHdlList aHdl; @@ -129,7 +128,7 @@ protected: Rectangle aMarkedGluePointsRect; sal_uInt16 nFrameHandlesLimit; - sal_uIntPtr mnInsPointNum; // Nummer des InsPoint + sal_uIntPtr mnInsPointNum; // Number of the InsPoint sal_uIntPtr nMarkableObjCount; SdrDragMode eDragMode; // Persistent @@ -137,12 +136,12 @@ protected: SdrViewEditMode eEditMode0; // Persistent //HMHunsigned bHdlShown : 1; - unsigned bRefHdlShownOnly : 1; // Spiegelachse waerend Dragging (ni) - unsigned bDesignMode : 1; // DesignMode fuer SdrUnoObj + unsigned bRefHdlShownOnly : 1; // Axis of reflextion during dragging (ni) + unsigned bDesignMode : 1; // DesignMode for SdrUnoObj unsigned bForceFrameHandles : 1; // Persistent - FrameDrag auch bei Einzelobjekten unsigned bPlusHdlAlways : 1; // Persistent unsigned bMarkHdlWhenTextEdit : 1; // Persistent, default=FALSE - unsigned bInsPolyPoint : 1; // z.Zt InsPolyPointDragging + unsigned bInsPolyPoint : 1; // at this time InsPolyPointDragging unsigned bMarkedObjRectDirty : 1; unsigned bMrkPntDirty : 1; unsigned bMarkedPointsRectsDirty : 1; @@ -158,10 +157,10 @@ private: protected: virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint); - virtual void ModelHasChanged(); // Wird von der PaintView gerufen - virtual void SetMarkHandles(); // aHdl (Liste der Handles) fuellen - virtual void SetMarkRects(); // Rects an den PageViews - virtual void CheckMarked(); // MarkList nach Del und Lock Layer durchsuchen... + virtual void ModelHasChanged(); // Is called by the PaintView + virtual void SetMarkHandles(); // aHdl - fill (List of handles) + virtual void SetMarkRects(); // Rects at the PageViews + virtual void CheckMarked(); // Scan MarkList after Del and Lock Layer ... virtual void AddDragModeHdl(SdrDragMode eMode); virtual sal_Bool MouseMove(const MouseEvent& rMEvt, Window* pWin); @@ -178,7 +177,7 @@ protected: sal_Bool ImpIsFrameHandles() const; void ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, String& rStr, sal_uInt16 nVal=0, sal_uInt16 nOpt=0) const; - // Macht aus einer Winkelangabe in 1/100deg einen String inkl. Grad-Zeichen + // Generates a string including degrees symbol, from an angel specification in 1/100deg sal_Bool ImpMarkPoint(SdrHdl* pHdl, SdrMark* pMark, sal_Bool bUnmark); virtual sal_Bool MarkPoints(const Rectangle* pRect, sal_Bool bUnmark); sal_Bool MarkGluePoints(const Rectangle* pRect, sal_Bool bUnmark); @@ -202,11 +201,11 @@ public: virtual void HideSdrPage(); virtual sal_Bool IsObjMarkable(SdrObject* pObj, SdrPageView* pPV) const; - // Liefert sal_True wenn Objekte, Punkte oder Klebepunkte durch Rahmenaufziehen - // selektiert werden (solange wie der Rahmen aufgezogen wird). + // Returns sal_True if objects, points or glue points are selected by drawing a frame + // (as long as the frame is drawn). sal_Bool IsMarking() const { return IsMarkObj() || IsMarkPoints() || IsMarkGluePoints(); } - // Objekte durch Aufziehen eines Selektionsrahmens markieren + // Marking objects by drawing of a selection frame sal_Bool BegMarkObj(const Point& rPnt, sal_Bool bUnmark = sal_False); void MovMarkObj(const Point& rPnt); sal_Bool EndMarkObj(); @@ -215,14 +214,14 @@ public: // DragModes: SDRDRAG_CREATE,SDRDRAG_MOVE,SDRDRAG_RESIZE,SDRDRAG_ROTATE,SDRDRAG_MIRROR,SDRDRAG_SHEAR,SDRDRAG_CROOK // Move==Resize - // Das Interface wird hier evtl noch geaendert wg. Ortho-Drag + // The interface might maybe be changed in the future because of Ortho-Drag void SetDragMode(SdrDragMode eMode); SdrDragMode GetDragMode() const { return eDragMode; } sal_Bool ChkDragMode(SdrDragMode eMode) const; void SetFrameHandles(sal_Bool bOn); sal_Bool IsFrameHandles() const { return bForceFrameHandles; } - // Limit, ab wann implizit auf FrameHandles umgeschaltet wird. default=50. + // Limit. Exceeding the limit causes an implicite switch to FrameHandles. default=50. void SetFrameHandlesLimit(sal_uInt16 nAnz) { nFrameHandlesLimit=nAnz; } sal_uInt16 GetFrameHandlesLimit() const { return nFrameHandlesLimit; } @@ -266,8 +265,8 @@ public: sal_Bool GetBoundRectFromMarkedObjects(SdrPageView* pPageView, Rectangle& rRect) const { return GetMarkedObjectList().TakeBoundRect(pPageView, rRect); } sal_Bool GetSnapRectFromMarkedObjects(SdrPageView* pPageView, Rectangle& rRect) const { return GetMarkedObjectList().TakeSnapRect(pPageView, rRect); } - // Eine Liste aller an markierten Knoten gebundenen Kanten holen, - // die selbst jedoch nicht markiert sind. + // Get a list of all those links which are connected to marked nodes, + // but which are not marked themselves. const SdrMarkList& GetEdgesOfMarkedNodes() const { return mpSdrViewSelection->GetEdgesOfMarkedNodes(); } const SdrMarkList& GetMarkedEdgesOfMarkedNodes() const { return mpSdrViewSelection->GetMarkedEdgesOfMarkedNodes(); } const std::vector& GetTransitiveHullOfMarkedObjects() const { return mpSdrViewSelection->GetAllMarkedObjects(); } @@ -284,10 +283,10 @@ public: sal_Bool IsMarkedHit(const Point& rPnt, short nTol=-2) const { return IsMarkedObjHit(rPnt,nTol); } sal_Bool IsMarkedObjHit(const Point& rPnt, short nTol=-2) const; - // Pick: Unterstuetzte Optionen fuer nOptions sind SEARCH_NEXT, SEARCH_BACKWARD (ni) + // Pick: Supported options for nOptions are SEARCH_NEXT, SEARCH_BACKWARD (ni) SdrHdl* PickHandle(const Point& rPnt, sal_uIntPtr nOptions=0, SdrHdl* pHdl0=NULL) const; - // Pick: Unterstuetzte Optionen fuer nOptions sind: + // Pick: Supported options for nOptions are: // SDRSEARCH_DEEP SDRSEARCH_ALSOONMASTER SDRSEARCH_TESTMARKABLE SDRSEARCH_TESTTEXTEDIT // SDRSEARCH_WITHTEXT SDRSEARCH_TESTTEXTAREA SDRSEARCH_BACKWARD SDRSEARCH_MARKED // SDRSEARCH_WHOLEPAGE @@ -296,39 +295,39 @@ public: // sal_Bool PickObj(const Point& rPnt, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr nOptions=0) const { return PickObj(rPnt,nHitTolLog,rpObj,rpPV,nOptions); } sal_Bool MarkObj(const Point& rPnt, short nTol=-2, sal_Bool bToggle=sal_False, sal_Bool bDeep=sal_False); - // Pick: Unterstuetzte Optionen fuer nOptions sind SDRSEARCH_PASS2BOUND und SDRSEARCH_PASS3NEAREST + // Pick: Supported options for nOptions are SDRSEARCH_PASS2BOUND und SDRSEARCH_PASS3NEAREST sal_Bool PickMarkedObj(const Point& rPnt, SdrObject*& rpObj, SdrPageView*& rpPV, sal_uIntPtr* pnMarkNum=NULL, sal_uIntPtr nOptions=0) const; - // Sucht sich das Oberste der markierten Objekte (O1) und sucht von dort - // aus in Richtung nach Unten dann das erste nichtmarkierte Objekt (O2). - // Bei Erfolg wird die Markierung von O1 entfernt, an O2 gesetzt und TRUE - // returniert. Mit dem Parameter bPrev=sal_True geht die Suche genau in die - // andere Richtung. + // 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. sal_Bool MarkNextObj(sal_Bool bPrev=sal_False); - // Sucht sich das Oberste der markierten Objekte (O1) das von rPnt/nTol - // getroffen wird und sucht von dort aus in Richtung nach Unten dann das - // erste nichtmarkierte Objekt (O2). Bei Erfolg wird die Markierung von - // O1 entfernt, an O2 gesetzt und sal_True returniert. - // Mit dem Parameter bPrev=sal_True geht die Suche genau in die andere Richtung. + // 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. sal_Bool MarkNextObj(const Point& rPnt, short nTol=-2, sal_Bool bPrev=sal_False); - // Alle Objekte innerhalb eines rechteckigen Bereichs markieren - // Markiert werden nur Objekte, die vollstaendig eingeschlossen sind. + // Mark all objects within a rectangular area + // Just objects are marked which are inclosed completely sal_Bool MarkObj(const Rectangle& rRect, sal_Bool bUnmark=sal_False); void MarkObj(SdrObject* pObj, SdrPageView* pPV, sal_Bool bUnmark=sal_False, sal_Bool bImpNoSetMarkHdl=sal_False); - void MarkAllObj(SdrPageView* pPV=NULL); // pPage=NULL => alle angezeigten Seiten - void UnmarkAllObj(SdrPageView* pPV=NULL); // pPage=NULL => alle angezeigten Seiten + void MarkAllObj(SdrPageView* pPV=NULL); // pPage=NULL => all displayed pages + void UnmarkAllObj(SdrPageView* pPV=NULL); // pPage=NULL => all displayed pages - // Diese Funktion kostet etwas Zeit, da die MarkList durchsucht werden muss. + // This function is time-consuming intensive, as the MarkList has to be scanned. sal_Bool IsObjMarked(SdrObject* pObj) const; // void MarkAll(SdrPageView* pPV=NULL) { MarkAllObj(pPV); } -> replace with inline void UnMarkAll(SdrPageView* pPV=NULL) { UnmarkAllObj(pPV); } - // Groesse der Markierungs-Handles abfragen/setzen. Angabe in Pixel. - // Der Wert ist als Kantenlaenge zu betrachten. Gerade Werte werden - // auf Ungerade aufgerundet: 3->3, 4->5, 5->5, 6->7, 7->7, ... - // Defaultwert ist 7, Mindestwert 3 Pixel. + // 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); @@ -337,14 +336,14 @@ public: virtual sal_Bool HasMarkedPoints() const; virtual sal_uIntPtr GetMarkedPointCount() const; - // Nicht alle Punkte lassen sich markieren: + // There might be points which can't be marked: virtual sal_Bool IsPointMarkable(const SdrHdl& rHdl) const; virtual sal_Bool MarkPoint(SdrHdl& rHdl, sal_Bool bUnmark=sal_False); /** should only be used from outside svx for special ui elements */ sal_Bool MarkPointHelper(SdrHdl* pHdl, SdrMark* pMark, sal_Bool bUnmark); - // alle Punkte innerhalb dieses Rechtecks markieren (Viewkoordinaten) + // Mark all points within this rectangular alle Punkte (View coordinates) sal_Bool MarkPoints(const Rectangle& rRect, sal_Bool bUnmark=sal_False) { return MarkPoints(&rRect,bUnmark); } sal_Bool UnmarkPoint(SdrHdl& rHdl) { return MarkPoint(rHdl,sal_True); } sal_Bool UnMarkPoint(SdrHdl& rHdl) { return MarkPoint(rHdl,sal_True); } @@ -353,33 +352,32 @@ public: sal_Bool UnmarkAllPoints() { return MarkPoints(NULL,sal_True); } sal_Bool UnMarkAllPoints() { return MarkPoints(NULL,sal_True); } - // Sucht sich den ersten markierten Punkt (P1) das von rPnt - // getroffen wird und sucht von dort aus den - // ersten nichtmarkierten Punkt (P2). Bei Erfolg wird die Markierung von - // P1 entfernt, an P2 gesetzt und sal_True returniert. - // Mit dem Parameter bPrev=sal_True geht die Suche genau in die andere Richtung. + // 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 and sal_True is returned. + // With the parameter bPrev=sal_True the scan direction is turned to the other direction. sal_Bool MarkNextPoint(const Point& rPnt, sal_Bool bPrev=sal_False); - // Die Nummer des passenden Handles raussuchen. Nicht gefunden - // liefert CONTAINER_ENTRY_NOTFOUND. + // Search for the number of the suitable handle. In case of empty search result, + // CONTAINER_ENTRY_NOTFOUND is returned. sal_uIntPtr GetHdlNum(SdrHdl* pHdl) const { return aHdl.GetHdlNum(pHdl); } SdrHdl* GetHdl(sal_uIntPtr nHdlNum) const { return aHdl.GetHdl(nHdlNum); } const SdrHdlList& GetHdlList() const { return aHdl; } - // Selektionsrahmen fuer Punktmarkierung aufziehen. - // Wird nur gestartet, wenn HasMarkablePoints() sal_True liefert. - // sal_Bool BegMarkPoints(const Point& rPnt, OutputDevice* pOut); + // Draw a selection frame for marking of points. + // This routine will just be started in case that HasMarkablePoints() returns sal_True. sal_Bool BegMarkPoints(const Point& rPnt, sal_Bool bUnmark = sal_False); void MovMarkPoints(const Point& rPnt); sal_Bool EndMarkPoints(); void BrkMarkPoints(); sal_Bool IsMarkPoints() const { return (0L != mpMarkPointsOverlay); } - // Zusatzhandles dauerhaft sichtbar schalten + // Select that additional handles are displayed permanently. void SetPlusHandlesAlwaysVisible(sal_Bool bOn); sal_Bool IsPlusHandlesAlwaysVisible() const { return bPlusHdlAlways; } - // Handles sichrbar waerend TextEdit (in doppelter Groesse)? + // Are Handles visible during TextEdit (in double size)? // Persistent, default=FALSE void SetMarkHdlWhenTextEdit(sal_Bool bOn) { bMarkHdlWhenTextEdit=bOn; } sal_Bool IsMarkHdlWhenTextEdit() const { return bMarkHdlWhenTextEdit; } @@ -387,44 +385,43 @@ public: sal_Bool HasMarkableGluePoints() const; sal_Bool HasMarkedGluePoints() const; - // Ein Klebepunkt wird eindeutig identifiziert durch das SdrObject - // (dem er zugehoert) sowie einem sal_uInt16 nId (da jedes SdrObject je - // mehrere Klebepunkte haben kann. Hier an der View kommt zudem noch - // eine SdrPageView, die stets korrekt gesetzt sein sollte. - // Alternativ kann ein Klebepunkt durch ein SdrHdl bezeichnet werden. - // Die SdrHdl-Instanz beinhaltet dann aller erforderlichen Informationen. - // Der Klebepunkt ist in diesem Fall dann zwangslaeufig markiert (nur auf - // markierten Klebepunkten sitzen Anfasser). - // Achtung: Bei jeder Aenderung des Klebepunktmarkierungsstatus wird die - // Handleliste erneut berechnet. Alle vorher gemerkten SdrHdl* sind - // damit ungueltig, ebenso die Punkt-Id's! - // Pick: Unterstuetzte Optionen fuer nOptions sind SEARCH_NEXT, SEARCH_BACKWARD + // 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 glue points. 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 informations. + // And in this case, the glue point are always is marked by enforcment + // (Handlers are just situated at marked gluepoints ) + // Attention: With each change of the glue point status the handle list is re-calculated. + // All previously saved SdrHdl* became invalid by this, the same with the point IDs! + // Pick: Supported options for nOptions are SEARCH_NEXT, SEARCH_BACKWARD sal_Bool PickGluePoint(const Point& rPnt, SdrObject*& rpObj, sal_uInt16& rnId, SdrPageView*& rpPV, sal_uIntPtr nOptions=0) const; sal_Bool MarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, const SdrPageView* pPV, sal_Bool bUnmark=sal_False); sal_Bool UnmarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, const SdrPageView* pPV) { return MarkGluePoint(pObj,nId,pPV,sal_True); } sal_Bool IsGluePointMarked(const SdrObject* pObj, sal_uInt16 nId) const; - // Hdl eines markierten GluePoints holen. Nicht markierte - // GluePoints haben keine Handles + // Get the Hdl (handle) of a marked GluePoint. Non-marked + // GluePoints don`t have handles SdrHdl* GetGluePointHdl(const SdrObject* pObj, sal_uInt16 nId) const; sal_Bool IsGluePoint(const SdrHdl& rHdl) const { return &rHdl!=NULL && rHdl.GetKind()==HDL_GLUE; } - // alle Punkte innerhalb dieses Rechtecks markieren (Viewkoordinaten) + // Mark all points within this rectangular (View coordinates) sal_Bool MarkGluePoints(const Rectangle& rRect) { return MarkGluePoints(&rRect,sal_False); } sal_Bool UnmarkGluePoints(const Rectangle& rRect) { return MarkGluePoints(&rRect,sal_True); } sal_Bool MarkAllGluePoints() { return MarkGluePoints(NULL,sal_False); } sal_Bool UnmarkAllGluePoints() { return MarkGluePoints(NULL,sal_True); } - // Sucht sich den ersten markierten Klebepunkt (P1) das von rPnt - // getroffen wird und sucht von dort aus den - // ersten nichtmarkierten Klebepunkt (P2). Bei Erfolg wird die Markierung - // von P1 entfernt, an P2 gesetzt und sal_True returniert. - // Mit dem Parameter bPrev=sal_True geht die Suche genau in die andere Richtung. + // 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 and sal_True is returned. + // With the parameter bPrev=sal_True the scan direction is turned to the other direction. sal_Bool MarkNextGluePoint(const Point& rPnt, sal_Bool bPrev=sal_False); - // Selektionsrahmen fuer Klebepunktmarkierung aufziehen. - // Wird nur gestartet, wenn HasMarkableGluePoints() sal_True liefert. - // Der GlueEditMode sal_True wird nicht abgefragt. + // Draw a selection frame for glue point marking. + // This routine will just be started in case that HasMarkablePoints() returns sal_True. + // The GlueEditMode sal_True is disregarded. // sal_Bool BegMarkGluePoints(const Point& rPnt, OutputDevice* pOut); sal_Bool BegMarkGluePoints(const Point& rPnt, sal_Bool bUnmark = sal_False); void MovMarkGluePoints(const Point& rPnt); @@ -432,66 +429,65 @@ public: void BrkMarkGluePoints(); sal_Bool IsMarkGluePoints() const { return (0L != mpMarkGluePointsOverlay); } - // bRestraintPaint=sal_False bewirkt, dass die Handles nicht sofort wieder gemalt werden. - // AdjustMarkHdl wird eh' nur gerufen, wenn was geaendert wurde; was idR ein Invalidate - // zur Folge hat. Am Ende von des Redraw werden die Handles automatisch gezeichnet. - // Der Zweck ist, unnoetiges Flackern zu vermeiden. -> Funkt noch nich, deshalb sal_True! + // 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(); //HMHBOOL bRestraintPaint=sal_True); - const Rectangle& GetMarkedObjRect() const; // SnapRects der Objekte, ohne Strichstaerke - Rectangle GetMarkedObjBoundRect() const; // inkl. Strichstaerke, ueberstehende Fetzen, ... - const Rectangle& GetMarkedPointsRect() const; // Umschliessendes Rechteck aller markierten Punkte - const Rectangle& GetMarkedGluePointsRect() const; // Umschliessendes Rechteck aller markierten Klebepunkte + const Rectangle& GetMarkedObjRect() const; // SnapRects of Objects, without line width + Rectangle GetMarkedObjBoundRect() const; // incl. line width, overlapping rags, ... + const Rectangle& GetMarkedPointsRect() const; // Enclosing rectangle of all marked points + const Rectangle& GetMarkedGluePointsRect() const; // Enclosing rectangle of all marked glue points const Rectangle& GetAllMarkedRect() const { return GetMarkedObjRect(); } Rectangle GetAllMarkedBoundRect() const { return GetMarkedObjBoundRect(); } const Rectangle& GetAllMarkedPointsRect() const { return GetMarkedPointsRect(); } Point GetGridOffset() const; - // Wird immer dann gerufen, wenn sich die Liste der markierten Objekte - // moeglicherweise geaendert hat. Wer ueberlaed muss unbedingt auch die - // Methode der Basisklasse rufen! + // Will be always called, if the list of marked objects might be changed. + // If you overload this method (as programmer), be shure that you call the + // methods of the base class! virtual void MarkListHasChanged(); - // Betreten (Editieren) einer evtl markierten Objektgruppe. Sind mehrere - // Objektgruppen markiert, so wird die Oberste genommen. Anschliessend - // liegen alle Memberobjekte der Gruppe im direkten Zugriff. Alle anderen - // Objekte koennen waerendessen nicht bearbeitet werden (bis zum naechsten - // LeaveGroup()). Bei einer seitenuebergreifenden Markierung wird jede Page - // separat abgearbeitet. Die Methode liefert sal_True, wenn wenigstens eine - // Gruppe betreten wurde. + // 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 accessable. 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. sal_Bool EnterMarkedGroup(); - // Den Mittelpunkt des letzten Crook-Dragging abholen. Den kann man + // Get the center point of the last Crook-Dragging. Den kann man // bei einem anschliessenden Rotate sinnvoll als Drehmittelpunkt setzen. const Point& GetLastCrookCenter() const { return aLastCrookCenter; } - // Wird automatisch von der DragView beim beenden eines Crook-Drag gesetzt. + // Is set by DragView automatically when finishing a Crook-Drag. void SetLastCrookCenter(const Point& rPt) { aLastCrookCenter=rPt; } - // Rotationsmittelpunkt bzw. Startpunkt der Spiegelachse + // Rotation center point and start point of the axis of reflextion, respecively const Point& GetRef1() const { return aRef1; } void SetRef1(const Point& rPt); - // Endpunkt der Spiegelachse + // End point of the axis of reflextion const Point& GetRef2() const { return aRef1; } void SetRef2(const Point& rPt); }; //////////////////////////////////////////////////////////////////////////////////////////////////// // -// - Hit-Toleranzen: -// Die muessen natuerlich immer in logischen Koordinaten angegeben werden. Also -// immer brav den gewuenschten Pixelwert mit PixelToLogic in Logischen umrechnen. -// Angenommen ein Wert 100 (logisch) -// - Bei einer waagerechten Haarlinie (Objekt mit Hoehe 0) waere dann +/-100, -// also ein vertikaler Bereich von 200 logischen Einheiten sensitiv. -// - Bei Polygonen wird ein Rect mit der Groesse (200,200) generiert und ein -// Touch-Test zwischen Poly und diesem Rect durchgefuehrt. -// - Eine Sonderbehandlung erfahren Objekte, die bei SdrObject::HasEdit()==TRUE -// liefern (z.B. Textrahmen). Hierbei wird ein weiterer sensitiver Bereich mit -// einer Breite von 2*Tol (in diesem Beispiel also 200 Einheiten) um das Objekt -// herumgelegt. Waerend ein Hit direkt ins Objekt die Edit-Methode ruft, -// ermoeglicht ein Hit in den umliegenden sensitiven Bereich ein Dragging. +// - Hit tolarances: +// It have 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. +// - Obects 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. // //////////////////////////////////////////////////////////////////////////////////////////////////// -- cgit v1.2.3