[PATCH] Translate German comments

Hi,

I have submitted a patch for review:

    https://gerrit.libreoffice.org/4295

To pull it, you can do:

    git pull ssh://gerrit.libreoffice.org:29418/core refs/changes/95/4295/1

Translate German comments

Change-Id: I1e852ec6961f11b9b5047442d974063496750440
---
M include/svx/svdmrkv.hxx
1 file changed, 155 insertions(+), 157 deletions(-)



diff --git a/include/svx/svdmrkv.hxx b/include/svx/svdmrkv.hxx
index 133a438..555a7c4 100644
--- a/include/svx/svdmrkv.hxx
+++ b/include/svx/svdmrkv.hxx
@@ -30,60 +30,60 @@
 //   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 */
+// 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,      // 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)
+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
+1. // from here on new at 1996-07-01:
+                 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 +114,10 @@
     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 +129,7 @@
     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 +137,12 @@
     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 +158,10 @@
 
 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 +178,7 @@
     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 +202,11 @@
     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 +215,14 @@
 
     // 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 +266,8 @@
     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<SdrObject*>& GetTransitiveHullOfMarkedObjects() const { return 
mpSdrViewSelection->GetAllMarkedObjects(); }
@@ -284,10 +284,10 @@
     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 +296,39 @@
     // 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 +337,14 @@
     virtual sal_Bool HasMarkedPoints() const;
     virtual sal_uIntPtr GetMarkedPointCount() const;
 
-    // Nicht alle Punkte lassen sich markieren:
+    // There might be points whic 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,21 +353,21 @@
     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.
+    // 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, OutputDevice* pOut);
     sal_Bool BegMarkPoints(const Point& rPnt, sal_Bool bUnmark = sal_False);
     void MovMarkPoints(const Point& rPnt);
@@ -375,11 +375,11 @@
     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 +387,43 @@
     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 +431,65 @@
     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.
 //
 
////////////////////////////////////////////////////////////////////////////////////////////////////
 

-- 
To view, visit https://gerrit.libreoffice.org/4295
To unsubscribe, visit https://gerrit.libreoffice.org/settings

Gerrit-MessageType: newchange
Gerrit-Change-Id: I1e852ec6961f11b9b5047442d974063496750440
Gerrit-PatchSet: 1
Gerrit-Project: core
Gerrit-Branch: master
Gerrit-Owner: Michael Meeks <michael.meeks@suse.com>