svx: prefix remaining members of SdrDragView

Change-Id: Iac5d80ef4e433c95277237692bda02fa75a24c61

include/svx/svddrgmt.hxx

@@ -157,16 +157,16 @@ protected:
 
     // old call forwarders to the SdrDragView
     void               ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, OUString& rStr, sal_uInt16 nVal=0) const;
-    SdrHdl*            GetDragHdl() const              { return getSdrDragView().pDragHdl; }
-    SdrHdlKind         GetDragHdlKind() const          { return getSdrDragView().eDragHdl; }
+    SdrHdl*            GetDragHdl() const              { return getSdrDragView().mpDragHdl; }
+    SdrHdlKind         GetDragHdlKind() const          { return getSdrDragView().meDragHdl; }
     SdrDragStat&       DragStat()                      { return getSdrDragView().aDragStat; }
     const SdrDragStat& DragStat() const                { return getSdrDragView().aDragStat; }
     Point&             Ref1() const                    { return mrSdrDragView.aRef1; }
     Point&             Ref2() const                    { return mrSdrDragView.aRef2; }
     const SdrHdlList&  GetHdlList() const              { return getSdrDragView().GetHdlList(); }
     void               AddUndo(SdrUndoAction* pUndo)   { getSdrDragView().AddUndo(pUndo); }
-    bool               IsDragLimit()                   { return getSdrDragView().bDragLimit; }
-    const Rectangle&   GetDragLimitRect()              { return getSdrDragView().aDragLimit; }
+    bool               IsDragLimit()                   { return getSdrDragView().mbDragLimit; }
+    const Rectangle&   GetDragLimitRect()              { return getSdrDragView().maDragLimit; }
     const SdrMarkList& GetMarkedObjectList()                   { return getSdrDragView().GetMarkedObjectList(); }
     Point              GetSnapPos(const Point& rPt) const { return getSdrDragView().GetSnapPos(rPt,getSdrDragView().pMarkedPV); }
     SdrSnap            SnapPos(Point& rPt) const       { return getSdrDragView().SnapPos(rPt,getSdrDragView().pMarkedPV); }
@@ -217,8 +217,8 @@ public:
 
 inline const Rectangle& SdrDragMethod::GetMarkedRect() const
 {
-    return getSdrDragView().eDragHdl==HDL_POLY ? getSdrDragView().GetMarkedPointsRect() :
-           getSdrDragView().eDragHdl==HDL_GLUE ? getSdrDragView().GetMarkedGluePointsRect() :
+    return getSdrDragView().meDragHdl==HDL_POLY ? getSdrDragView().GetMarkedPointsRect() :
+           getSdrDragView().meDragHdl==HDL_GLUE ? getSdrDragView().GetMarkedGluePointsRect() :
            getSdrDragView().GetMarkedObjRect();
 }
 

include/svx/svddrgv.hxx

@@ -31,38 +31,38 @@ class SVX_DLLPUBLIC SdrDragView: public SdrExchangeView
     friend class                SdrDragMethod;
 
 protected:
-    SdrHdl*                     pDragHdl;
+    SdrHdl*                     mpDragHdl;
     SdrDragMethod*              mpCurrentSdrDragMethod;
-    SdrUndoGeoObj*              pInsPointUndo;
-    Rectangle                   aDragLimit;
-    OUString               aInsPointUndoStr;
-    SdrMarkList                 aFollowingEdges; // If nodes are dragged, all edges should follow as Xor
-    SdrHdlKind                  eDragHdl;
-
-    sal_uIntPtr                     nDragXorPolyLimit;
-    sal_uIntPtr                     nDragXorPointLimit;
-    sal_uInt16                      nDetailedEdgeDraggingLimit;
-
-    bool                        bFramDrag : 1;        // currently frame dragging
-    bool                        bDragSpecial : 1;     // currently Special Obj-dragging
-    bool                        bMarkedHitMovesAlways : 1; // Persistent
-    bool                        bDragLimit : 1;      // Limit on SnapRect instead of BoundRect
-    bool                        bDragHdl : 1;        // TRUE: RefPt is slid
-    bool                        bDragStripes : 1;    // Persistent
-    bool                        bMirrRefDragObj : 1; // Persistent - During the drag, show the mirror axis of the mirrored objects as Xor
+    SdrUndoGeoObj*              mpInsPointUndo;
+    Rectangle                   maDragLimit;
+    OUString               maInsPointUndoStr;
+    SdrMarkList                 maFollowingEdges; // If nodes are dragged, all edges should follow as Xor
+    SdrHdlKind                  meDragHdl;
+
+    sal_uIntPtr                     mnDragXorPolyLimit;
+    sal_uIntPtr                     mnDragXorPointLimit;
+    sal_uInt16                      mnDetailedEdgeDraggingLimit;
+
+    bool                        mbFramDrag : 1;        // currently frame dragging
+    bool                        mbDragSpecial : 1;     // currently Special Obj-dragging
+    bool                        mbMarkedHitMovesAlways : 1; // Persistent
+    bool                        mbDragLimit : 1;      // Limit on SnapRect instead of BoundRect
+    bool                        mbDragHdl : 1;        // TRUE: RefPt is slid
+    bool                        mbDragStripes : 1;    // Persistent
+    bool                        mbMirrRefDragObj : 1; // Persistent - During the drag, show the mirror axis of the mirrored objects as Xor
     bool                        mbSolidDragging : 1;  // allow solid create/drag of objects
-    bool                        bMouseHideWhileDraggingPoints : 1;
-    bool                        bResizeAtCenter : 1;
-    bool                        bCrookAtCenter : 1;
-    bool                        bDragWithCopy : 1;
-    bool                        bInsGluePoint : 1;
-    bool                        bInsObjPointMode : 1;
-    bool                        bInsGluePointMode : 1;
-    bool                        bNoDragXorPolys : 1;
-    bool                        bAutoVertexCon : 1;  // automatic generation of connectors at the vertices
-    bool                        bAutoCornerCon : 1;  // automatic geneartion of connectors at the corners
-    bool                        bRubberEdgeDragging : 1;
-    bool                        bDetailedEdgeDragging : 1;
+    bool                        mbMouseHideWhileDraggingPoints : 1;
+    bool                        mbResizeAtCenter : 1;
+    bool                        mbCrookAtCenter : 1;
+    bool                        mbDragWithCopy : 1;
+    bool                        mbInsGluePoint : 1;
+    bool                        mbInsObjPointMode : 1;
+    bool                        mbInsGluePointMode : 1;
+    bool                        mbNoDragXorPolys : 1;
+    bool                        mbAutoVertexCon : 1;  // automatic generation of connectors at the vertices
+    bool                        mbAutoCornerCon : 1;  // automatic geneartion of connectors at the corners
+    bool                        mbRubberEdgeDragging : 1;
+    bool                        mbDetailedEdgeDragging : 1;
 
 private:
     SVX_DLLPRIVATE void ImpClearVars();
@@ -105,20 +105,20 @@ public:
     void MovDragObj(const Point& rPnt);
     bool EndDragObj(bool bCopy=false);
     void BrkDragObj();
-    bool IsDragObj() const { return mpCurrentSdrDragMethod && !bInsPolyPoint && !bInsGluePoint; }
-    SdrHdl* GetDragHdl() const { return pDragHdl; }
+    bool IsDragObj() const { return mpCurrentSdrDragMethod && !bInsPolyPoint && !mbInsGluePoint; }
+    SdrHdl* GetDragHdl() const { return mpDragHdl; }
     SdrDragMethod* GetDragMethod() const { return mpCurrentSdrDragMethod; }
-    bool IsDraggingPoints() const { return eDragHdl==HDL_POLY; }
-    bool IsDraggingGluePoints() const { return eDragHdl==HDL_GLUE; }
+    bool IsDraggingPoints() const { return meDragHdl==HDL_POLY; }
+    bool IsDraggingGluePoints() const { return meDragHdl==HDL_GLUE; }
 
     // If you want to define that already during BegDrag
     // or in the middle.
     // (Is reset to 'false' on each BegDrag, so set it after BegDrag.)
-    void SetDragWithCopy(bool bOn) { bDragWithCopy = bOn; }
-    bool IsDragWithCopy() const { return bDragWithCopy; }
+    void SetDragWithCopy(bool bOn) { mbDragWithCopy = bOn; }
+    bool IsDragWithCopy() const { return mbDragWithCopy; }
 
-    void SetInsertGluePoint(bool bOn) { bInsGluePoint = bOn; }
-    bool IsInsertGluePoint() const { return bInsGluePoint; }
+    void SetInsertGluePoint(bool bOn) { mbInsGluePoint = bOn; }
+    bool IsInsertGluePoint() const { return mbInsGluePoint; }
 
     // Interactive insertion of a new point. nIdx=0 => in front of the first point
     bool IsInsObjPointPossible() const;
@@ -130,25 +130,25 @@ public:
 
     // For the app to manage the status. GetPreferredPointer() is
     // possibly going to deliver a matching pointer for it.
-    void SetInsObjPointMode(bool bOn) { bInsObjPointMode = bOn; }
-    bool IsInsObjPointMode() const { return bInsObjPointMode; }
+    void SetInsObjPointMode(bool bOn) { mbInsObjPointMode = bOn; }
+    bool IsInsObjPointMode() const { return mbInsObjPointMode; }
 
     bool IsInsGluePointPossible() const;
     bool BegInsGluePoint(const Point& rPnt);
     void MovInsGluePoint(const Point& rPnt) { MovDragObj(rPnt); }
     bool EndInsGluePoint() { return EndDragObj(); }
     void BrkInsGluePoint() { BrkDragObj(); }
-    bool IsInsGluePoint() const { return mpCurrentSdrDragMethod && bInsGluePoint; }
+    bool IsInsGluePoint() const { return mpCurrentSdrDragMethod && mbInsGluePoint; }
 
     // For the app to manage the status. GetPreferredPointer() is
     // possibly going to deliver a matching pointer for it.
-    void SetInsGluePointMode(bool bOn) { bInsGluePointMode = bOn; }
-    bool IsInsGluePointMode() const { return bInsGluePointMode; }
+    void SetInsGluePointMode(bool bOn) { mbInsGluePointMode = bOn; }
+    bool IsInsGluePointMode() const { return mbInsGluePointMode; }
 
     // border lines over the whole win persistent during the
     // whole dragging. Default=FALSE.
     void SetDragStripes(bool bOn);
-    bool IsDragStripes() const { return bDragStripes; }
+    bool IsDragStripes() const { return mbDragStripes; }
 
     // hide handles during dragging
     //HMHvoid SetDragHdlHide(bool bOn);
@@ -156,8 +156,8 @@ public:
 
     // Hide the mouse when dragging polygon points or glue points.
     // Default=false
-    void SetMouseHideWhileDraggingPoints(bool bOn) { bMouseHideWhileDraggingPoints = bOn; }
-    bool IsMouseHideWhileDraggingPoints() const { return bMouseHideWhileDraggingPoints; }
+    void SetMouseHideWhileDraggingPoints(bool bOn) { mbMouseHideWhileDraggingPoints = bOn; }
+    bool IsMouseHideWhileDraggingPoints() const { return mbMouseHideWhileDraggingPoints; }
 
     // As a general rule, the contours of the selected objects
     // are displayed as Xor-polygons. If this flag is set, only one
@@ -167,21 +167,21 @@ public:
     // Also changeable during the dragging.
     // Default=Off
     void SetNoDragXorPolys(bool bOn);
-    bool IsNoDragXorPolys() const { return bNoDragXorPolys; }
+    bool IsNoDragXorPolys() const { return mbNoDragXorPolys; }
 
     // If the number of selected objects exceeds te value set here,
     // NoDragPolys is (temporarily) activated implicitely.
     // PolyPolygons etc. are regarded as multiple objects respectively.
     // Default=100
-    void  SetDragXorPolyLimit(sal_uIntPtr nLimit) { nDragXorPolyLimit=nLimit; }
-    sal_uIntPtr GetDragXorPolyLimit() const { return nDragXorPolyLimit; }
+    void  SetDragXorPolyLimit(sal_uIntPtr nLimit) { mnDragXorPolyLimit=nLimit; }
+    sal_uIntPtr GetDragXorPolyLimit() const { return mnDragXorPolyLimit; }
 
     // Like DragXorPolyLimit, but in respect to the total number of
     // all polygons. Default=500.
     // NoDragPolys is (temporarily) activated, if one of the limits
     // is exceeded.
-    void  SetDragXorPointLimit(sal_uIntPtr nPointCount) { nDragXorPointLimit=nPointCount; }
-    sal_uIntPtr GetDragXorPointLimit() const { return nDragXorPointLimit; }
+    void  SetDragXorPointLimit(sal_uIntPtr nPointCount) { mnDragXorPointLimit=nPointCount; }
+    sal_uIntPtr GetDragXorPointLimit() const { return mnDragXorPointLimit; }
 
     void SetSolidDragging(bool bOn);
     bool IsSolidDragging() const;
@@ -190,13 +190,13 @@ public:
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // Stick Connectors to vertices
     // Default=true=Yes
-    void SetAutoVertexConnectors(bool bOn) { bAutoVertexCon = bOn; }
-    bool IsAutoVertexConnectors() const { return bAutoVertexCon; }
+    void SetAutoVertexConnectors(bool bOn) { mbAutoVertexCon = bOn; }
+    bool IsAutoVertexConnectors() const { return mbAutoVertexCon; }
 
     // Stick Connectors to Corners
     // Default=false=No
-    void SetAutoCornerConnectors(bool bOn) { bAutoCornerCon = bOn; }
-    bool IsAutoCornerConnectors() const { return bAutoCornerCon; }
+    void SetAutoCornerConnectors(bool bOn) { mbAutoCornerCon = bOn; }
+    bool IsAutoCornerConnectors() const { return mbAutoCornerCon; }
 
     // Dragging of connected objects (Nodes):
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -205,16 +205,16 @@ public:
     // only rubber bands but total recalculations are visible while
     // dragging. This detailed depiction is only possible in MoveDrag.
     // Default value: 10
-    bool IsDetailedEdgeDragging() const { return bDetailedEdgeDragging; }
+    bool IsDetailedEdgeDragging() const { return mbDetailedEdgeDragging; }
 
-    sal_uInt16 GetDetailedEdgeDraggingLimit() const { return nDetailedEdgeDraggingLimit; }
+    sal_uInt16 GetDetailedEdgeDraggingLimit() const { return mnDetailedEdgeDraggingLimit; }
 
     // EdgeDraggingLimit: If more than nEdgeObjCount edges are affected,
     // they are not shown in the interactive dragging.
     // This here talks about the "rubber bands", which take less computing time
     // than the complete recalculations in the DetailedEdgeDragging.
     // default value: 100
-    bool IsRubberEdgeDragging() const { return bRubberEdgeDragging; }
+    bool IsRubberEdgeDragging() const { return mbRubberEdgeDragging; }
 
     // Connector handling is thus as follows (when using default settings):
     // - If at most 10 Connectors are affected, they are recalculated
@@ -230,25 +230,25 @@ public:
     // object always triggers a Move, independent of the DragMode that is
     // set. This flag is persistent and should be configurable in the app
     // by the user!
-    void SetMarkedHitMovesAlways(bool bOn) { bMarkedHitMovesAlways = bOn; }
-    bool IsMarkedHitMovesAlways() const { return bMarkedHitMovesAlways; }
+    void SetMarkedHitMovesAlways(bool bOn) { mbMarkedHitMovesAlways = bOn; }
+    bool IsMarkedHitMovesAlways() const { return mbMarkedHitMovesAlways; }
 
     // Show the mirror image of the selected objects as Xor while dragging
     // the mirror axis? Persistent. Not yet implemented. Default: true
-    void SetMirrRefDragObj(bool bOn) { bMirrRefDragObj = bOn; }
-    bool IsMirrRefDragObj() const { return bMirrRefDragObj; }
+    void SetMirrRefDragObj(bool bOn) { mbMirrRefDragObj = bOn; }
+    bool IsMirrRefDragObj() const { return mbMirrRefDragObj; }
 
     bool IsOrthoDesired() const;
 
     // center as reference on Resize
     // Default=FALSE.
-    bool IsResizeAtCenter() const { return bResizeAtCenter; }
-    void SetResizeAtCenter(bool bOn) { bResizeAtCenter = bOn; }
+    bool IsResizeAtCenter() const { return mbResizeAtCenter; }
+    void SetResizeAtCenter(bool bOn) { mbResizeAtCenter = bOn; }
 
     // symmetric Crook
     // Default=FALSE.
-    bool IsCrookAtCenter() const { return bCrookAtCenter; }
-    void SetCrookAtCenter(bool bOn) { bCrookAtCenter = bOn; }
+    bool IsCrookAtCenter() const { return mbCrookAtCenter; }
+    void SetCrookAtCenter(bool bOn) { mbCrookAtCenter = bOn; }
 
     // Limitation of the working area. The limitation refers to the View,
     // not to the single PageViews. This limitation is only evaluated by

svx/source/engine3d/view3d.cxx

@@ -1229,13 +1229,13 @@ bool E3dView::BegDragObj(const Point& rPnt, OutputDevice* pOut,
             }
             if( bThereAre3DObjects )
             {
-                eDragHdl = ( pHdl == NULL ? HDL_MOVE : pHdl->GetKind() );
+                meDragHdl = ( pHdl == NULL ? HDL_MOVE : pHdl->GetKind() );
                 switch ( eDragMode )
                 {
                     case SDRDRAG_ROTATE:
                     case SDRDRAG_SHEAR:
                     {
-                        switch ( eDragHdl )
+                        switch ( meDragHdl )
                         {
                             case HDL_LEFT:
                             case HDL_RIGHT:
@@ -1272,7 +1272,7 @@ bool E3dView::BegDragObj(const Point& rPnt, OutputDevice* pOut,
                     {
                         if(!bThereAreRootScenes)
                         {
-                            pForcedMeth = new E3dDragMove(*this, GetMarkedObjectList(), eDragHdl, eConstraint, IsSolidDragging());
+                            pForcedMeth = new E3dDragMove(*this, GetMarkedObjectList(), meDragHdl, eConstraint, IsSolidDragging());
                         }
                     }
                     break;

svx/source/svdraw/svddrgmt.cxx

@@ -575,7 +575,7 @@ void SdrDragMethod::ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, OUString& rStr
 SdrObject* SdrDragMethod::GetDragObj() const
 {
     SdrObject* pObj=NULL;
-    if (getSdrDragView().pDragHdl!=NULL) pObj=getSdrDragView().pDragHdl->GetObj();
+    if (getSdrDragView().mpDragHdl!=NULL) pObj=getSdrDragView().mpDragHdl->GetObj();
     if (pObj==NULL) pObj=getSdrDragView().pMarkedObj;
     return pObj;
 }
@@ -583,7 +583,7 @@ SdrObject* SdrDragMethod::GetDragObj() const
 SdrPageView* SdrDragMethod::GetDragPV() const
 {
     SdrPageView* pPV=NULL;
-    if (getSdrDragView().pDragHdl!=NULL) pPV=getSdrDragView().pDragHdl->GetPageView();
+    if (getSdrDragView().mpDragHdl!=NULL) pPV=getSdrDragView().mpDragHdl->GetPageView();
     if (pPV==NULL) pPV=getSdrDragView().pMarkedPV;
     return pPV;
 }

svx/source/svdraw/svddrgv.cxx

@@ -51,33 +51,33 @@ using namespace sdr;
 
 void SdrDragView::ImpClearVars()
 {
-    bFramDrag=false;
+    mbFramDrag=false;
     eDragMode=SDRDRAG_MOVE;
-    bDragLimit=false;
-    bMarkedHitMovesAlways=false;
-    eDragHdl=HDL_MOVE;
-    pDragHdl=NULL;
-    bDragHdl=false;
-    bDragSpecial=false;
+    mbDragLimit=false;
+    mbMarkedHitMovesAlways=false;
+    meDragHdl=HDL_MOVE;
+    mpDragHdl=NULL;
+    mbDragHdl=false;
+    mbDragSpecial=false;
     mpCurrentSdrDragMethod=NULL;
-    bDragStripes=false;
-    bMirrRefDragObj=true;
-    bDragWithCopy=false;
-    pInsPointUndo=NULL;
-    bInsGluePoint=false;
-    bInsObjPointMode=false;
-    bInsGluePointMode=false;
-    nDragXorPolyLimit=100;
-    nDragXorPointLimit=500;
-    bNoDragXorPolys=false;
-    bAutoVertexCon=true;
-    bAutoCornerCon=false;
-    bRubberEdgeDragging=true;
-    bDetailedEdgeDragging=true;
-    nDetailedEdgeDraggingLimit=10;
-    bResizeAtCenter=false;
-    bCrookAtCenter=false;
-    bMouseHideWhileDraggingPoints=false;
+    mbDragStripes=false;
+    mbMirrRefDragObj=true;
+    mbDragWithCopy=false;
+    mpInsPointUndo=NULL;
+    mbInsGluePoint=false;
+    mbInsObjPointMode=false;
+    mbInsGluePointMode=false;
+    mnDragXorPolyLimit=100;
+    mnDragXorPointLimit=500;
+    mbNoDragXorPolys=false;
+    mbAutoVertexCon=true;
+    mbAutoCornerCon=false;
+    mbRubberEdgeDragging=true;
+    mbDetailedEdgeDragging=true;
+    mnDetailedEdgeDraggingLimit=10;
+    mbResizeAtCenter=false;
+    mbCrookAtCenter=false;
+    mbMouseHideWhileDraggingPoints=false;
 
     // init using default
     mbSolidDragging = getOptionsDrawinglayer().IsSolidDragCreate();
@@ -177,7 +177,7 @@ bool SdrDragView::TakeDragObjAnchorPos(Point& rPos, bool bTR ) const
         if (pObj->ISA(SdrCaptionObj))
         {
             Point aPt(static_cast<SdrCaptionObj*>(pObj)->GetTailPos());
-            bool bTail=eDragHdl==HDL_POLY; // drag tail
+            bool bTail=meDragHdl==HDL_POLY; // drag tail
             bool bOwn=mpCurrentSdrDragMethod->ISA(SdrDragObjOwn); // specific to object
             if (!bTail)
             { // for bTail, TakeActionRect already does the right thing
@@ -215,18 +215,18 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
         SetDragWithCopy(false);
         //TODO: aAni.Reset();
         mpCurrentSdrDragMethod=NULL;
-        bDragSpecial=false;
-        bDragLimit=false;
+        mbDragSpecial=false;
+        mbDragLimit=false;
         SdrDragMode eTmpMode=eDragMode;
         if (eTmpMode==SDRDRAG_MOVE && pHdl!=NULL && pHdl->GetKind()!=HDL_MOVE) {
             eTmpMode=SDRDRAG_RESIZE;
         }
-        bDragLimit=TakeDragLimit(eTmpMode,aDragLimit);
-        bFramDrag=ImpIsFrameHandles();
-        if (!bFramDrag &&
+        mbDragLimit=TakeDragLimit(eTmpMode,maDragLimit);
+        mbFramDrag=ImpIsFrameHandles();
+        if (!mbFramDrag &&
             (pMarkedObj==NULL || !pMarkedObj->hasSpecialDrag()) &&
             (pHdl==NULL || pHdl->GetObj()==NULL)) {
-            bFramDrag=true;
+            mbFramDrag=true;
         }
 
         Point aPnt(rPnt);
@@ -249,18 +249,18 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
         aDragStat.SetHdl(pHdl);
         aDragStat.NextPoint();
         pDragWin=pOut;
-        pDragHdl=pHdl;
-        eDragHdl= pHdl==NULL ? HDL_MOVE : pHdl->GetKind();
-        bDragHdl=eDragHdl==HDL_REF1 || eDragHdl==HDL_REF2 || eDragHdl==HDL_MIRX;
+        mpDragHdl=pHdl;
+        meDragHdl= pHdl==NULL ? HDL_MOVE : pHdl->GetKind();
+        mbDragHdl=meDragHdl==HDL_REF1 || meDragHdl==HDL_REF2 || meDragHdl==HDL_MIRX;
 
         // Expand test for HDL_ANCHOR_TR
-        bool bNotDraggable = (HDL_ANCHOR == eDragHdl || HDL_ANCHOR_TR == eDragHdl);
+        bool bNotDraggable = (HDL_ANCHOR == meDragHdl || HDL_ANCHOR_TR == meDragHdl);
 
         if(pHdl && (pHdl->GetKind() == HDL_SMARTTAG) && pForcedMeth )
         {
             // just use the forced method for smart tags
         }
-        else if(bDragHdl)
+        else if(mbDragHdl)
         {
             mpCurrentSdrDragMethod = new SdrDragMovHdl(*this);
         }
@@ -270,7 +270,7 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
             {
                 case SDRDRAG_ROTATE: case SDRDRAG_SHEAR: case SDRDRAG_DISTORT:
                 {
-                    switch (eDragHdl)
+                    switch (meDragHdl)
                     {
                         case HDL_LEFT:  case HDL_RIGHT:
                         case HDL_UPPER: case HDL_LOWER:
@@ -305,7 +305,7 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
                         } break;
                         default:
                         {
-                            if (IsMarkedHitMovesAlways() && eDragHdl==HDL_MOVE)
+                            if (IsMarkedHitMovesAlways() && meDragHdl==HDL_MOVE)
                             { // HDL_MOVE is true, even if Obj is hit directly
                                 if (!IsMoveAllowed()) return false;
                                 mpCurrentSdrDragMethod = new SdrDragMove(*this);
@@ -320,7 +320,7 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
                 } break;
                 case SDRDRAG_MIRROR:
                 {
-                    if (eDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
+                    if (meDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
                     {
                         if (!IsMoveAllowed()) return false;
                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
@@ -334,7 +334,7 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
 
                 case SDRDRAG_CROP:
                 {
-                    if (eDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
+                    if (meDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
                     {
                         if (!IsMoveAllowed())
                             return false;
@@ -351,7 +351,7 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
 
                 case SDRDRAG_TRANSPARENCE:
                 {
-                    if(eDragHdl == HDL_MOVE && IsMarkedHitMovesAlways())
+                    if(meDragHdl == HDL_MOVE && IsMarkedHitMovesAlways())
                     {
                         if(!IsMoveAllowed())
                             return false;
@@ -368,7 +368,7 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
                 }
                 case SDRDRAG_GRADIENT:
                 {
-                    if(eDragHdl == HDL_MOVE && IsMarkedHitMovesAlways())
+                    if(meDragHdl == HDL_MOVE && IsMarkedHitMovesAlways())
                     {
                         if(!IsMoveAllowed())
                             return false;
@@ -386,7 +386,7 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
 
                 case SDRDRAG_CROOK :
                 {
-                    if (eDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
+                    if (meDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
                     {
                         if (!IsMoveAllowed()) return false;
                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
@@ -401,19 +401,19 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
                 default:
                 {
                     // SDRDRAG_MOVE
-                    if((eDragHdl == HDL_MOVE) && !IsMoveAllowed())
+                    if((meDragHdl == HDL_MOVE) && !IsMoveAllowed())
                     {
                         return false;
                     }
-                    else if(eDragHdl == HDL_GLUE)
+                    else if(meDragHdl == HDL_GLUE)
                     {
                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
                     }
                     else
                     {
-                        if(bFramDrag)
+                        if(mbFramDrag)
                         {
-                            if(eDragHdl == HDL_MOVE)
+                            if(meDragHdl == HDL_MOVE)
                             {
                                 mpCurrentSdrDragMethod = new SdrDragMove(*this);
                             }
@@ -441,7 +441,7 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
                         }
                         else
                         {
-                            if(HDL_MOVE == eDragHdl)
+                            if(HDL_MOVE == meDragHdl)
                             {
                                 const bool bCustomShapeSelected(1 == GetMarkedObjectCount() && GetMarkedObjectByIndex(0)->ISA(SdrObjCustomShape));
 
@@ -450,7 +450,7 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
                                     mpCurrentSdrDragMethod = new SdrDragMove( *this );
                                 }
                             }
-                            else if(HDL_POLY == eDragHdl)
+                            else if(HDL_POLY == meDragHdl)
                             {
                                 const bool bConnectorSelected(1 == GetMarkedObjectCount() && GetMarkedObjectByIndex(0)->ISA(SdrEdgeObj));
 
@@ -471,7 +471,7 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
                             if(!mpCurrentSdrDragMethod)
                             {
                                 // fallback to DragSpecial if no interaction defined
-                                bDragSpecial = true;
+                                mbDragSpecial = true;
                                 mpCurrentSdrDragMethod = new SdrDragObjOwn(*this);
                             }
                         }
@@ -495,12 +495,12 @@ bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl
                     // Obj may not Move SpecialDrag, so try with MoveFrameDrag
                     delete mpCurrentSdrDragMethod;
                     mpCurrentSdrDragMethod = 0;
-                    bDragSpecial=false;
+                    mbDragSpecial=false;
 
                     if (!IsMoveAllowed())
                         return false;
 
-                    bFramDrag=true;
+                    mbFramDrag=true;
                     mpCurrentSdrDragMethod = new SdrDragMove(*this);
                     aDragStat.SetDragMethod(mpCurrentSdrDragMethod);
                     bRet = mpCurrentSdrDragMethod->BeginSdrDrag();
@@ -545,8 +545,8 @@ bool SdrDragView::EndDragObj(bool bCopy)
         const bool bUndo = IsUndoEnabled();
         if (IsInsertGluePoint() && bUndo)
         {
-            BegUndo(aInsPointUndoStr);
-            AddUndo(pInsPointUndo);
+            BegUndo(maInsPointUndoStr);
+            AddUndo(mpInsPointUndo);
         }
 
         bRet = mpCurrentSdrDragMethod->EndSdrDrag(bCopy);
@@ -571,19 +571,19 @@ bool SdrDragView::EndDragObj(bool bCopy)
             bInsPolyPoint=false;
             if( bUndo )
             {
-                BegUndo(aInsPointUndoStr);
-                AddUndo(pInsPointUndo);
+                BegUndo(maInsPointUndoStr);
+                AddUndo(mpInsPointUndo);
                 EndUndo();
             }
         }
 
-        eDragHdl=HDL_MOVE;
-        pDragHdl=NULL;
+        meDragHdl=HDL_MOVE;
+        mpDragHdl=NULL;
 
         if (!bSomeObjChgdFlag)
         {
             // Obj did not broadcast (e. g. Writer FlyFrames)
-            if(!bDragHdl)
+            if(!mbDragHdl)
             {
                 AdjustMarkHdl();
             }
@@ -611,23 +611,23 @@ void SdrDragView::BrkDragObj()
 
         if (bInsPolyPoint)
         {
-            pInsPointUndo->Undo(); // delete inserted point again
-            delete pInsPointUndo;
-            pInsPointUndo=NULL;
+            mpInsPointUndo->Undo(); // delete inserted point again
+            delete mpInsPointUndo;
+            mpInsPointUndo=NULL;
             SetMarkHandles();
             bInsPolyPoint=false;
         }
 
         if (IsInsertGluePoint())
         {
-            pInsPointUndo->Undo(); // delete inserted glue point again
-            delete pInsPointUndo;
-            pInsPointUndo=NULL;
+            mpInsPointUndo->Undo(); // delete inserted glue point again
+            delete mpInsPointUndo;
+            mpInsPointUndo=NULL;
             SetInsertGluePoint(false);
         }
 
-        eDragHdl=HDL_MOVE;
-        pDragHdl=NULL;
+        meDragHdl=HDL_MOVE;
+        mpDragHdl=NULL;
     }
 }
 
@@ -644,12 +644,12 @@ bool SdrDragView::ImpBegInsObjPoint(bool bIdxZwang, sal_uInt32 nIdx, const Point
     {
         SdrPathObj* pMarkedPath = static_cast<SdrPathObj*>(pMarkedObj);
         BrkAction();
-        pInsPointUndo = dynamic_cast< SdrUndoGeoObj* >( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pMarkedObj) );
-        DBG_ASSERT( pInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" );
+        mpInsPointUndo = dynamic_cast< SdrUndoGeoObj* >( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pMarkedObj) );
+        DBG_ASSERT( mpInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" );
 
         OUString aStr(ImpGetResStr(STR_DragInsertPoint));
 
-        aInsPointUndoStr = aStr.replaceFirst("%1", pMarkedObj->TakeObjNameSingul() );
+        maInsPointUndoStr = aStr.replaceFirst("%1", pMarkedObj->TakeObjNameSingul() );
 
         Point aPt(rPnt);
 
@@ -691,8 +691,8 @@ bool SdrDragView::ImpBegInsObjPoint(bool bIdxZwang, sal_uInt32 nIdx, const Point
         }
         else
         {
-            delete pInsPointUndo;
-            pInsPointUndo = NULL;
+            delete mpInsPointUndo;
+            mpInsPointUndo = NULL;
         }
     }
 
@@ -747,11 +747,11 @@ bool SdrDragView::BegInsGluePoint(const Point& rPnt)
     {
         BrkAction();
         UnmarkAllGluePoints();
-        pInsPointUndo= dynamic_cast< SdrUndoGeoObj* >( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj) );
-        DBG_ASSERT( pInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" );
+        mpInsPointUndo= dynamic_cast< SdrUndoGeoObj* >( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj) );
+        DBG_ASSERT( mpInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" );
         OUString aStr(ImpGetResStr(STR_DragInsertGluePoint));
 
-        aInsPointUndoStr = aStr.replaceFirst("%1", pObj->TakeObjNameSingul() );
+        maInsPointUndoStr = aStr.replaceFirst("%1", pObj->TakeObjNameSingul() );
 
         SdrGluePointList* pGPL=pObj->ForceGluePointList();
         if (pGPL!=NULL)
@@ -778,8 +778,8 @@ bool SdrDragView::BegInsGluePoint(const Point& rPnt)
                 else
                 {
                     SetInsertGluePoint(false);
-                    delete pInsPointUndo;
-                    pInsPointUndo=NULL;
+                    delete mpInsPointUndo;
+                    mpInsPointUndo=NULL;
                 }
             }
             else
@@ -791,8 +791,8 @@ bool SdrDragView::BegInsGluePoint(const Point& rPnt)
         {
             // no glue points possible for this object (e. g. Edge)
             SetInsertGluePoint(false);
-            delete pInsPointUndo;
-            pInsPointUndo=NULL;
+            delete mpInsPointUndo;
+            mpInsPointUndo=NULL;
         }
     }
 
@@ -844,7 +844,7 @@ void SdrDragView::SetNoDragXorPolys(bool bOn)
             HideDragObj();
         }
 
-        bNoDragXorPolys = bOn;
+        mbNoDragXorPolys = bOn;
 
         if(bDragging)
         {
@@ -864,12 +864,12 @@ void SdrDragView::SetDragStripes(bool bOn)
     if (mpCurrentSdrDragMethod && aDragStat.IsShown())
     {
         HideDragObj();
-        bDragStripes=bOn;
+        mbDragStripes=bOn;
         ShowDragObj();
     }
     else
     {
-        bDragStripes=bOn;
+        mbDragStripes=bOn;
     }
 }
 
@@ -885,8 +885,8 @@ bool SdrDragView::IsOrthoDesired() const
 
 void SdrDragView::SetMarkHandles()
 {
-    if( pDragHdl )
-        pDragHdl = 0;
+    if( mpDragHdl )
+        mpDragHdl = 0;
 
     SdrExchangeView::SetMarkHandles();
 }

svx/source/svdraw/svdview.cxx

@@ -1067,7 +1067,7 @@ Pointer SdrView::GetPreferredPointer(const Point& rMousePos, const OutputDevice*
         bool bCorner=pHdl!=NULL && pHdl->IsCornerHdl();
         bool bVertex=pHdl!=NULL && pHdl->IsVertexHdl();
         bool bMov=eHdl==HDL_MOVE;
-        if (bMov && (eDragMode==SDRDRAG_MOVE || eDragMode==SDRDRAG_RESIZE || bMarkedHitMovesAlways)) {
+        if (bMov && (eDragMode==SDRDRAG_MOVE || eDragMode==SDRDRAG_RESIZE || mbMarkedHitMovesAlways)) {
             if (!IsMoveAllowed()) return Pointer(PointerStyle::Arrow); // because double click or drag & drop is possible
             return Pointer(PointerStyle::Move);
         }
@@ -1189,7 +1189,7 @@ OUString SdrView::GetStatusText()
     {
         if (bInsPolyPoint || IsInsertGluePoint())
         {
-            aStr=aInsPointUndoStr;
+            aStr=maInsPointUndoStr;
         }
         else
         {