tools: prefix member variables with an 'm'

Also updated debug pretty-printers

Change-Id: I5204bb8f1c6a47677ad3c49d6579c090ea69aedc
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/137388
Tested-by: Jenkins
Reviewed-by: Michael Stahl <michael.stahl@allotropia.de>

4 files changed, 184 insertions, 184 deletions

diff --git a/include/tools/gen.hxx b/include/tools/gen.hxx
index 35a510124749..8182676e0731 100644
--- a/include/tools/gen.hxx
+++ b/include/tools/gen.hxx
@@ -42,14 +42,14 @@ enum TriState { TRISTATE_FALSE, TRISTATE_TRUE, TRISTATE_INDET };
 class SAL_WARN_UNUSED Pair
 {
 public:
-    constexpr Pair() : nA(0), nB(0) {}
-    constexpr Pair( tools::Long _nA, tools::Long _nB ) : nA(_nA), nB(_nB) {}
+    constexpr Pair() : mnA(0), mnB(0) {}
+    constexpr Pair( tools::Long nA, tools::Long nB ) : mnA(nA), mnB(nB) {}
 
-    tools::Long                A() const { return nA; }
-    tools::Long                B() const { return nB; }
+    tools::Long                A() const { return mnA; }
+    tools::Long                B() const { return mnB; }
 
-    tools::Long&               A() { return nA; }
-    tools::Long&               B() { return nB; }
+    tools::Long&               A() { return mnA; }
+    tools::Long&               B() { return mnB; }
 
     TOOLS_DLLPUBLIC rtl::OString        toString() const;
 
@@ -57,8 +57,8 @@ public:
     TOOLS_DLLPUBLIC size_t     GetHashValue() const;
 
 protected:
-    tools::Long                nA;
-    tools::Long                nB;
+    tools::Long                mnA;
+    tools::Long                mnB;
 };
 
 namespace tools::detail {
@@ -80,13 +80,13 @@ public:
     constexpr Point() {}
     constexpr Point( tools::Long nX, tools::Long nY ) : Pair( nX, nY ) {}
 
-    constexpr tools::Long      X() const { return nA; }
-    constexpr tools::Long      Y() const { return nB; }
+    constexpr tools::Long      X() const { return mnA; }
+    constexpr tools::Long      Y() const { return mnB; }
 
     void                Move( tools::Long nHorzMove, tools::Long nVertMove );
     void                Move( Size const & s );
-    tools::Long                AdjustX( tools::Long nHorzMove ) { nA += nHorzMove; return nA; }
-    tools::Long                AdjustY( tools::Long nVertMove ) { nB += nVertMove; return nB; }
+    tools::Long                AdjustX( tools::Long nHorzMove ) { mnA += nHorzMove; return mnA; }
+    tools::Long                AdjustY( tools::Long nVertMove ) { mnB += nVertMove; return mnB; }
 
     void                RotateAround( tools::Long& rX, tools::Long& rY, Degree10 nOrientation ) const;
     void                RotateAround( Point&, Degree10 nOrientation ) const;
@@ -103,8 +103,8 @@ public:
 
     constexpr tools::Long      getX() const { return X(); }
     constexpr tools::Long      getY() const { return Y(); }
-    void                setX(tools::Long nX)  { nA = nX; }
-    void                setY(tools::Long nY)  { nB = nY; }
+    void                setX(tools::Long nX)  { mnA = nX; }
+    void                setY(tools::Long nY)  { mnB = nY; }
 
     Pair const &        toPair() const { return *this; }
     Pair &              toPair() { return *this; }
@@ -119,56 +119,56 @@ public:
 
 inline void Point::Move( tools::Long nHorzMove, tools::Long nVertMove )
 {
-    nA += nHorzMove;
-    nB += nVertMove;
+    mnA += nHorzMove;
+    mnB += nVertMove;
 }
 
 inline Point& Point::operator += ( const Point& rPoint )
 {
-    nA += rPoint.nA;
-    nB += rPoint.nB;
+    mnA += rPoint.mnA;
+    mnB += rPoint.mnB;
     return *this;
 }
 
 inline Point& Point::operator -= ( const Point& rPoint )
 {
-    nA -= rPoint.nA;
-    nB -= rPoint.nB;
+    mnA -= rPoint.mnA;
+    mnB -= rPoint.mnB;
     return *this;
 }
 
 inline Point& Point::operator *= ( const tools::Long nVal )
 {
-    nA *= nVal;
-    nB *= nVal;
+    mnA *= nVal;
+    mnB *= nVal;
     return *this;
 }
 
 inline Point& Point::operator /= ( const tools::Long nVal )
 {
-    nA /= nVal;
-    nB /= nVal;
+    mnA /= nVal;
+    mnB /= nVal;
     return *this;
 }
 
 inline Point operator+( const Point &rVal1, const Point &rVal2 )
 {
-    return Point( rVal1.nA+rVal2.nA, rVal1.nB+rVal2.nB );
+    return Point( rVal1.mnA+rVal2.mnA, rVal1.mnB+rVal2.mnB );
 }
 
 inline Point operator-( const Point &rVal1, const Point &rVal2 )
 {
-    return Point( rVal1.nA-rVal2.nA, rVal1.nB-rVal2.nB );
+    return Point( rVal1.mnA-rVal2.mnA, rVal1.mnB-rVal2.mnB );
 }
 
 inline Point operator*( const Point &rVal1, const tools::Long nVal2 )
 {
-    return Point( rVal1.nA*nVal2, rVal1.nB*nVal2 );
+    return Point( rVal1.mnA*nVal2, rVal1.mnB*nVal2 );
 }
 
 inline Point operator/( const Point &rVal1, const tools::Long nVal2 )
 {
-    return Point( rVal1.nA/nVal2, rVal1.nB/nVal2 );
+    return Point( rVal1.mnA/nVal2, rVal1.mnB/nVal2 );
 }
 
 inline bool operator ==(Point const & p1, Point const & p2)
@@ -213,23 +213,23 @@ public:
     constexpr Size() {}
     constexpr Size( tools::Long nWidth, tools::Long nHeight ) : Pair( nWidth, nHeight ) {}
 
-    constexpr tools::Long  Width() const  { return nA; }
-    constexpr tools::Long  Height() const { return nB; }
+    constexpr tools::Long  Width() const  { return mnA; }
+    constexpr tools::Long  Height() const { return mnB; }
 
-    tools::Long            AdjustWidth( tools::Long n ) { nA += n; return nA; }
-    tools::Long            AdjustHeight( tools::Long n ) { nB += n; return nB; }
+    tools::Long            AdjustWidth( tools::Long n ) { mnA += n; return mnA; }
+    tools::Long            AdjustHeight( tools::Long n ) { mnB += n; return mnB; }
 
     constexpr tools::Long  getWidth() const { return Width(); }
     constexpr tools::Long  getHeight() const { return Height(); }
-    void            setWidth(tools::Long nWidth)  { nA = nWidth; }
-    void            setHeight(tools::Long nHeight)  { nB = nHeight; }
+    void            setWidth(tools::Long nWidth)  { mnA = nWidth; }
+    void            setHeight(tools::Long nHeight)  { mnB = nHeight; }
 
-    bool            IsEmpty() const { return nA <= 0 || nB <= 0; }
+    bool            IsEmpty() const { return mnA <= 0 || mnB <= 0; }
 
     void extendBy(tools::Long x, tools::Long y)
     {
-        nA += x;
-        nB += y;
+        mnA += x;
+        mnB += y;
     }
 
     Pair const &    toPair() const { return *this; }
@@ -265,50 +265,50 @@ inline bool operator !=(Size const & s1, Size const & s2)
 
 inline Size& Size::operator += ( const Size& rSize )
 {
-    nA += rSize.nA;
-    nB += rSize.nB;
+    mnA += rSize.mnA;
+    mnB += rSize.mnB;
     return *this;
 }
 
 inline Size& Size::operator -= ( const Size& rSize )
 {
-    nA -= rSize.nA;
-    nB -= rSize.nB;
+    mnA -= rSize.mnA;
+    mnB -= rSize.mnB;
     return *this;
 }
 
 inline Size& Size::operator *= ( const tools::Long nVal )
 {
-    nA *= nVal;
-    nB *= nVal;
+    mnA *= nVal;
+    mnB *= nVal;
     return *this;
 }
 
 inline Size& Size::operator /= ( const tools::Long nVal )
 {
-    nA /= nVal;
-    nB /= nVal;
+    mnA /= nVal;
+    mnB /= nVal;
     return *this;
 }
 
 inline Size operator+( const Size &rVal1, const Size &rVal2 )
 {
-    return Size( rVal1.nA+rVal2.nA, rVal1.nB+rVal2.nB );
+    return Size( rVal1.mnA+rVal2.mnA, rVal1.mnB+rVal2.mnB );
 }
 
 inline Size operator-( const Size &rVal1, const Size &rVal2 )
 {
-    return Size( rVal1.nA-rVal2.nA, rVal1.nB-rVal2.nB );
+    return Size( rVal1.mnA-rVal2.mnA, rVal1.mnB-rVal2.mnB );
 }
 
 inline Size operator*( const Size &rVal1, const tools::Long nVal2 )
 {
-    return Size( rVal1.nA*nVal2, rVal1.nB*nVal2 );
+    return Size( rVal1.mnA*nVal2, rVal1.mnB*nVal2 );
 }
 
 inline Size operator/( const Size &rVal1, const tools::Long nVal2 )
 {
-    return Size( rVal1.nA/nVal2, rVal1.nB/nVal2 );
+    return Size( rVal1.mnA/nVal2, rVal1.mnB/nVal2 );
 }
 
 constexpr inline Size Size::scale(sal_Int64 nMulX, sal_Int64 nDivX,
@@ -352,12 +352,12 @@ public:
     constexpr Range() {}
     constexpr Range( tools::Long nMin, tools::Long nMax ) : Pair( nMin, nMax ) {}
 
-    tools::Long            Min() const { return nA; }
-    tools::Long            Max() const { return nB; }
-    tools::Long            Len() const { return nB - nA + 1; }
+    tools::Long            Min() const { return mnA; }
+    tools::Long            Max() const { return mnB; }
+    tools::Long            Len() const { return mnB - mnA + 1; }
 
-    tools::Long&           Min() { return nA; }
-    tools::Long&           Max() { return nB; }
+    tools::Long&           Min() { return mnA; }
+    tools::Long&           Max() { return mnB; }
 
     bool            Contains( tools::Long nIs ) const;
 
@@ -371,16 +371,16 @@ public:
 
 inline bool Range::Contains( tools::Long nIs ) const
 {
-    return ((nA <= nIs) && (nIs <= nB ));
+    return ((mnA <= nIs) && (nIs <= mnB ));
 }
 
 inline void Range::Justify()
 {
-    if ( nA > nB )
+    if ( mnA > mnB )
     {
-        tools::Long nHelp = nA;
-        nA = nB;
-        nB = nHelp;
+        tools::Long nHelp = mnA;
+        mnA = mnB;
+        mnB = nHelp;
     }
 }
 
@@ -413,12 +413,12 @@ public:
                     Selection( tools::Long nPos ) : Pair( nPos, nPos ) {}
                     Selection( tools::Long nMin, tools::Long nMax ) : Pair( nMin, nMax ) {}
 
-    tools::Long            Min() const { return nA; }
-    tools::Long            Max() const { return nB; }
-    tools::Long            Len() const { return nB - nA; }
+    tools::Long            Min() const { return mnA; }
+    tools::Long            Max() const { return mnB; }
+    tools::Long            Len() const { return mnB - mnA; }
 
-    tools::Long&           Min() { return nA; }
-    tools::Long&           Max() { return nB; }
+    tools::Long&           Min() { return mnA; }
+    tools::Long&           Max() { return mnB; }
 
     bool            Contains( tools::Long nIs ) const;
 
@@ -438,16 +438,16 @@ public:
 
 inline bool Selection::Contains( tools::Long nIs ) const
 {
-    return ((nA <= nIs) && (nIs < nB ));
+    return ((mnA <= nIs) && (nIs < mnB ));
 }
 
 inline void Selection::Justify()
 {
-    if ( nA > nB )
+    if ( mnA > mnB )
     {
-        tools::Long nHelp = nA;
-        nA = nB;
-        nB = nHelp;
+        tools::Long nHelp = mnA;
+        mnA = mnB;
+        mnB = nHelp;
     }
 }
 
@@ -495,24 +495,24 @@ class SAL_WARN_UNUSED TOOLS_DLLPUBLIC Rectangle final
 public:
     constexpr Rectangle() = default;
     constexpr Rectangle( const Point& rLT, const Point& rRB );
-    constexpr Rectangle( tools::Long nLeft, tools::Long nTop,
-                         tools::Long nRight, tools::Long nBottom );
+    constexpr Rectangle( tools::Long mnLeft, tools::Long mnTop,
+                         tools::Long mnRight, tools::Long mnBottom );
     /// Constructs an empty Rectangle, with top/left at the specified params
-    constexpr Rectangle( tools::Long nLeft, tools::Long nTop );
+    constexpr Rectangle( tools::Long mnLeft, tools::Long mnTop );
     /// Constructs a closed interval rectangle
     constexpr Rectangle( const Point& rLT, const Size& rSize );
 
     constexpr inline static Rectangle Justify(const Point& rLT, const Point& rRB);
 
-    constexpr tools::Long Left() const { return nLeft; }
-    constexpr tools::Long Right() const { return IsWidthEmpty() ? nLeft : nRight; }
-    constexpr tools::Long Top() const { return nTop; }
-    constexpr tools::Long Bottom() const { return IsHeightEmpty() ? nTop : nBottom; }
+    constexpr tools::Long Left() const { return mnLeft; }
+    constexpr tools::Long Right() const { return IsWidthEmpty() ? mnLeft : mnRight; }
+    constexpr tools::Long Top() const { return mnTop; }
+    constexpr tools::Long Bottom() const { return IsHeightEmpty() ? mnTop : mnBottom; }
 
-    constexpr void SetLeft(tools::Long v) { nLeft = v; }
-    constexpr void SetRight(tools::Long v) { nRight = v; }
-    constexpr void SetTop(tools::Long v) { nTop = v; }
-    constexpr void SetBottom(tools::Long v) { nBottom = v; }
+    constexpr void SetLeft(tools::Long v) { mnLeft = v; }
+    constexpr void SetRight(tools::Long v) { mnRight = v; }
+    constexpr void SetTop(tools::Long v) { mnTop = v; }
+    constexpr void SetBottom(tools::Long v) { mnBottom = v; }
 
     constexpr Point TopLeft() const { return { Left(), Top() }; }
     constexpr Point TopRight() const { return { Right(), Top() }; }
@@ -527,9 +527,9 @@ public:
     /// Move the top and left edges by a delta, preserving width and height
     inline void         Move( tools::Long nHorzMoveDelta, tools::Long nVertMoveDelta );
     void                Move( Size const & s ) { Move(s.Width(), s.Height()); }
-    tools::Long         AdjustLeft( tools::Long nHorzMoveDelta ) { nLeft += nHorzMoveDelta; return nLeft; }
+    tools::Long         AdjustLeft( tools::Long nHorzMoveDelta ) { mnLeft += nHorzMoveDelta; return mnLeft; }
     tools::Long         AdjustRight( tools::Long nHorzMoveDelta );
-    tools::Long         AdjustTop( tools::Long nVertMoveDelta ) { nTop += nVertMoveDelta; return nTop; }
+    tools::Long         AdjustTop( tools::Long nVertMoveDelta ) { mnTop += nVertMoveDelta; return mnTop; }
     tools::Long         AdjustBottom( tools::Long nVertMoveDelta );
     /// Set the left edge of the rectangle to x, preserving the width
     inline void SetPosX(tools::Long x);
@@ -559,12 +559,12 @@ public:
     bool                Contains( const tools::Rectangle& rRect ) const;
     bool                Overlaps( const tools::Rectangle& rRect ) const;
 
-    void                SetEmpty() { nRight = nBottom = RECT_EMPTY; }
-    void                SetWidthEmpty() { nRight = RECT_EMPTY; }
-    void                SetHeightEmpty() { nBottom = RECT_EMPTY; }
+    void                SetEmpty() { mnRight = mnBottom = RECT_EMPTY; }
+    void                SetWidthEmpty() { mnRight = RECT_EMPTY; }
+    void                SetHeightEmpty() { mnBottom = RECT_EMPTY; }
     constexpr bool IsEmpty() const { return IsWidthEmpty() || IsHeightEmpty(); }
-    constexpr bool IsWidthEmpty() const { return nRight == RECT_EMPTY; }
-    constexpr bool IsHeightEmpty() const { return nBottom == RECT_EMPTY; }
+    constexpr bool IsWidthEmpty() const { return mnRight == RECT_EMPTY; }
+    constexpr bool IsHeightEmpty() const { return mnBottom == RECT_EMPTY; }
 
     inline bool         operator == ( const tools::Rectangle& rRect ) const;
     inline bool         operator != ( const tools::Rectangle& rRect ) const;
@@ -575,14 +575,14 @@ public:
     friend inline tools::Rectangle operator + ( const tools::Rectangle& rRect, const Point& rPt );
     friend inline tools::Rectangle operator - ( const tools::Rectangle& rRect, const Point& rPt );
 
-    tools::Long         getX() const { return nLeft; }
-    tools::Long         getY() const { return nTop; }
+    tools::Long         getX() const { return mnLeft; }
+    tools::Long         getY() const { return mnTop; }
     /// Returns the difference between right and left, assuming the range includes one end, but not the other.
     tools::Long getOpenWidth() const { return Right() - Left(); }
     /// Returns the difference between bottom and top, assuming the range includes one end, but not the other.
     tools::Long getOpenHeight() const { return Bottom() - Top(); }
-    void                setWidth( tools::Long n ) { nRight = nLeft + n; }
-    void                setHeight( tools::Long n ) { nBottom = nTop + n; }
+    void                setWidth( tools::Long n ) { mnRight = mnLeft + n; }
+    void                setHeight( tools::Long n ) { mnBottom = mnTop + n; }
     /// Returns the string representation of the rectangle, format is "x, y, width, height".
     rtl::OString        toString() const;
 
@@ -604,10 +604,10 @@ public:
                                             sal_Int64 nMulY, sal_Int64 nDivY) const;
 
 private:
-    tools::Long nLeft = 0;
-    tools::Long nTop = 0;
-    tools::Long nRight = RECT_EMPTY;
-    tools::Long nBottom = RECT_EMPTY;
+    tools::Long mnLeft = 0;
+    tools::Long mnTop = 0;
+    tools::Long mnRight = RECT_EMPTY;
+    tools::Long mnBottom = RECT_EMPTY;
 };
 }
 
@@ -615,24 +615,24 @@ constexpr inline tools::Rectangle::Rectangle( const Point& rLT, const Point& rRB
     : Rectangle(rLT.X(), rLT.Y(), rRB.X(), rRB.Y())
 {}
 
-constexpr inline tools::Rectangle::Rectangle( tools::Long _nLeft,  tools::Long _nTop,
-                             tools::Long _nRight, tools::Long _nBottom )
-    : nLeft( _nLeft )
-    , nTop( _nTop )
-    , nRight( _nRight )
-    , nBottom( _nBottom )
+constexpr inline tools::Rectangle::Rectangle( tools::Long nLeft,  tools::Long nTop,
+                             tools::Long nRight, tools::Long nBottom )
+    : mnLeft( nLeft )
+    , mnTop( nTop )
+    , mnRight( nRight )
+    , mnBottom( nBottom )
 {}
 
-constexpr inline tools::Rectangle::Rectangle( tools::Long _nLeft,  tools::Long _nTop )
-    : nLeft(_nLeft)
-    , nTop(_nTop)
+constexpr inline tools::Rectangle::Rectangle( tools::Long nLeft,  tools::Long nTop )
+    : mnLeft(nLeft)
+    , mnTop(nTop)
 {}
 
 constexpr inline tools::Rectangle::Rectangle( const Point& rLT, const Size& rSize )
-    : nLeft( rLT.X())
-    , nTop( rLT.Y())
-    , nRight(rSize.Width() ? nLeft + (rSize.Width() + (rSize.Width() > 0 ? -1 : 1)) : RECT_EMPTY)
-    , nBottom(rSize.Height() ? nTop + (rSize.Height() + (rSize.Height() > 0 ? -1 : 1)) : RECT_EMPTY)
+    : mnLeft( rLT.X())
+    , mnTop( rLT.Y())
+    , mnRight(rSize.Width() ? mnLeft + (rSize.Width() + (rSize.Width() > 0 ? -1 : 1)) : RECT_EMPTY)
+    , mnBottom(rSize.Height() ? mnTop + (rSize.Height() + (rSize.Height() > 0 ? -1 : 1)) : RECT_EMPTY)
 {}
 
 constexpr inline tools::Rectangle tools::Rectangle::Justify(const Point& rLT, const Point& rRB)
@@ -644,26 +644,26 @@ constexpr inline tools::Rectangle tools::Rectangle::Justify(const Point& rLT, co
 
 inline void tools::Rectangle::Move( tools::Long nHorzMove, tools::Long nVertMove )
 {
-    nLeft += nHorzMove;
-    nTop  += nVertMove;
+    mnLeft += nHorzMove;
+    mnTop  += nVertMove;
     if (!IsWidthEmpty())
-        nRight += nHorzMove;
+        mnRight += nHorzMove;
     if (!IsHeightEmpty())
-        nBottom += nVertMove;
+        mnBottom += nVertMove;
 }
 
 inline void tools::Rectangle::SetPosX(tools::Long x)
 {
     if (!IsWidthEmpty())
-        nRight += x - nLeft;
-    nLeft = x;
+        mnRight += x - mnLeft;
+    mnLeft = x;
 }
 
 inline void tools::Rectangle::SetPosY(tools::Long y)
 {
     if (!IsHeightEmpty())
-        nBottom += y - nTop;
-    nTop = y;
+        mnBottom += y - mnTop;
+    mnTop = y;
 }
 
 inline void tools::Rectangle::SetPos( const Point& rPoint )
@@ -675,9 +675,9 @@ inline void tools::Rectangle::SetPos( const Point& rPoint )
 inline void tools::Rectangle::SetWidth(tools::Long nWidth)
 {
     if (nWidth < 0)
-        nRight = nLeft + nWidth + 1;
+        mnRight = mnLeft + nWidth + 1;
     else if (nWidth > 0)
-        nRight = nLeft + nWidth - 1;
+        mnRight = mnLeft + nWidth - 1;
     else
         SetWidthEmpty();
 }
@@ -685,9 +685,9 @@ inline void tools::Rectangle::SetWidth(tools::Long nWidth)
 inline void tools::Rectangle::SetHeight(tools::Long nHeight)
 {
     if (nHeight < 0)
-        nBottom = nTop + nHeight + 1;
+        mnBottom = mnTop + nHeight + 1;
     else if (nHeight > 0)
-        nBottom = nTop + nHeight - 1;
+        mnBottom = mnTop + nHeight - 1;
     else
         SetHeightEmpty();
 }
@@ -704,7 +704,7 @@ constexpr inline tools::Long tools::Rectangle::GetWidth() const
 
     if (!IsWidthEmpty())
     {
-        n = nRight - nLeft;
+        n = mnRight - mnLeft;
         if (n < 0)
             n--;
         else
@@ -720,7 +720,7 @@ constexpr inline tools::Long tools::Rectangle::GetHeight() const
 
     if (!IsHeightEmpty())
     {
-        n = nBottom - nTop;
+        n = mnBottom - mnTop;
         if (n < 0)
             n--;
         else
@@ -744,18 +744,18 @@ inline tools::Rectangle tools::Rectangle::GetIntersection( const tools::Rectangl
 
 inline bool tools::Rectangle::operator == ( const tools::Rectangle& rRect ) const
 {
-    return (nLeft   == rRect.nLeft   ) &&
-           (nTop    == rRect.nTop    ) &&
-           (nRight  == rRect.nRight  ) &&
-           (nBottom == rRect.nBottom );
+    return (mnLeft   == rRect.mnLeft   ) &&
+           (mnTop    == rRect.mnTop    ) &&
+           (mnRight  == rRect.mnRight  ) &&
+           (mnBottom == rRect.mnBottom );
 }
 
 inline bool tools::Rectangle::operator != ( const tools::Rectangle& rRect ) const
 {
-    return (nLeft   != rRect.nLeft   ) ||
-           (nTop    != rRect.nTop    ) ||
-           (nRight  != rRect.nRight  ) ||
-           (nBottom != rRect.nBottom );
+    return (mnLeft   != rRect.mnLeft   ) ||
+           (mnTop    != rRect.mnTop    ) ||
+           (mnRight  != rRect.mnRight  ) ||
+           (mnBottom != rRect.mnBottom );
 }
 
 inline tools::Rectangle& tools::Rectangle::operator +=( const Point& rPt )
diff --git a/solenv/gdb/libreoffice/tl.py b/solenv/gdb/libreoffice/tl.py
index 8e15bfd47a0d..5eb2c45ca54f 100644
--- a/solenv/gdb/libreoffice/tl.py
+++ b/solenv/gdb/libreoffice/tl.py
@@ -156,8 +156,8 @@ class PointPrinter(object):
         return "%s" % (self.typename)
 
     def children(self):
-        x = self.value['nA']
-        y = self.value['nB']
+        x = self.value['mnA']
+        y = self.value['mnB']
         children = [('x', x), ('y', y)]
         return children.__iter__()
 
@@ -172,8 +172,8 @@ class SizePrinter(object):
         return "%s" % (self.typename)
 
     def children(self):
-        width = self.value['nA']
-        height = self.value['nB']
+        width = self.value['mnA']
+        height = self.value['mnB']
         children = [('width', width), ('height', height)]
         return children.__iter__()
 
@@ -188,10 +188,10 @@ class RectanglePrinter(object):
         return "%s" % (self.typename)
 
     def children(self):
-        left = self.value['nLeft']
-        top = self.value['nTop']
-        right = self.value['nRight']
-        bottom = self.value['nBottom']
+        left = self.value['mnLeft']
+        top = self.value['mnTop']
+        right = self.value['mnRight']
+        bottom = self.value['mnBottom']
         children = [('left', left), ('top', top), ('right', right), ('bottom', bottom)]
         return children.__iter__()
 
diff --git a/solenv/vs/LibreOffice.natvis b/solenv/vs/LibreOffice.natvis
index 23445345a631..ec89af18ff68 100644
--- a/solenv/vs/LibreOffice.natvis
+++ b/solenv/vs/LibreOffice.natvis
@@ -89,29 +89,29 @@
     <DisplayString>{mpImpl}</DisplayString>
   </Type>
   <Type Name="Point">
-    <DisplayString>X:{nA}, Y:{nB}</DisplayString>
+    <DisplayString>X:{mnA}, Y:{mnB}</DisplayString>
   </Type>
   <Type Name="Size">
-    <DisplayString>W:{nA}, H:{nB}</DisplayString>
+    <DisplayString>W:{mnA}, H:{mnB}</DisplayString>
   </Type>
   <Type Name="Range">
-    <DisplayString>Min:{nA}, Max:{nB}</DisplayString>
+    <DisplayString>Min:{mnA}, Max:{mnB}</DisplayString>
   </Type>
   <Type Name="Selection">
-    <DisplayString>Min:{nA}, Max:{nB}</DisplayString>
+    <DisplayString>Min:{mnA}, Max:{mnB}</DisplayString>
   </Type>
   <Type Name="Pair">
-    <DisplayString>A:{nA}, B:{nB}</DisplayString>
+    <DisplayString>A:{mnA}, B:{mnB}</DisplayString>
   </Type>
   <Type Name="SwRect">
     <DisplayString>{m_Point}, {m_Size}</DisplayString>
   </Type>
   <Type Name="tools::Rectangle">
-    <DisplayString IncludeView="w">{nRight==-32767?0:(nRight-nLeft+(nLeft>nRight?(-1):(1)))}</DisplayString>
-    <DisplayString IncludeView="h">{nBottom==-32767?0:(nBottom-nTop+(nTop>nBottom?(-1):(1)))}</DisplayString>
-    <DisplayString IncludeView="sz" Condition="nRight==-32767 || nBottom==-32767">empty</DisplayString>
+    <DisplayString IncludeView="w">{mnRight==-32767?0:(mnRight-mnLeft+(mnLeft>mnRight?(-1):(1)))}</DisplayString>
+    <DisplayString IncludeView="h">{mnBottom==-32767?0:(mnBottom-mnTop+(mnTop>mnBottom?(-1):(1)))}</DisplayString>
+    <DisplayString IncludeView="sz" Condition="mnRight==-32767 || mnBottom==-32767">empty</DisplayString>
     <DisplayString IncludeView="sz">{*this,view(w)nd} x {*this,view(h)nd}</DisplayString>
-    <DisplayString>{{ LT=[{nLeft} , {nTop}] RB=[{nRight} , {nBottom}] [{*this,view(sz)}] }}</DisplayString>
+    <DisplayString>{{ LT=[{mnLeft} , {mnTop}] RB=[{mnRight} , {mnBottom}] [{*this,view(sz)}] }}</DisplayString>
   </Type>
   <Type Name="_sal_Sequence">
     <DisplayString Condition="nElements == 0">_sal_Sequence (empty)</DisplayString>
diff --git a/tools/source/generic/gen.cxx b/tools/source/generic/gen.cxx
index fa2878928512..0452f8ea2049 100644
--- a/tools/source/generic/gen.cxx
+++ b/tools/source/generic/gen.cxx
@@ -37,24 +37,24 @@ OString Pair::toString() const
 size_t Pair::GetHashValue() const
 {
     size_t hash = 0;
-    o3tl::hash_combine( hash, nA );
-    o3tl::hash_combine( hash, nB );
+    o3tl::hash_combine( hash, mnA );
+    o3tl::hash_combine( hash, mnB );
     return hash;
 }
 
 void tools::Rectangle::SaturatingSetSize(const Size& rSize)
 {
     if (rSize.Width() < 0)
-        nRight = o3tl::saturating_add(nLeft, (rSize.Width() + 1));
+        mnRight = o3tl::saturating_add(mnLeft, (rSize.Width() + 1));
     else if ( rSize.Width() > 0 )
-        nRight = o3tl::saturating_add(nLeft, (rSize.Width() - 1));
+        mnRight = o3tl::saturating_add(mnLeft, (rSize.Width() - 1));
     else
         SetWidthEmpty();
 
     if ( rSize.Height() < 0 )
-        nBottom = o3tl::saturating_add(nTop, (rSize.Height() + 1));
+        mnBottom = o3tl::saturating_add(mnTop, (rSize.Height() + 1));
     else if ( rSize.Height() > 0 )
-        nBottom = o3tl::saturating_add(nTop, (rSize.Height() - 1));
+        mnBottom = o3tl::saturating_add(mnTop, (rSize.Height() - 1));
     else
         SetHeightEmpty();
 }
@@ -62,15 +62,15 @@ void tools::Rectangle::SaturatingSetSize(const Size& rSize)
 void tools::Rectangle::SaturatingSetPosX(tools::Long x)
 {
     if (!IsWidthEmpty())
-        nRight = o3tl::saturating_add(nRight, x - nLeft);
-    nLeft = x;
+        mnRight = o3tl::saturating_add(mnRight, x - mnLeft);
+    mnLeft = x;
 }
 
 void tools::Rectangle::SaturatingSetPosY(tools::Long y)
 {
     if (!IsHeightEmpty())
-        nBottom = o3tl::saturating_add(nBottom, y - nTop);
-    nTop = y;
+        mnBottom = o3tl::saturating_add(mnBottom, y - mnTop);
+    mnTop = y;
 }
 
 tools::Rectangle& tools::Rectangle::Union( const tools::Rectangle& rRect )
@@ -82,8 +82,8 @@ tools::Rectangle& tools::Rectangle::Union( const tools::Rectangle& rRect )
         *this = rRect;
     else
     {
-        std::tie(nLeft, nRight) = std::minmax({ nLeft, rRect.nLeft, nRight, rRect.nRight });
-        std::tie(nTop, nBottom) = std::minmax({ nTop, rRect.nTop, nBottom, rRect.nBottom });
+        std::tie(mnLeft, mnRight) = std::minmax({ mnLeft, rRect.mnLeft, mnRight, rRect.mnRight });
+        std::tie(mnTop, mnBottom) = std::minmax({ mnTop, rRect.mnTop, mnBottom, rRect.mnBottom });
     }
 
     return *this;
@@ -105,13 +105,13 @@ tools::Rectangle& tools::Rectangle::Intersection( const tools::Rectangle& rRect
     aTmpRect.Justify();
 
     // Perform intersection
-    nLeft  = std::max( nLeft, aTmpRect.nLeft );
-    nRight = std::min( nRight, aTmpRect.nRight );
-    nTop   = std::max( nTop, aTmpRect.nTop );
-    nBottom= std::min( nBottom, aTmpRect.nBottom );
+    mnLeft  = std::max( mnLeft, aTmpRect.mnLeft );
+    mnRight = std::min( mnRight, aTmpRect.mnRight );
+    mnTop   = std::max( mnTop, aTmpRect.mnTop );
+    mnBottom= std::min( mnBottom, aTmpRect.mnBottom );
 
     // Determine if intersection is empty
-    if ( nRight < nLeft || nBottom < nTop )
+    if ( mnRight < mnLeft || mnBottom < mnTop )
         *this = tools::Rectangle();
 
     return *this;
@@ -119,14 +119,14 @@ tools::Rectangle& tools::Rectangle::Intersection( const tools::Rectangle& rRect
 
 void tools::Rectangle::Justify()
 {
-    if ((nRight < nLeft) && (!IsWidthEmpty()))
+    if ((mnRight < mnLeft) && (!IsWidthEmpty()))
     {
-        std::swap(nLeft, nRight);
+        std::swap(mnLeft, mnRight);
     }
 
-    if ((nBottom < nTop) && (!IsHeightEmpty()))
+    if ((mnBottom < mnTop) && (!IsHeightEmpty()))
     {
-        std::swap(nBottom, nTop);
+        std::swap(mnBottom, mnTop);
     }
 }
 
@@ -135,24 +135,24 @@ bool tools::Rectangle::Contains( const Point& rPoint ) const
     if ( IsEmpty() )
         return false;
 
-    if ( nLeft <= nRight )
+    if ( mnLeft <= mnRight )
     {
-        if ( (rPoint.X() < nLeft) || (rPoint.X() > nRight) )
+        if ( (rPoint.X() < mnLeft) || (rPoint.X() > mnRight) )
             return false;
     }
     else
     {
-        if ( (rPoint.X() > nLeft) || (rPoint.X() < nRight) )
+        if ( (rPoint.X() > mnLeft) || (rPoint.X() < mnRight) )
             return false;
     }
-    if ( nTop <= nBottom )
+    if ( mnTop <= mnBottom )
     {
-        if ( (rPoint.Y() < nTop) || (rPoint.Y() > nBottom) )
+        if ( (rPoint.Y() < mnTop) || (rPoint.Y() > mnBottom) )
             return false;
     }
     else
     {
-        if ( (rPoint.Y() > nTop) || (rPoint.Y() < nBottom) )
+        if ( (rPoint.Y() > mnTop) || (rPoint.Y() < mnBottom) )
             return false;
     }
     return true;
@@ -190,30 +190,30 @@ void tools::Rectangle::expand(tools::Long nExpandBy)
 
 void tools::Rectangle::shrink(tools::Long nShrinkBy)
 {
-    nLeft   += nShrinkBy;
-    nTop    += nShrinkBy;
+    mnLeft   += nShrinkBy;
+    mnTop    += nShrinkBy;
     if (!IsWidthEmpty())
-        nRight -= nShrinkBy;
+        mnRight -= nShrinkBy;
     if (!IsHeightEmpty())
-        nBottom -= nShrinkBy;
+        mnBottom -= nShrinkBy;
 }
 
 tools::Long tools::Rectangle::AdjustRight(tools::Long nHorzMoveDelta)
 {
     if (IsWidthEmpty())
-        nRight = nLeft + nHorzMoveDelta - 1;
+        mnRight = mnLeft + nHorzMoveDelta - 1;
     else
-        nRight += nHorzMoveDelta;
-    return nRight;
+        mnRight += nHorzMoveDelta;
+    return mnRight;
 }
 
 tools::Long tools::Rectangle::AdjustBottom( tools::Long nVertMoveDelta )
 {
     if (IsHeightEmpty())
-        nBottom = nTop + nVertMoveDelta - 1;
+        mnBottom = mnTop + nVertMoveDelta - 1;
     else
-        nBottom += nVertMoveDelta;
-    return nBottom;
+        mnBottom += nVertMoveDelta;
+    return mnBottom;
 }
 
 static_assert( std::is_trivially_copyable< Pair >::value );