update loplugin stylepolice to check local pointers vars

are actually pointer vars.

Also convert from regex to normal code, so we can enable this
plugin all the time.

Change-Id: Ie36a25ecba61c18f99c77c77646d6459a443cbd1
Reviewed-on: https://gerrit.libreoffice.org/24391
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Noel Grandin <noelgrandin@gmail.com>

10 files changed, 310 insertions, 310 deletions

diff --git a/vcl/source/app/help.cxx b/vcl/source/app/help.cxx
index 9b973be74dff..9b72256e07fc 100644
--- a/vcl/source/app/help.cxx
+++ b/vcl/source/app/help.cxx
@@ -668,10 +668,10 @@ void ImplSetHelpWindowPos( vcl::Window* pHelpWin, sal_uInt16 nHelpWinStyle, Quic
         if( aHelpRect.IsInside( aMousePos ) )
         {
             Point delta(2,2);
-            Point pSize( aSz.Width(), aSz.Height() );
-            Point pTest( aMousePos - pSize - delta );
-            if( pTest.X() > aScreenRect.Left() &&  pTest.Y() > aScreenRect.Top() )
-                aPos = pTest;
+            Point aSize( aSz.Width(), aSz.Height() );
+            Point aTest( aMousePos - aSize - delta );
+            if( aTest.X() > aScreenRect.Left() && aTest.Y() > aScreenRect.Top() )
+                aPos = aTest;
             else
                 aPos = aMousePos + delta;
         }
diff --git a/vcl/source/bitmap/BitmapProcessor.cxx b/vcl/source/bitmap/BitmapProcessor.cxx
index 4d1500049592..a80e36693b68 100644
--- a/vcl/source/bitmap/BitmapProcessor.cxx
+++ b/vcl/source/bitmap/BitmapProcessor.cxx
@@ -137,9 +137,9 @@ void BitmapProcessor::colorizeImage(BitmapEx& rBitmapEx, Color aColor)
         BitmapColor aBitmapColor;
         const long nW = pWriteAccess->Width();
         const long nH = pWriteAccess->Height();
-        std::vector<sal_uInt8> pMapR(256);
-        std::vector<sal_uInt8> pMapG(256);
-        std::vector<sal_uInt8> pMapB(256);
+        std::vector<sal_uInt8> aMapR(256);
+        std::vector<sal_uInt8> aMapG(256);
+        std::vector<sal_uInt8> aMapB(256);
         long nX;
         long nY;
 
@@ -149,9 +149,9 @@ void BitmapProcessor::colorizeImage(BitmapEx& rBitmapEx, Color aColor)
 
         for (nX = 0; nX < 256; ++nX)
         {
-            pMapR[nX] = MinMax((nX + cR) / 2, 0, 255);
-            pMapG[nX] = MinMax((nX + cG) / 2, 0, 255);
-            pMapB[nX] = MinMax((nX + cB) / 2, 0, 255);
+            aMapR[nX] = MinMax((nX + cR) / 2, 0, 255);
+            aMapG[nX] = MinMax((nX + cG) / 2, 0, 255);
+            aMapB[nX] = MinMax((nX + cB) / 2, 0, 255);
         }
 
         if (pWriteAccess->HasPalette())
@@ -159,9 +159,9 @@ void BitmapProcessor::colorizeImage(BitmapEx& rBitmapEx, Color aColor)
             for (sal_uInt16 i = 0, nCount = pWriteAccess->GetPaletteEntryCount(); i < nCount; i++)
             {
                 const BitmapColor& rCol = pWriteAccess->GetPaletteColor(i);
-                aBitmapColor.SetRed(pMapR[rCol.GetRed()]);
-                aBitmapColor.SetGreen(pMapG[rCol.GetGreen()]);
-                aBitmapColor.SetBlue(pMapB[rCol.GetBlue()]);
+                aBitmapColor.SetRed(aMapR[rCol.GetRed()]);
+                aBitmapColor.SetGreen(aMapG[rCol.GetGreen()]);
+                aBitmapColor.SetBlue(aMapB[rCol.GetBlue()]);
                 pWriteAccess->SetPaletteColor(i, aBitmapColor);
             }
         }
@@ -173,9 +173,9 @@ void BitmapProcessor::colorizeImage(BitmapEx& rBitmapEx, Color aColor)
 
                 for (nX = 0; nX < nW; ++nX)
                 {
-                    *pScan = pMapB[*pScan]; pScan++;
-                    *pScan = pMapG[*pScan]; pScan++;
-                    *pScan = pMapR[*pScan]; pScan++;
+                    *pScan = aMapB[*pScan]; pScan++;
+                    *pScan = aMapG[*pScan]; pScan++;
+                    *pScan = aMapR[*pScan]; pScan++;
                 }
             }
         }
@@ -186,9 +186,9 @@ void BitmapProcessor::colorizeImage(BitmapEx& rBitmapEx, Color aColor)
                 for (nX = 0; nX < nW; ++nX)
                 {
                     aBitmapColor = pWriteAccess->GetPixel(nY, nX);
-                    aBitmapColor.SetRed(pMapR[aBitmapColor.GetRed()]);
-                    aBitmapColor.SetGreen(pMapG[aBitmapColor.GetGreen()]);
-                    aBitmapColor.SetBlue(pMapB[aBitmapColor.GetBlue()]);
+                    aBitmapColor.SetRed(aMapR[aBitmapColor.GetRed()]);
+                    aBitmapColor.SetGreen(aMapG[aBitmapColor.GetGreen()]);
+                    aBitmapColor.SetBlue(aMapB[aBitmapColor.GetBlue()]);
                     pWriteAccess->SetPixel(nY, nX, aBitmapColor);
                 }
             }
diff --git a/vcl/source/bitmap/BitmapTools.cxx b/vcl/source/bitmap/BitmapTools.cxx
index f476ca0065e7..cb016c3306a3 100644
--- a/vcl/source/bitmap/BitmapTools.cxx
+++ b/vcl/source/bitmap/BitmapTools.cxx
@@ -35,11 +35,11 @@ void BitmapTools::loadFromSvg(SvStream& rStream, const OUString& sPath, BitmapEx
     const uno::Reference<graphic::XSvgParser> xSvgParser = graphic::SvgTools::create(xContext);
 
     sal_Size nSize = rStream.remainingSize();
-    std::vector<sal_Int8> pBuffer(nSize + 1);
-    rStream.Read(pBuffer.data(), nSize);
-    pBuffer[nSize] = 0;
+    std::vector<sal_Int8> aBuffer(nSize + 1);
+    rStream.Read(aBuffer.data(), nSize);
+    aBuffer[nSize] = 0;
 
-    uno::Sequence<sal_Int8> aData(pBuffer.data(), nSize + 1);
+    uno::Sequence<sal_Int8> aData(aBuffer.data(), nSize + 1);
     uno::Reference<io::XInputStream> aInputStream(new comphelper::SequenceInputStream(aData));
 
     Primitive2DSequence aPrimitiveSequence = xSvgParser->getDecomposition(aInputStream, sPath);
diff --git a/vcl/source/edit/textdata.cxx b/vcl/source/edit/textdata.cxx
index a3b32c8287c8..841e5cc78433 100644
--- a/vcl/source/edit/textdata.cxx
+++ b/vcl/source/edit/textdata.cxx
@@ -164,9 +164,9 @@ sal_uInt16 TEParaPortion::GetLineNumber( sal_Int32 nChar, bool bInclEnd )
 {
     for ( size_t nLine = 0; nLine < maLines.size(); nLine++ )
     {
-        TextLine& pLine = maLines[ nLine ];
-        if ( ( bInclEnd && ( pLine.GetEnd() >= nChar ) ) ||
-             ( pLine.GetEnd() > nChar ) )
+        TextLine& rLine = maLines[ nLine ];
+        if ( ( bInclEnd && ( rLine.GetEnd() >= nChar ) ) ||
+             ( rLine.GetEnd() > nChar ) )
         {
             return nLine;
         }
@@ -184,10 +184,10 @@ void TEParaPortion::CorrectValuesBehindLastFormattedLine( sal_uInt16 nLastFormat
     DBG_ASSERT( nLines, "CorrectPortionNumbersFromLine: Leere Portion?" );
     if ( nLastFormattedLine < ( nLines - 1 ) )
     {
-        const TextLine& pLastFormatted = maLines[ nLastFormattedLine ];
-        const TextLine& pUnformatted = maLines[ nLastFormattedLine+1 ];
-        short nPortionDiff = pUnformatted.GetStartPortion() - pLastFormatted.GetEndPortion();
-        sal_Int32 nTextDiff = pUnformatted.GetStart() - pLastFormatted.GetEnd();
+        const TextLine& rLastFormatted = maLines[ nLastFormattedLine ];
+        const TextLine& rUnformatted = maLines[ nLastFormattedLine+1 ];
+        short nPortionDiff = rUnformatted.GetStartPortion() - rLastFormatted.GetEndPortion();
+        sal_Int32 nTextDiff = rUnformatted.GetStart() - rLastFormatted.GetEnd();
         nTextDiff++;    // LastFormatted.GetEnd() was inclusive => subtracted one too much!
 
         // The first unformatted one has to start exactly one portion past the last
@@ -199,15 +199,15 @@ void TEParaPortion::CorrectValuesBehindLastFormattedLine( sal_uInt16 nLastFormat
         {
             for ( sal_uInt16 nL = nLastFormattedLine+1; nL < nLines; nL++ )
             {
-                TextLine& pLine = maLines[ nL ];
+                TextLine& rLine = maLines[ nL ];
 
-                pLine.GetStartPortion() = pLine.GetStartPortion() + nPDiff;
-                pLine.GetEndPortion() = pLine.GetEndPortion() + nPDiff;
+                rLine.GetStartPortion() = rLine.GetStartPortion() + nPDiff;
+                rLine.GetEndPortion() = rLine.GetEndPortion() + nPDiff;
 
-                pLine.GetStart() = pLine.GetStart() + nTDiff;
-                pLine.GetEnd() = pLine.GetEnd() + nTDiff;
+                rLine.GetStart() = rLine.GetStart() + nTDiff;
+                rLine.GetEnd() = rLine.GetEnd() + nTDiff;
 
-                pLine.SetValid();
+                rLine.SetValid();
             }
         }
     }
diff --git a/vcl/source/edit/texteng.cxx b/vcl/source/edit/texteng.cxx
index 40a47719a242..af3425b30d9d 100644
--- a/vcl/source/edit/texteng.cxx
+++ b/vcl/source/edit/texteng.cxx
@@ -270,8 +270,8 @@ OUString TextEngine::GetTextLines( LineEnd aSeparator ) const
         const size_t nLines = pTEParaPortion->GetLines().size();
         for ( size_t nL = 0; nL < nLines; ++nL )
         {
-            TextLine& pLine = pTEParaPortion->GetLines()[nL];
-            aText += pTEParaPortion->GetNode()->GetText().copy( pLine.GetStart(), pLine.GetEnd() - pLine.GetStart() );
+            TextLine& rLine = pTEParaPortion->GetLines()[nL];
+            aText += pTEParaPortion->GetNode()->GetText().copy( rLine.GetStart(), rLine.GetEnd() - rLine.GetStart() );
             if ( pSep && ( ( (nP+1) < nParas ) || ( (nL+1) < nLines ) ) )
                 aText += pSep;
         }
@@ -895,14 +895,14 @@ Rectangle TextEngine::GetEditCursor( const TextPaM& rPaM, bool bSpecial, bool bP
     TextLine* pLine = nullptr;
     for ( size_t nLine = 0; nLine < pPortion->GetLines().size(); nLine++ )
     {
-        TextLine& pTmpLine = pPortion->GetLines()[ nLine ];
-        if ( ( pTmpLine.GetStart() == rPaM.GetIndex() ) || ( pTmpLine.IsIn( rPaM.GetIndex(), bSpecial ) ) )
+        TextLine& rTmpLine = pPortion->GetLines()[ nLine ];
+        if ( ( rTmpLine.GetStart() == rPaM.GetIndex() ) || ( rTmpLine.IsIn( rPaM.GetIndex(), bSpecial ) ) )
         {
-            pLine = &pTmpLine;
+            pLine = &rTmpLine;
             break;
         }
 
-        nCurIndex = nCurIndex + pTmpLine.GetLen();
+        nCurIndex = nCurIndex + rTmpLine.GetLen();
         nY += mnCharHeight;
     }
     if ( !pLine )
@@ -1076,11 +1076,11 @@ sal_Int32 TextEngine::ImpFindIndex( sal_uInt32 nPortion, const Point& rPosInPara
     sal_uInt16 nLine;
     for ( nLine = 0; nLine < pPortion->GetLines().size(); nLine++ )
     {
-        TextLine& pTmpLine = pPortion->GetLines()[ nLine ];
+        TextLine& rmpLine = pPortion->GetLines()[ nLine ];
         nY += mnCharHeight;
         if ( nY > rPosInPara.Y() )  // that's it
         {
-            pLine = &pTmpLine;
+            pLine = &rmpLine;
             break;                  // correct Y-Position not needed
         }
     }
@@ -1103,15 +1103,15 @@ sal_Int32 TextEngine::GetCharPos( sal_uInt32 nPortion, sal_uInt16 nLine, long nX
 {
 
     TEParaPortion* pPortion = mpTEParaPortions->GetObject( nPortion );
-    TextLine& pLine = pPortion->GetLines()[ nLine ];
+    TextLine& rLine = pPortion->GetLines()[ nLine ];
 
-    sal_Int32 nCurIndex = pLine.GetStart();
+    sal_Int32 nCurIndex = rLine.GetStart();
 
-    long nTmpX = pLine.GetStartX();
+    long nTmpX = rLine.GetStartX();
     if ( nXPos <= nTmpX )
         return nCurIndex;
 
-    for ( sal_uInt16 i = pLine.GetStartPortion(); i <= pLine.GetEndPortion(); i++ )
+    for ( sal_uInt16 i = rLine.GetStartPortion(); i <= rLine.GetEndPortion(); i++ )
     {
         TETextPortion* pTextPortion = pPortion->GetTextPortions()[ i ];
         nTmpX += pTextPortion->GetWidth();
@@ -1165,8 +1165,8 @@ long TextEngine::CalcTextWidth( sal_uInt32 nPara )
     for ( auto nLine = pPortion->GetLines().size(); nLine; )
     {
         long nLineWidth = 0;
-        TextLine& pLine = pPortion->GetLines()[ --nLine ];
-        for ( sal_uInt16 nTP = pLine.GetStartPortion(); nTP <= pLine.GetEndPortion(); nTP++ )
+        TextLine& rLine = pPortion->GetLines()[ --nLine ];
+        for ( sal_uInt16 nTP = rLine.GetStartPortion(); nTP <= rLine.GetEndPortion(); nTP++ )
         {
             TETextPortion* pTextPortion = pPortion->GetTextPortions()[ nTP ];
             nLineWidth += pTextPortion->GetWidth();
@@ -1274,8 +1274,8 @@ Range TextEngine::GetInvalidYOffsets( sal_uInt32 nPortion )
     sal_uInt16 nLine;
     for ( nLine = 0; nLine < nLines; nLine++ )
     {
-        TextLine& pL = pTEParaPortion->GetLines()[ nLine ];
-        if ( pL.IsInvalid() )
+        TextLine& rL = pTEParaPortion->GetLines()[ nLine ];
+        if ( rL.IsInvalid() )
         {
             nFirstInvalid = nLine;
             break;
@@ -1284,8 +1284,8 @@ Range TextEngine::GetInvalidYOffsets( sal_uInt32 nPortion )
 
     for ( nLastInvalid = nFirstInvalid; nLastInvalid < nLines; nLastInvalid++ )
     {
-        TextLine& pL = pTEParaPortion->GetLines()[ nLine ];
-        if ( pL.IsValid() )
+        TextLine& rL = pTEParaPortion->GetLines()[ nLine ];
+        if ( rL.IsValid() )
             break;
     }
 
@@ -1942,18 +1942,18 @@ void TextEngine::ImpPaint( OutputDevice* pOutDev, const Point& rStartPos, Rectan
         {
             // for all lines of the paragraph
             sal_Int32 nIndex = 0;
-            for ( auto &pLine : pPortion->GetLines() )
+            for ( auto & rLine : pPortion->GetLines() )
             {
-                Point aTmpPos( rStartPos.X() + pLine.GetStartX(), nY );
+                Point aTmpPos( rStartPos.X() + rLine.GetStartX(), nY );
 
                 if ( ( !pPaintArea || ( ( nY + mnCharHeight ) > pPaintArea->Top() ) )
                     && ( !pPaintRange || (
-                        ( TextPaM( nPara, pLine.GetStart() ) < pPaintRange->GetEnd() ) &&
-                        ( TextPaM( nPara, pLine.GetEnd() ) > pPaintRange->GetStart() ) ) ) )
+                        ( TextPaM( nPara, rLine.GetStart() ) < pPaintRange->GetEnd() ) &&
+                        ( TextPaM( nPara, rLine.GetEnd() ) > pPaintRange->GetStart() ) ) ) )
                 {
                     // for all Portions of the line
-                    nIndex = pLine.GetStart();
-                    for ( sal_uInt16 y = pLine.GetStartPortion(); y <= pLine.GetEndPortion(); y++ )
+                    nIndex = rLine.GetStart();
+                    for ( sal_uInt16 y = rLine.GetStartPortion(); y <= rLine.GetEndPortion(); y++ )
                     {
                         OSL_ENSURE(pPortion->GetTextPortions().size(),
                                 "ImpPaint: Line without Textportion!");
@@ -1963,7 +1963,7 @@ void TextEngine::ImpPaint( OutputDevice* pOutDev, const Point& rStartPos, Rectan
                         ImpInitLayoutMode( pOutDev /*, pTextPortion->IsRightToLeft() */);
 
                         long nTxtWidth = pTextPortion->GetWidth();
-                        aTmpPos.X() = rStartPos.X() + ImpGetOutputOffset( nPara, &pLine, nIndex, nIndex );
+                        aTmpPos.X() = rStartPos.X() + ImpGetOutputOffset( nPara, &rLine, nIndex, nIndex );
 
                         // only print if starting in the visible region
                         if ( ( ( aTmpPos.X() + nTxtWidth ) >= 0 )
@@ -2015,7 +2015,7 @@ void TextEngine::ImpPaint( OutputDevice* pOutDev, const Point& rStartPos, Rectan
                                                 {
                                                     const sal_Int32 nL = pSelStart->GetIndex() - nTmpIndex;
                                                     pOutDev->SetFont( aFont);
-                                                    aPos.X() = rStartPos.X() + ImpGetOutputOffset( nPara, &pLine, nTmpIndex, nTmpIndex+nL );
+                                                    aPos.X() = rStartPos.X() + ImpGetOutputOffset( nPara, &rLine, nTmpIndex, nTmpIndex+nL );
                                                     pOutDev->DrawText( aPos, pPortion->GetNode()->GetText(), nTmpIndex, nL );
                                                     nTmpIndex = nTmpIndex + nL;
 
@@ -2029,7 +2029,7 @@ void TextEngine::ImpPaint( OutputDevice* pOutDev, const Point& rStartPos, Rectan
                                                     Color aOldTextColor = pOutDev->GetTextColor();
                                                     pOutDev->SetTextColor( rStyleSettings.GetHighlightTextColor() );
                                                     pOutDev->SetTextFillColor( rStyleSettings.GetHighlightColor() );
-                                                    aPos.X() = rStartPos.X() + ImpGetOutputOffset( nPara, &pLine, nTmpIndex, nTmpIndex+nL );
+                                                    aPos.X() = rStartPos.X() + ImpGetOutputOffset( nPara, &rLine, nTmpIndex, nTmpIndex+nL );
                                                     pOutDev->DrawText( aPos, pPortion->GetNode()->GetText(), nTmpIndex, nL );
                                                     pOutDev->SetTextColor( aOldTextColor );
                                                     pOutDev->SetTextFillColor();
@@ -2040,7 +2040,7 @@ void TextEngine::ImpPaint( OutputDevice* pOutDev, const Point& rStartPos, Rectan
                                                 if ( nTmpIndex < nEnd )
                                                 {
                                                     nL = nEnd-nTmpIndex;
-                                                    aPos.X() = rStartPos.X() + ImpGetOutputOffset( nPara, &pLine, nTmpIndex, nTmpIndex+nL );
+                                                    aPos.X() = rStartPos.X() + ImpGetOutputOffset( nPara, &rLine, nTmpIndex, nTmpIndex+nL );
                                                     pOutDev->DrawText( aPos, pPortion->GetNode()->GetText(), nTmpIndex, nEnd-nTmpIndex );
                                                 }
                                                 bDone = true;
@@ -2048,7 +2048,7 @@ void TextEngine::ImpPaint( OutputDevice* pOutDev, const Point& rStartPos, Rectan
                                         }
                                         if ( !bDone )
                                         {
-                                            aPos.X() = rStartPos.X() + ImpGetOutputOffset( nPara, &pLine, nTmpIndex, nEnd );
+                                            aPos.X() = rStartPos.X() + ImpGetOutputOffset( nPara, &rLine, nTmpIndex, nEnd );
                                             pOutDev->DrawText( aPos, pPortion->GetNode()->GetText(), nTmpIndex, nEnd-nTmpIndex );
                                         }
                                     }
diff --git a/vcl/source/edit/textview.cxx b/vcl/source/edit/textview.cxx
index 038f122bd83d..daaf4f480b29 100644
--- a/vcl/source/edit/textview.cxx
+++ b/vcl/source/edit/textview.cxx
@@ -367,9 +367,9 @@ void TextView::ImpHighlight( const TextSelection& rSel )
                 // iterate over all lines
                 for ( sal_uInt16 nLine = nStartLine; nLine <= nEndLine; nLine++ )
                 {
-                    TextLine& pLine = pTEParaPortion->GetLines()[ nLine ];
-                    sal_Int32 nStartIndex = pLine.GetStart();
-                    sal_Int32 nEndIndex = pLine.GetEnd();
+                    TextLine& rLine = pTEParaPortion->GetLines()[ nLine ];
+                    sal_Int32 nStartIndex = rLine.GetStart();
+                    sal_Int32 nEndIndex = rLine.GetEnd();
                     if ( ( nPara == nStartPara ) && ( nLine == nStartLine ) )
                         nStartIndex = aSel.GetStart().GetIndex();
                     if ( ( nPara == nEndPara ) && ( nLine == nEndLine ) )
@@ -970,9 +970,9 @@ void TextView::Command( const CommandEvent& rCEvt )
 
             TEParaPortion* pParaPortion = mpImpl->mpTextEngine->mpTEParaPortions->GetObject( aPaM.GetPara() );
             sal_uInt16 nLine = pParaPortion->GetLineNumber( aPaM.GetIndex(), true );
-            TextLine& pLine = pParaPortion->GetLines()[ nLine ];
-            if ( nInputEnd > pLine.GetEnd() )
-                nInputEnd = pLine.GetEnd();
+            TextLine& rLine = pParaPortion->GetLines()[ nLine ];
+            if ( nInputEnd > rLine.GetEnd() )
+                nInputEnd = rLine.GetEnd();
             Rectangle aR2 = mpImpl->mpTextEngine->PaMtoEditCursor( TextPaM( aPaM.GetPara(), nInputEnd ) );
 
             long nWidth = aR2.Left()-aR1.Right();
@@ -1462,8 +1462,8 @@ TextPaM TextView::CursorUp( const TextPaM& rPaM )
         // If we need to go to the end of a line that was wrapped automatically,
         // the cursor ends up at the beginning of the 2nd line
         // Problem: Last character of an automatically wrapped line = Cursor
-        TextLine& pLine = pPPortion->GetLines()[ nLine - 1 ];
-        if ( aPaM.GetIndex() && ( aPaM.GetIndex() == pLine.GetEnd() ) )
+        TextLine& rLine = pPPortion->GetLines()[ nLine - 1 ];
+        if ( aPaM.GetIndex() && ( aPaM.GetIndex() == rLine.GetEnd() ) )
             --aPaM.GetIndex();
     }
     else if ( rPaM.GetPara() )  // previous paragraph
@@ -1497,8 +1497,8 @@ TextPaM TextView::CursorDown( const TextPaM& rPaM )
         aPaM.GetIndex() = mpImpl->mpTextEngine->GetCharPos( rPaM.GetPara(), nLine+1, nX );
 
         // special case CursorUp
-        TextLine& pLine = pPPortion->GetLines()[ nLine + 1 ];
-        if ( ( aPaM.GetIndex() == pLine.GetEnd() ) && ( aPaM.GetIndex() > pLine.GetStart() ) && aPaM.GetIndex() < pPPortion->GetNode()->GetText().getLength() )
+        TextLine& rLine = pPPortion->GetLines()[ nLine + 1 ];
+        if ( ( aPaM.GetIndex() == rLine.GetEnd() ) && ( aPaM.GetIndex() > rLine.GetStart() ) && aPaM.GetIndex() < pPPortion->GetNode()->GetText().getLength() )
             --aPaM.GetIndex();
     }
     else if ( rPaM.GetPara() < ( mpImpl->mpTextEngine->mpDoc->GetNodes().size() - 1 ) )   // next paragraph
@@ -1506,8 +1506,8 @@ TextPaM TextView::CursorDown( const TextPaM& rPaM )
         aPaM.GetPara()++;
         pPPortion = mpImpl->mpTextEngine->mpTEParaPortions->GetObject( aPaM.GetPara() );
         aPaM.GetIndex() = mpImpl->mpTextEngine->GetCharPos( aPaM.GetPara(), 0, nX+1 );
-        TextLine& pLine = pPPortion->GetLines().front();
-        if ( ( aPaM.GetIndex() == pLine.GetEnd() ) && ( aPaM.GetIndex() > pLine.GetStart() ) && ( pPPortion->GetLines().size() > 1 ) )
+        TextLine& rLine = pPPortion->GetLines().front();
+        if ( ( aPaM.GetIndex() == rLine.GetEnd() ) && ( aPaM.GetIndex() > rLine.GetStart() ) && ( pPPortion->GetLines().size() > 1 ) )
             --aPaM.GetIndex();
     }
 
@@ -1520,8 +1520,8 @@ TextPaM TextView::CursorStartOfLine( const TextPaM& rPaM )
 
     TEParaPortion* pPPortion = mpImpl->mpTextEngine->mpTEParaPortions->GetObject( rPaM.GetPara() );
     sal_uInt16 nLine = pPPortion->GetLineNumber( aPaM.GetIndex(), false );
-    TextLine& pLine = pPPortion->GetLines()[ nLine ];
-    aPaM.GetIndex() = pLine.GetStart();
+    TextLine& rLine = pPPortion->GetLines()[ nLine ];
+    aPaM.GetIndex() = rLine.GetStart();
 
     return aPaM;
 }
@@ -1532,10 +1532,10 @@ TextPaM TextView::CursorEndOfLine( const TextPaM& rPaM )
 
     TEParaPortion* pPPortion = mpImpl->mpTextEngine->mpTEParaPortions->GetObject( rPaM.GetPara() );
     sal_uInt16 nLine = pPPortion->GetLineNumber( aPaM.GetIndex(), false );
-    TextLine& pLine = pPPortion->GetLines()[ nLine ];
-    aPaM.GetIndex() = pLine.GetEnd();
+    TextLine& rLine = pPPortion->GetLines()[ nLine ];
+    aPaM.GetIndex() = rLine.GetEnd();
 
-    if ( pLine.GetEnd() > pLine.GetStart() )  // empty line
+    if ( rLine.GetEnd() > rLine.GetStart() )  // empty line
     {
         sal_Unicode cLastChar = pPPortion->GetNode()->GetText()[ aPaM.GetIndex()-1 ];
         if ( ( cLastChar == ' ' ) && ( aPaM.GetIndex() != pPPortion->GetNode()->GetText().getLength() ) )
diff --git a/vcl/source/filter/ixpm/xpmread.cxx b/vcl/source/filter/ixpm/xpmread.cxx
index d4853b496b41..b757709be118 100644
--- a/vcl/source/filter/ixpm/xpmread.cxx
+++ b/vcl/source/filter/ixpm/xpmread.cxx
@@ -575,7 +575,7 @@ bool XPMReader::ImplCompare( sal_uInt8 const * pSource, sal_uInt8 const * pDest,
 bool XPMReader::ImplGetPara ( sal_uLong nNumb )
 {
     sal_uInt8   nByte;
-    sal_uLong   pSize = 0;
+    sal_uLong   nSize = 0;
     sal_uInt8*  pPtr = mpStringBuf;
     sal_uLong   nCount = 0;
 
@@ -591,7 +591,7 @@ bool XPMReader::ImplGetPara ( sal_uLong nNumb )
         nCount = 0xffffffff;
     }
 
-    while ( pSize < mnStringSize )
+    while ( nSize < mnStringSize )
     {
         nByte = *pPtr;
 
@@ -616,7 +616,7 @@ bool XPMReader::ImplGetPara ( sal_uLong nNumb )
                 nCount++;
             }
         }
-        pSize++;
+        nSize++;
         pPtr++;
     }
     return ( ( nCount == nNumb ) && ( mpPara ) );
diff --git a/vcl/source/gdi/bitmap3.cxx b/vcl/source/gdi/bitmap3.cxx
index 5b6902c30244..46826ad50362 100644
--- a/vcl/source/gdi/bitmap3.cxx
+++ b/vcl/source/gdi/bitmap3.cxx
@@ -709,9 +709,9 @@ bool Bitmap::ImplConvertDown(sal_uInt16 nBitCount, Color* pExtColor)
             InverseColorMap aColorMap(aPalette);
             BitmapColor aColor;
             ImpErrorQuad aErrQuad;
-            std::vector<ImpErrorQuad> pErrQuad1(nWidth);
-            std::vector<ImpErrorQuad> pErrQuad2(nWidth);
-            ImpErrorQuad* pQLine1 = pErrQuad1.data();
+            std::vector<ImpErrorQuad> aErrQuad1(nWidth);
+            std::vector<ImpErrorQuad> aErrQuad2(nWidth);
+            ImpErrorQuad* pQLine1 = aErrQuad1.data();
             ImpErrorQuad* pQLine2 = nullptr;
             long nYTmp = 0L;
             sal_uInt8 cIndex;
@@ -735,7 +735,7 @@ bool Bitmap::ImplConvertDown(sal_uInt16 nBitCount, Color* pExtColor)
 
             for (long nY = 0L; nY < std::min(nHeight, 2L); nY++, nYTmp++)
             {
-                pQLine2 = !nY ? pErrQuad1.data() : pErrQuad2.data();
+                pQLine2 = !nY ? aErrQuad1.data() : aErrQuad2.data();
                 for (long nX = 0L; nX < nWidth; nX++)
                 {
                     if (pReadAcc->HasPalette())
@@ -773,7 +773,7 @@ bool Bitmap::ImplConvertDown(sal_uInt16 nBitCount, Color* pExtColor)
 
                 // Refill/copy row buffer
                 pQLine1 = pQLine2;
-                pQLine2 = (bQ1 = !bQ1) ? pErrQuad2.data() : pErrQuad1.data();
+                pQLine2 = (bQ1 = !bQ1) ? aErrQuad2.data() : aErrQuad1.data();
 
                 if (nYTmp < nHeight)
                 {
diff --git a/vcl/source/gdi/pdfwriter_impl.cxx b/vcl/source/gdi/pdfwriter_impl.cxx
index 4ee03669a4fd..7595aeae07bb 100644
--- a/vcl/source/gdi/pdfwriter_impl.cxx
+++ b/vcl/source/gdi/pdfwriter_impl.cxx
@@ -2101,11 +2101,11 @@ bool PDFWriterImpl::compressStream( SvMemoryStream* pStream )
     pStream->Seek( STREAM_SEEK_TO_END );
     sal_uLong nEndPos = pStream->Tell();
     pStream->Seek( STREAM_SEEK_TO_BEGIN );
-    ZCodec pCodec( 0x4000, 0x4000 );
+    ZCodec aCodec( 0x4000, 0x4000 );
     SvMemoryStream aStream;
-    pCodec.BeginCompression();
-    pCodec.Write( aStream, static_cast<const sal_uInt8*>(pStream->GetData()), nEndPos );
-    pCodec.EndCompression();
+    aCodec.BeginCompression();
+    aCodec.Write( aStream, static_cast<const sal_uInt8*>(pStream->GetData()), nEndPos );
+    aCodec.EndCompression();
     nEndPos = aStream.Tell();
     pStream->Seek( STREAM_SEEK_TO_BEGIN );
     aStream.Seek( STREAM_SEEK_TO_BEGIN );
@@ -3748,11 +3748,11 @@ sal_Int32 PDFWriterImpl::createToUnicodeCMap( sal_uInt8* pEncoding,
                       "end\n"
                       "end\n" );
 #ifndef DEBUG_DISABLE_PDFCOMPRESSION
-    ZCodec pCodec( 0x4000, 0x4000 );
+    ZCodec aCodec( 0x4000, 0x4000 );
     SvMemoryStream aStream;
-    pCodec.BeginCompression();
-    pCodec.Write( aStream, reinterpret_cast<const sal_uInt8*>(aContents.getStr()), aContents.getLength() );
-    pCodec.EndCompression();
+    aCodec.BeginCompression();
+    aCodec.Write( aStream, reinterpret_cast<const sal_uInt8*>(aContents.getStr()), aContents.getLength() );
+    aCodec.EndCompression();
 #endif
 
     #if OSL_DEBUG_LEVEL > 1
diff --git a/vcl/source/window/splitwin.cxx b/vcl/source/window/splitwin.cxx
index be145fab7cf6..b19c625de95f 100644
--- a/vcl/source/window/splitwin.cxx
+++ b/vcl/source/window/splitwin.cxx
@@ -341,19 +341,19 @@ static ImplSplitSet* ImplFindSet( ImplSplitSet* pSet, sal_uInt16 nId )
 
     sal_uInt16          i;
     size_t              nItems = pSet->mpItems.size();
-    ImplSplitItems&     pItems = pSet->mpItems;
+    ImplSplitItems&     rItems = pSet->mpItems;
 
     for ( i = 0; i < nItems; i++ )
     {
-        if ( pItems[i]->mnId == nId )
-            return pItems[i]->mpSet;
+        if ( rItems[i]->mnId == nId )
+            return rItems[i]->mpSet;
     }
 
     for ( i = 0; i < nItems; i++ )
     {
-        if ( pItems[i]->mpSet )
+        if ( rItems[i]->mpSet )
         {
-            ImplSplitSet* pFindSet = ImplFindSet( pItems[i]->mpSet, nId );
+            ImplSplitSet* pFindSet = ImplFindSet( rItems[i]->mpSet, nId );
             if ( pFindSet )
                 return pFindSet;
         }
@@ -366,11 +366,11 @@ static ImplSplitSet* ImplFindItem( ImplSplitSet* pSet, sal_uInt16 nId, sal_uInt1
 {
     sal_uInt16          i;
     size_t              nItems = pSet->mpItems.size();
-    ImplSplitItems&     pItems = pSet->mpItems;
+    ImplSplitItems&     rItems = pSet->mpItems;
 
     for ( i = 0; i < nItems; i++ )
     {
-        if ( pItems[i]->mnId == nId )
+        if ( rItems[i]->mnId == nId )
         {
             rPos = i;
             return pSet;
@@ -379,9 +379,9 @@ static ImplSplitSet* ImplFindItem( ImplSplitSet* pSet, sal_uInt16 nId, sal_uInt1
 
     for ( i = 0; i < nItems; i++ )
     {
-        if ( pItems[i]->mpSet )
+        if ( rItems[i]->mpSet )
         {
-            ImplSplitSet* pFindSet = ImplFindItem( pItems[i]->mpSet, nId, rPos );
+            ImplSplitSet* pFindSet = ImplFindItem( rItems[i]->mpSet, nId, rPos );
             if ( pFindSet )
                 return pFindSet;
         }
@@ -394,17 +394,17 @@ static sal_uInt16 ImplFindItem( ImplSplitSet* pSet, vcl::Window* pWindow )
 {
     sal_uInt16          i;
     size_t              nItems = pSet->mpItems.size();
-    ImplSplitItems&     pItems = pSet->mpItems;
+    ImplSplitItems&     rItems = pSet->mpItems;
 
     for ( i = 0; i < nItems; i++ )
     {
-        if ( pItems[i]->mpWindow == pWindow )
-            return pItems[i]->mnId;
+        if ( rItems[i]->mpWindow == pWindow )
+            return rItems[i]->mnId;
         else
         {
-            if ( pItems[i]->mpSet )
+            if ( rItems[i]->mpSet )
             {
-                sal_uInt16 nId = ImplFindItem( pItems[i]->mpSet, pWindow );
+                sal_uInt16 nId = ImplFindItem( rItems[i]->mpSet, pWindow );
                 if ( nId )
                     return nId;
             }
@@ -419,14 +419,14 @@ static sal_uInt16 ImplFindItem( ImplSplitSet* pSet, const Point& rPos,
 {
     sal_uInt16          i;
     size_t              nItems = pSet->mpItems.size();
-    ImplSplitItems&     pItems = pSet->mpItems;
+    ImplSplitItems&     rItems = pSet->mpItems;
 
     for ( i = 0; i < nItems; i++ )
     {
-        if ( pItems[i]->mnWidth && pItems[i]->mnHeight )
+        if ( rItems[i]->mnWidth && rItems[i]->mnHeight )
         {
-            Point       aPoint( pItems[i]->mnLeft, pItems[i]->mnTop );
-            Size        aSize( pItems[i]->mnWidth, pItems[i]->mnHeight );
+            Point       aPoint( rItems[i]->mnLeft, rItems[i]->mnTop );
+            Size        aSize( rItems[i]->mnWidth, rItems[i]->mnHeight );
             Rectangle   aRect( aPoint, aSize );
             if ( bRows )
             {
@@ -445,13 +445,13 @@ static sal_uInt16 ImplFindItem( ImplSplitSet* pSet, const Point& rPos,
 
             if ( aRect.IsInside( rPos ) )
             {
-                if ( pItems[i]->mpSet && !pItems[i]->mpSet->mpItems.empty() )
+                if ( rItems[i]->mpSet && !rItems[i]->mpSet->mpItems.empty() )
                 {
-                    return ImplFindItem( pItems[i]->mpSet, rPos,
-                                        !(pItems[i]->mnBits & SplitWindowItemFlags::ColSet) );
+                    return ImplFindItem( rItems[i]->mpSet, rPos,
+                                        !(rItems[i]->mnBits & SplitWindowItemFlags::ColSet) );
                 }
                 else
-                    return pItems[i]->mnId;
+                    return rItems[i]->mnId;
             }
         }
     }
@@ -477,14 +477,14 @@ static void ImplCalcSet( ImplSplitSet* pSet,
     long                nCalcSize;
     long                nPos;
     long                nMaxPos;
-    ImplSplitItems&     pItems = pSet->mpItems;
+    ImplSplitItems&     rItems = pSet->mpItems;
     bool                bEmpty;
 
     // get number of visible items
     nVisItems = 0;
     for ( i = 0; i < nItems; i++ )
     {
-        if ( !(pItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
+        if ( !(rItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
             nVisItems++;
     }
 
@@ -504,14 +504,14 @@ static void ImplCalcSet( ImplSplitSet* pSet,
         long nCurSize       = 0;
         for ( i = 0; i < nItems; i++ )
         {
-            if ( !(pItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
+            if ( !(rItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
             {
-                if ( pItems[i]->mnBits & SplitWindowItemFlags::RelativeSize )
-                    nRelCount += pItems[i]->mnSize;
-                else if ( pItems[i]->mnBits & SplitWindowItemFlags::PercentSize )
-                    nPercent += pItems[i]->mnSize;
+                if ( rItems[i]->mnBits & SplitWindowItemFlags::RelativeSize )
+                    nRelCount += rItems[i]->mnSize;
+                else if ( rItems[i]->mnBits & SplitWindowItemFlags::PercentSize )
+                    nPercent += rItems[i]->mnSize;
                 else
-                    nAbsSize += pItems[i]->mnSize;
+                    nAbsSize += rItems[i]->mnSize;
             }
         }
         // map relative values to percentages (percentage here one tenth of a procent)
@@ -537,25 +537,25 @@ static void ImplCalcSet( ImplSplitSet* pSet,
         long nSizeDelta = nCalcSize-nAbsSize;
         for ( i = 0; i < nItems; i++ )
         {
-            if ( pItems[i]->mnBits & SplitWindowItemFlags::Invisible )
-                pItems[i]->mnPixSize = 0;
-            else if ( pItems[i]->mnBits & SplitWindowItemFlags::RelativeSize )
+            if ( rItems[i]->mnBits & SplitWindowItemFlags::Invisible )
+                rItems[i]->mnPixSize = 0;
+            else if ( rItems[i]->mnBits & SplitWindowItemFlags::RelativeSize )
             {
                 if ( nSizeDelta <= 0 )
-                    pItems[i]->mnPixSize = 0;
+                    rItems[i]->mnPixSize = 0;
                 else
-                    pItems[i]->mnPixSize = (nSizeDelta*pItems[i]->mnSize*nRelPercent)/nPercent;
+                    rItems[i]->mnPixSize = (nSizeDelta*rItems[i]->mnSize*nRelPercent)/nPercent;
             }
-            else if ( pItems[i]->mnBits & SplitWindowItemFlags::PercentSize )
+            else if ( rItems[i]->mnBits & SplitWindowItemFlags::PercentSize )
             {
                 if ( nSizeDelta <= 0 )
-                    pItems[i]->mnPixSize = 0;
+                    rItems[i]->mnPixSize = 0;
                 else
-                    pItems[i]->mnPixSize = (nSizeDelta*pItems[i]->mnSize*nPercentFactor)/nPercent;
+                    rItems[i]->mnPixSize = (nSizeDelta*rItems[i]->mnSize*nPercentFactor)/nPercent;
             }
             else
-                pItems[i]->mnPixSize = pItems[i]->mnSize;
-            nCurSize += pItems[i]->mnPixSize;
+                rItems[i]->mnPixSize = rItems[i]->mnSize;
+            nCurSize += rItems[i]->mnPixSize;
         }
 
         pSet->mbCalcPix  = false;
@@ -572,12 +572,12 @@ static void ImplCalcSet( ImplSplitSet* pSet,
             // first resize absolute items relative
             for ( i = 0; i < nItems; i++ )
             {
-                if ( !(pItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
+                if ( !(rItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
                 {
-                    if ( !(pItems[i]->mnBits & (SplitWindowItemFlags::RelativeSize | SplitWindowItemFlags::PercentSize)) )
+                    if ( !(rItems[i]->mnBits & (SplitWindowItemFlags::RelativeSize | SplitWindowItemFlags::PercentSize)) )
                     {
                         nAbsItems++;
-                        nSizeWinSize += pItems[i]->mnPixSize;
+                        nSizeWinSize += rItems[i]->mnPixSize;
                     }
                 }
             }
@@ -586,12 +586,12 @@ static void ImplCalcSet( ImplSplitSet* pSet,
             {
                 for ( i = 0; i < nItems; i++ )
                 {
-                    if ( !(pItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
+                    if ( !(rItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
                     {
-                        if ( !(pItems[i]->mnBits & (SplitWindowItemFlags::RelativeSize | SplitWindowItemFlags::PercentSize)) )
+                        if ( !(rItems[i]->mnBits & (SplitWindowItemFlags::RelativeSize | SplitWindowItemFlags::PercentSize)) )
                         {
-                            pItems[i]->mnPixSize += (nSizeDelta*pItems[i]->mnPixSize)/nSizeWinSize;
-                            nNewSizeWinSize += pItems[i]->mnPixSize;
+                            rItems[i]->mnPixSize += (nSizeDelta*rItems[i]->mnPixSize)/nSizeWinSize;
+                            nNewSizeWinSize += rItems[i]->mnPixSize;
                         }
                     }
                 }
@@ -609,28 +609,28 @@ static void ImplCalcSet( ImplSplitSet* pSet,
                 {
                     for ( i = 0; i < nItems; i++ )
                     {
-                        pItems[i]->mbSubSize = false;
+                        rItems[i]->mbSubSize = false;
 
                         if ( j >= 2 )
-                            pItems[i]->mbSubSize = true;
+                            rItems[i]->mbSubSize = true;
                         else
                         {
-                            if ( !(pItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
+                            if ( !(rItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
                             {
-                                if ( (nSizeDelta > 0) || pItems[i]->mnPixSize )
+                                if ( (nSizeDelta > 0) || rItems[i]->mnPixSize )
                                 {
                                     if ( j >= 1 )
-                                        pItems[i]->mbSubSize = true;
+                                        rItems[i]->mbSubSize = true;
                                     else
                                     {
-                                        if ( (j == 0) && (pItems[i]->mnBits & (SplitWindowItemFlags::RelativeSize | SplitWindowItemFlags::PercentSize)) )
-                                            pItems[i]->mbSubSize = true;
+                                        if ( (j == 0) && (rItems[i]->mnBits & (SplitWindowItemFlags::RelativeSize | SplitWindowItemFlags::PercentSize)) )
+                                            rItems[i]->mbSubSize = true;
                                     }
                                 }
                             }
                         }
 
-                        if ( pItems[i]->mbSubSize )
+                        if ( rItems[i]->mbSubSize )
                             nCalcItems++;
                     }
 
@@ -643,11 +643,11 @@ static void ImplCalcSet( ImplSplitSet* pSet,
                 nMins           = 0;
                 for ( i = 0; i < nItems; i++ )
                 {
-                    if ( pItems[i]->mnBits & SplitWindowItemFlags::Invisible )
+                    if ( rItems[i]->mnBits & SplitWindowItemFlags::Invisible )
                         nMins++;
-                    else if ( pItems[i]->mbSubSize )
+                    else if ( rItems[i]->mbSubSize )
                     {
-                        long* pSize = &(pItems[i]->mnPixSize);
+                        long* pSize = &(rItems[i]->mnPixSize);
                         long  nTempErr;
 
                         if ( nErrorSum )
@@ -708,24 +708,24 @@ static void ImplCalcSet( ImplSplitSet* pSet,
     // order windows and adept values
     for ( i = 0; i < nItems; i++ )
     {
-        pItems[i]->mnOldSplitPos    = pItems[i]->mnSplitPos;
-        pItems[i]->mnOldSplitSize   = pItems[i]->mnSplitSize;
-        pItems[i]->mnOldWidth       = pItems[i]->mnWidth;
-        pItems[i]->mnOldHeight      = pItems[i]->mnHeight;
+        rItems[i]->mnOldSplitPos    = rItems[i]->mnSplitPos;
+        rItems[i]->mnOldSplitSize   = rItems[i]->mnSplitSize;
+        rItems[i]->mnOldWidth       = rItems[i]->mnWidth;
+        rItems[i]->mnOldHeight      = rItems[i]->mnHeight;
 
-        if ( pItems[i]->mnBits & SplitWindowItemFlags::Invisible )
+        if ( rItems[i]->mnBits & SplitWindowItemFlags::Invisible )
             bEmpty = true;
         else
         {
             bEmpty = false;
             if ( bDown )
             {
-                if ( nPos+pItems[i]->mnPixSize > nMaxPos )
+                if ( nPos+rItems[i]->mnPixSize > nMaxPos )
                     bEmpty = true;
             }
             else
             {
-                nPos -= pItems[i]->mnPixSize;
+                nPos -= rItems[i]->mnPixSize;
                 if ( nPos < nMaxPos )
                     bEmpty = true;
             }
@@ -733,85 +733,85 @@ static void ImplCalcSet( ImplSplitSet* pSet,
 
         if ( bEmpty )
         {
-            pItems[i]->mnWidth     = 0;
-            pItems[i]->mnHeight    = 0;
-            pItems[i]->mnSplitSize = 0;
+            rItems[i]->mnWidth     = 0;
+            rItems[i]->mnHeight    = 0;
+            rItems[i]->mnSplitSize = 0;
         }
         else
         {
             if ( bRows )
             {
-                pItems[i]->mnLeft   = nSetLeft;
-                pItems[i]->mnTop    = nPos;
-                pItems[i]->mnWidth  = nSetWidth;
-                pItems[i]->mnHeight = pItems[i]->mnPixSize;
+                rItems[i]->mnLeft   = nSetLeft;
+                rItems[i]->mnTop    = nPos;
+                rItems[i]->mnWidth  = nSetWidth;
+                rItems[i]->mnHeight = rItems[i]->mnPixSize;
             }
             else
             {
-                pItems[i]->mnLeft   = nPos;
-                pItems[i]->mnTop    = nSetTop;
-                pItems[i]->mnWidth  = pItems[i]->mnPixSize;
-                pItems[i]->mnHeight = nSetHeight;
+                rItems[i]->mnLeft   = nPos;
+                rItems[i]->mnTop    = nSetTop;
+                rItems[i]->mnWidth  = rItems[i]->mnPixSize;
+                rItems[i]->mnHeight = nSetHeight;
             }
 
             if ( i > nItems-1 )
-                pItems[i]->mnSplitSize = 0;
+                rItems[i]->mnSplitSize = 0;
             else
             {
-                pItems[i]->mnSplitSize = pSet->mnSplitSize;
+                rItems[i]->mnSplitSize = pSet->mnSplitSize;
                 if ( bDown )
                 {
-                    pItems[i]->mnSplitPos  = nPos+pItems[i]->mnPixSize;
-                    if ( pItems[i]->mnSplitPos+pItems[i]->mnSplitSize > nMaxPos )
-                        pItems[i]->mnSplitSize = nMaxPos-pItems[i]->mnSplitPos;
+                    rItems[i]->mnSplitPos  = nPos+rItems[i]->mnPixSize;
+                    if ( rItems[i]->mnSplitPos+rItems[i]->mnSplitSize > nMaxPos )
+                        rItems[i]->mnSplitSize = nMaxPos-rItems[i]->mnSplitPos;
                 }
                 else
                 {
-                    pItems[i]->mnSplitPos = nPos-pSet->mnSplitSize;
-                    if ( pItems[i]->mnSplitPos < nMaxPos )
-                        pItems[i]->mnSplitSize = pItems[i]->mnSplitPos+pSet->mnSplitSize-nMaxPos;
+                    rItems[i]->mnSplitPos = nPos-pSet->mnSplitSize;
+                    if ( rItems[i]->mnSplitPos < nMaxPos )
+                        rItems[i]->mnSplitSize = rItems[i]->mnSplitPos+pSet->mnSplitSize-nMaxPos;
                 }
             }
         }
 
-        if ( !(pItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
+        if ( !(rItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
         {
             if ( !bDown )
                 nPos -= pSet->mnSplitSize;
             else
-                nPos += pItems[i]->mnPixSize+pSet->mnSplitSize;
+                nPos += rItems[i]->mnPixSize+pSet->mnSplitSize;
         }
     }
 
     // calculate Sub-Set's
     for ( i = 0; i < nItems; i++ )
     {
-        if ( pItems[i]->mpSet && pItems[i]->mnWidth && pItems[i]->mnHeight )
+        if ( rItems[i]->mpSet && rItems[i]->mnWidth && rItems[i]->mnHeight )
         {
-            ImplCalcSet( pItems[i]->mpSet,
-                         pItems[i]->mnLeft, pItems[i]->mnTop,
-                         pItems[i]->mnWidth, pItems[i]->mnHeight,
-                         !(pItems[i]->mnBits & SplitWindowItemFlags::ColSet) );
+            ImplCalcSet( rItems[i]->mpSet,
+                         rItems[i]->mnLeft, rItems[i]->mnTop,
+                         rItems[i]->mnWidth, rItems[i]->mnHeight,
+                         !(rItems[i]->mnBits & SplitWindowItemFlags::ColSet) );
         }
     }
 
     // set fixed
     for ( i = 0; i < nItems; i++ )
     {
-        pItems[i]->mbFixed = false;
-        if ( pItems[i]->mnBits & SplitWindowItemFlags::Fixed )
-            pItems[i]->mbFixed = true;
+        rItems[i]->mbFixed = false;
+        if ( rItems[i]->mnBits & SplitWindowItemFlags::Fixed )
+            rItems[i]->mbFixed = true;
         else
         {
             // this item is also fixed if Child-Set is available,
             // if a child is fixed
-            if ( pItems[i]->mpSet )
+            if ( rItems[i]->mpSet )
             {
-                for ( j = 0; j < pItems[i]->mpSet->mpItems.size(); j++ )
+                for ( j = 0; j < rItems[i]->mpSet->mpItems.size(); j++ )
                 {
-                    if ( pItems[i]->mpSet->mpItems[j]->mbFixed )
+                    if ( rItems[i]->mpSet->mpItems[j]->mbFixed )
                     {
-                        pItems[i]->mbFixed = true;
+                        rItems[i]->mbFixed = true;
                         break;
                     }
                 }
@@ -825,63 +825,63 @@ void SplitWindow::ImplCalcSet2( SplitWindow* pWindow, ImplSplitSet* pSet, bool b
 {
     sal_uInt16          i;
     size_t              nItems = pSet->mpItems.size();
-    ImplSplitItems&     pItems = pSet->mpItems;
+    ImplSplitItems&     rItems = pSet->mpItems;
 
     if ( pWindow->IsReallyVisible() && pWindow->IsUpdateMode() && pWindow->mbInvalidate )
     {
         for ( i = 0; i < nItems; i++ )
         {
-            if ( pItems[i]->mnSplitSize )
+            if ( rItems[i]->mnSplitSize )
             {
                 // invalidate all, if applicable or only a small part
-                if ( (pItems[i]->mnOldSplitPos  != pItems[i]->mnSplitPos)  ||
-                     (pItems[i]->mnOldSplitSize != pItems[i]->mnSplitSize) ||
-                     (pItems[i]->mnOldWidth     != pItems[i]->mnWidth)     ||
-                     (pItems[i]->mnOldHeight    != pItems[i]->mnHeight) )
+                if ( (rItems[i]->mnOldSplitPos  != rItems[i]->mnSplitPos)  ||
+                     (rItems[i]->mnOldSplitSize != rItems[i]->mnSplitSize) ||
+                     (rItems[i]->mnOldWidth     != rItems[i]->mnWidth)     ||
+                     (rItems[i]->mnOldHeight    != rItems[i]->mnHeight) )
                 {
                     Rectangle aRect;
 
                     // invalidate old rectangle
                     if ( bRows )
                     {
-                        aRect.Left()    = pItems[i]->mnLeft;
-                        aRect.Right()   = pItems[i]->mnLeft+pItems[i]->mnOldWidth-1;
-                        aRect.Top()     = pItems[i]->mnOldSplitPos;
-                        aRect.Bottom()  = aRect.Top() + pItems[i]->mnOldSplitSize;
+                        aRect.Left()    = rItems[i]->mnLeft;
+                        aRect.Right()   = rItems[i]->mnLeft+rItems[i]->mnOldWidth-1;
+                        aRect.Top()     = rItems[i]->mnOldSplitPos;
+                        aRect.Bottom()  = aRect.Top() + rItems[i]->mnOldSplitSize;
                     }
                     else
                     {
-                        aRect.Top()     = pItems[i]->mnTop;
-                        aRect.Bottom()  = pItems[i]->mnTop+pItems[i]->mnOldHeight-1;
-                        aRect.Left()    = pItems[i]->mnOldSplitPos;
-                        aRect.Right()   = aRect.Left() + pItems[i]->mnOldSplitSize;
+                        aRect.Top()     = rItems[i]->mnTop;
+                        aRect.Bottom()  = rItems[i]->mnTop+rItems[i]->mnOldHeight-1;
+                        aRect.Left()    = rItems[i]->mnOldSplitPos;
+                        aRect.Right()   = aRect.Left() + rItems[i]->mnOldSplitSize;
                     }
                     pWindow->Invalidate( aRect );
                     // invalidate new rectangle
                     if ( bRows )
                     {
-                        aRect.Left()    = pItems[i]->mnLeft;
-                        aRect.Right()   = pItems[i]->mnLeft+pItems[i]->mnWidth-1;
-                        aRect.Top()     = pItems[i]->mnSplitPos;
-                        aRect.Bottom()  = aRect.Top() + pItems[i]->mnSplitSize;
+                        aRect.Left()    = rItems[i]->mnLeft;
+                        aRect.Right()   = rItems[i]->mnLeft+rItems[i]->mnWidth-1;
+                        aRect.Top()     = rItems[i]->mnSplitPos;
+                        aRect.Bottom()  = aRect.Top() + rItems[i]->mnSplitSize;
                     }
                     else
                     {
-                        aRect.Top()     = pItems[i]->mnTop;
-                        aRect.Bottom()  = pItems[i]->mnTop+pItems[i]->mnHeight-1;
-                        aRect.Left()    = pItems[i]->mnSplitPos;
-                        aRect.Right()   = aRect.Left() + pItems[i]->mnSplitSize;
+                        aRect.Top()     = rItems[i]->mnTop;
+                        aRect.Bottom()  = rItems[i]->mnTop+rItems[i]->mnHeight-1;
+                        aRect.Left()    = rItems[i]->mnSplitPos;
+                        aRect.Right()   = aRect.Left() + rItems[i]->mnSplitSize;
                     }
                     pWindow->Invalidate( aRect );
 
                     // invalidate complete set, as these areas
                     // are not cluttered by windows
-                    if ( pItems[i]->mpSet && pItems[i]->mpSet->mpItems.empty() )
+                    if ( rItems[i]->mpSet && rItems[i]->mpSet->mpItems.empty() )
                     {
-                        aRect.Left()    = pItems[i]->mnLeft;
-                        aRect.Top()     = pItems[i]->mnTop;
-                        aRect.Right()   = pItems[i]->mnLeft+pItems[i]->mnWidth-1;
-                        aRect.Bottom()  = pItems[i]->mnTop+pItems[i]->mnHeight-1;
+                        aRect.Left()    = rItems[i]->mnLeft;
+                        aRect.Top()     = rItems[i]->mnTop;
+                        aRect.Right()   = rItems[i]->mnLeft+rItems[i]->mnWidth-1;
+                        aRect.Bottom()  = rItems[i]->mnTop+rItems[i]->mnHeight-1;
                         pWindow->Invalidate( aRect );
                     }
                 }
@@ -892,36 +892,36 @@ void SplitWindow::ImplCalcSet2( SplitWindow* pWindow, ImplSplitSet* pSet, bool b
     // position windows
     for ( i = 0; i < nItems; i++ )
     {
-        if ( pItems[i]->mpSet )
+        if ( rItems[i]->mpSet )
         {
             bool bTempHide = bHide;
-            if ( !pItems[i]->mnWidth || !pItems[i]->mnHeight )
+            if ( !rItems[i]->mnWidth || !rItems[i]->mnHeight )
                 bTempHide = true;
-            ImplCalcSet2( pWindow, pItems[i]->mpSet, bTempHide,
-                          !(pItems[i]->mnBits & SplitWindowItemFlags::ColSet) );
+            ImplCalcSet2( pWindow, rItems[i]->mpSet, bTempHide,
+                          !(rItems[i]->mnBits & SplitWindowItemFlags::ColSet) );
         }
         else
         {
-            if ( pItems[i]->mnWidth && pItems[i]->mnHeight && !bHide )
+            if ( rItems[i]->mnWidth && rItems[i]->mnHeight && !bHide )
             {
-                Point aPos( pItems[i]->mnLeft, pItems[i]->mnTop );
-                Size  aSize( pItems[i]->mnWidth, pItems[i]->mnHeight );
-                pItems[i]->mpWindow->SetPosSizePixel( aPos, aSize );
+                Point aPos( rItems[i]->mnLeft, rItems[i]->mnTop );
+                Size  aSize( rItems[i]->mnWidth, rItems[i]->mnHeight );
+                rItems[i]->mpWindow->SetPosSizePixel( aPos, aSize );
             }
             else
-                pItems[i]->mpWindow->Hide();
+                rItems[i]->mpWindow->Hide();
         }
     }
 
     // show windows and reset flag
     for ( i = 0; i < nItems; i++ )
     {
-        if ( pItems[i]->mpWindow && pItems[i]->mnWidth && pItems[i]->mnHeight && !bHide )
-            pItems[i]->mpWindow->Show();
+        if ( rItems[i]->mpWindow && rItems[i]->mnWidth && rItems[i]->mnHeight && !bHide )
+            rItems[i]->mpWindow->Show();
     }
 }
 
-static void ImplCalcLogSize( ImplSplitItems pItems, size_t nItems )
+static void ImplCalcLogSize( ImplSplitItems rItems, size_t nItems )
 {
     // update original sizes
     size_t  i;
@@ -930,30 +930,30 @@ static void ImplCalcLogSize( ImplSplitItems pItems, size_t nItems )
 
     for ( i = 0; i < nItems; i++ )
     {
-        if ( pItems[i]->mnBits & SplitWindowItemFlags::RelativeSize )
-            nRelSize += pItems[i]->mnPixSize;
-        else if ( pItems[i]->mnBits & SplitWindowItemFlags::PercentSize )
-            nPerSize += pItems[i]->mnPixSize;
+        if ( rItems[i]->mnBits & SplitWindowItemFlags::RelativeSize )
+            nRelSize += rItems[i]->mnPixSize;
+        else if ( rItems[i]->mnBits & SplitWindowItemFlags::PercentSize )
+            nPerSize += rItems[i]->mnPixSize;
     }
     nPerSize += nRelSize;
     for ( i = 0; i < nItems; i++ )
     {
-        if ( pItems[i]->mnBits & SplitWindowItemFlags::RelativeSize )
+        if ( rItems[i]->mnBits & SplitWindowItemFlags::RelativeSize )
         {
             if ( nRelSize )
-                pItems[i]->mnSize = (pItems[i]->mnPixSize+(nRelSize/2))/nRelSize;
+                rItems[i]->mnSize = (rItems[i]->mnPixSize+(nRelSize/2))/nRelSize;
             else
-                pItems[i]->mnSize = 1;
+                rItems[i]->mnSize = 1;
         }
-        else if ( pItems[i]->mnBits & SplitWindowItemFlags::PercentSize )
+        else if ( rItems[i]->mnBits & SplitWindowItemFlags::PercentSize )
         {
             if ( nPerSize )
-                pItems[i]->mnSize = (pItems[i]->mnPixSize*100)/nPerSize;
+                rItems[i]->mnSize = (rItems[i]->mnPixSize*100)/nPerSize;
             else
-                pItems[i]->mnSize = 1;
+                rItems[i]->mnSize = 1;
         }
         else
-            pItems[i]->mnSize = pItems[i]->mnPixSize;
+            rItems[i]->mnSize = rItems[i]->mnPixSize;
     }
 }
 
@@ -990,7 +990,7 @@ void SplitWindow::ImplDrawBack(vcl::RenderContext& rRenderContext, ImplSplitSet*
 {
     sal_uInt16      i;
     size_t          nItems = pSet->mpItems.size();
-    ImplSplitItems& pItems = pSet->mpItems;
+    ImplSplitItems& rItems = pSet->mpItems;
 
     // also draw background for mainset
     if (pSet->mnId == 0)
@@ -1007,13 +1007,13 @@ void SplitWindow::ImplDrawBack(vcl::RenderContext& rRenderContext, ImplSplitSet*
 
     for (i = 0; i < nItems; i++)
     {
-        pSet = pItems[i]->mpSet;
+        pSet = rItems[i]->mpSet;
         if (pSet)
         {
             if (pSet->mpBitmap || pSet->mpWallpaper)
             {
-                Point aPoint(pItems[i]->mnLeft, pItems[i]->mnTop);
-                Size aSize(pItems[i]->mnWidth, pItems[i]->mnHeight);
+                Point aPoint(rItems[i]->mnLeft, rItems[i]->mnTop);
+                Size aSize(rItems[i]->mnWidth, rItems[i]->mnHeight);
                 Rectangle aRect(aPoint, aSize);
                 ImplDrawBack(rRenderContext, aRect, pSet->mpWallpaper, pSet->mpBitmap);
             }
@@ -1022,8 +1022,8 @@ void SplitWindow::ImplDrawBack(vcl::RenderContext& rRenderContext, ImplSplitSet*
 
     for (i = 0; i < nItems; i++)
     {
-        if (pItems[i]->mpSet)
-            ImplDrawBack(rRenderContext, pItems[i]->mpSet);
+        if (rItems[i]->mpSet)
+            ImplDrawBack(rRenderContext, rItems[i]->mpSet);
     }
 }
 
@@ -1037,21 +1037,21 @@ static void ImplDrawSplit(vcl::RenderContext& rRenderContext, ImplSplitSet* pSet
     long       nPos;
     long       nTop;
     long       nBottom;
-    ImplSplitItems& pItems = pSet->mpItems;
+    ImplSplitItems& rItems = pSet->mpItems;
     const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
 
     for (i = 0; i < nItems-1; i++)
     {
-        if (pItems[i]->mnSplitSize)
+        if (rItems[i]->mnSplitSize)
         {
-            nPos = pItems[i]->mnSplitPos;
+            nPos = rItems[i]->mnSplitPos;
 
-            long nItemSplitSize = pItems[i]->mnSplitSize;
+            long nItemSplitSize = rItems[i]->mnSplitSize;
             long nSplitSize = pSet->mnSplitSize;
             if (bRows)
             {
-                nTop    = pItems[i]->mnLeft;
-                nBottom = pItems[i]->mnLeft+pItems[i]->mnWidth-1;
+                nTop    = rItems[i]->mnLeft;
+                nBottom = rItems[i]->mnLeft+rItems[i]->mnWidth-1;
 
                 if (bFlat)
                     nPos--;
@@ -1082,8 +1082,8 @@ static void ImplDrawSplit(vcl::RenderContext& rRenderContext, ImplSplitSet* pSet
             }
             else
             {
-                nTop    = pItems[i]->mnTop;
-                nBottom = pItems[i]->mnTop+pSet->mpItems[i]->mnHeight-1;
+                nTop    = rItems[i]->mnTop;
+                nBottom = rItems[i]->mnTop+pSet->mpItems[i]->mnHeight-1;
 
                 if (bFlat)
                     nPos--;
@@ -1116,9 +1116,9 @@ static void ImplDrawSplit(vcl::RenderContext& rRenderContext, ImplSplitSet* pSet
 
     for (i = 0; i < nItems; i++)
     {
-        if (pItems[i]->mpSet && pItems[i]->mnWidth && pItems[i]->mnHeight)
+        if (rItems[i]->mpSet && rItems[i]->mnWidth && rItems[i]->mnHeight)
         {
-            ImplDrawSplit(rRenderContext, pItems[i]->mpSet, !(pItems[i]->mnBits & SplitWindowItemFlags::ColSet), bFlat);
+            ImplDrawSplit(rRenderContext, rItems[i]->mpSet, !(rItems[i]->mnBits & SplitWindowItemFlags::ColSet), bFlat);
         }
     }
 }
@@ -1138,7 +1138,7 @@ sal_uInt16 SplitWindow::ImplTestSplit( ImplSplitSet* pSet, const Point& rPos,
     long            nPos;
     long            nTop;
     long            nBottom;
-    ImplSplitItems& pItems = pSet->mpItems;
+    ImplSplitItems& rItems = pSet->mpItems;
 
     if ( bRows )
     {
@@ -1153,24 +1153,24 @@ sal_uInt16 SplitWindow::ImplTestSplit( ImplSplitSet* pSet, const Point& rPos,
 
     for ( i = 0; i < nItems-1; i++ )
     {
-        if ( pItems[i]->mnSplitSize )
+        if ( rItems[i]->mnSplitSize )
         {
             if ( bRows )
             {
-                nTop    = pItems[i]->mnLeft;
-                nBottom = pItems[i]->mnLeft+pItems[i]->mnWidth-1;
+                nTop    = rItems[i]->mnLeft;
+                nBottom = rItems[i]->mnLeft+rItems[i]->mnWidth-1;
             }
             else
             {
-                nTop    = pItems[i]->mnTop;
-                nBottom = pItems[i]->mnTop+pItems[i]->mnHeight-1;
+                nTop    = rItems[i]->mnTop;
+                nBottom = rItems[i]->mnTop+rItems[i]->mnHeight-1;
             }
-            nPos = pItems[i]->mnSplitPos;
+            nPos = rItems[i]->mnSplitPos;
 
             if ( (nMPos1 >= nTop) && (nMPos1 <= nBottom) &&
-                 (nMPos2 >= nPos) && (nMPos2 <= nPos+pItems[i]->mnSplitSize) )
+                 (nMPos2 >= nPos) && (nMPos2 <= nPos+rItems[i]->mnSplitSize) )
             {
-                if ( !pItems[i]->mbFixed && !pItems[i+1]->mbFixed )
+                if ( !rItems[i]->mbFixed && !rItems[i+1]->mbFixed )
                 {
                     rMouseOff = nMPos2-nPos;
                     *ppFoundSet = pSet;
@@ -1188,11 +1188,11 @@ sal_uInt16 SplitWindow::ImplTestSplit( ImplSplitSet* pSet, const Point& rPos,
 
     for ( i = 0; i < nItems; i++ )
     {
-        if ( pItems[i]->mpSet )
+        if ( rItems[i]->mpSet )
         {
-            nSplitTest = ImplTestSplit( pItems[i]->mpSet, rPos,
+            nSplitTest = ImplTestSplit( rItems[i]->mpSet, rPos,
                                        rMouseOff, ppFoundSet, rFoundPos,
-                                       !(pItems[i]->mnBits & SplitWindowItemFlags::ColSet) );
+                                       !(rItems[i]->mnBits & SplitWindowItemFlags::ColSet) );
             if ( nSplitTest )
                 return nSplitTest;
         }
@@ -2175,13 +2175,13 @@ void SplitWindow::ImplStartSplit( const MouseEvent& rMEvt )
         }
         else
         {
-            ImplSplitItems&  pItems = mpSplitSet->mpItems;
+            ImplSplitItems&  rItems = mpSplitSet->mpItems;
             sal_uInt16       nItems = mpSplitSet->mpItems.size();
             mpLastSizes = new long[nItems*2];
             for ( sal_uInt16 i = 0; i < nItems; i++ )
             {
-                mpLastSizes[i*2]   = pItems[i]->mnSize;
-                mpLastSizes[i*2+1] = pItems[i]->mnPixSize;
+                mpLastSizes[i*2]   = rItems[i]->mnSize;
+                mpLastSizes[i*2+1] = rItems[i]->mnPixSize;
             }
         }
         mnMStartPos = mnMSplitPos;
@@ -2416,12 +2416,12 @@ void SplitWindow::Tracking( const TrackingEvent& rTEvt )
             {
                 if ( rTEvt.IsTrackingCanceled() )
                 {
-                    ImplSplitItems& pItems = mpSplitSet->mpItems;
-                    size_t          nItems = pItems.size();
+                    ImplSplitItems& rItems = mpSplitSet->mpItems;
+                    size_t          nItems = rItems.size();
                     for ( size_t i = 0; i < nItems; i++ )
                     {
-                        pItems[i]->mnSize     = mpLastSizes[i*2];
-                        pItems[i]->mnPixSize  = mpLastSizes[i*2+1];
+                        rItems[i]->mnSize     = mpLastSizes[i*2];
+                        rItems[i]->mnPixSize  = mpLastSizes[i*2+1];
                     }
                     ImplUpdate();
                     Split();
@@ -2782,19 +2782,19 @@ void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
         return;
 
     size_t           nItems = pSet->mpItems.size();
-    ImplSplitItems&  pItems = pSet->mpItems;
+    ImplSplitItems&  rItems = pSet->mpItems;
 
     // When there is an explicit minimum or maximum size then move nNewSize
     // into that range (when it is not yet already in it.)
-    nNewSize = ValidateSize(nNewSize, pItems[nPos]);
+    nNewSize = ValidateSize(nNewSize, rItems[nPos]);
 
     if ( mbCalc )
     {
-        pItems[nPos]->mnSize = nNewSize;
+        rItems[nPos]->mnSize = nNewSize;
         return;
     }
 
-    long nDelta = nNewSize-pItems[nPos]->mnPixSize;
+    long nDelta = nNewSize-rItems[nPos]->mnPixSize;
     if ( !nDelta )
         return;
 
@@ -2803,7 +2803,7 @@ void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
     sal_uInt16 nMax = nItems;
     for (size_t i = 0; i < nItems; ++i)
     {
-        if ( pItems[i]->mbFixed )
+        if ( rItems[i]->mbFixed )
         {
             if ( i < nPos )
                 nMin = i+1;
@@ -2867,7 +2867,7 @@ void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
                     {
                         if ( nTempDelta )
                         {
-                            pItems[n]->mnPixSize++;
+                            rItems[n]->mnPixSize++;
                             nTempDelta++;
                         }
                         n++;
@@ -2877,7 +2877,7 @@ void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
                 while ( nTempDelta );
             }
             else
-                pItems[nPos+1]->mnPixSize -= nDelta;
+                rItems[nPos+1]->mnPixSize -= nDelta;
         }
 
         if ( bSmall )
@@ -2889,9 +2889,9 @@ void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
                     n = nPos+1;
                     do
                     {
-                        if ( nDelta && pItems[n-1]->mnPixSize )
+                        if ( nDelta && rItems[n-1]->mnPixSize )
                         {
-                            pItems[n-1]->mnPixSize--;
+                            rItems[n-1]->mnPixSize--;
                             nDelta++;
                         }
 
@@ -2906,14 +2906,14 @@ void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
                 n = nPos+1;
                 do
                 {
-                    if ( pItems[n-1]->mnPixSize+nDelta < 0 )
+                    if ( rItems[n-1]->mnPixSize+nDelta < 0 )
                     {
-                        nDelta += pItems[n-1]->mnPixSize;
-                        pItems[n-1]->mnPixSize = 0;
+                        nDelta += rItems[n-1]->mnPixSize;
+                        rItems[n-1]->mnPixSize = 0;
                     }
                     else
                     {
-                        pItems[n-1]->mnPixSize += nDelta;
+                        rItems[n-1]->mnPixSize += nDelta;
                         break;
                     }
                     n--;
@@ -2936,7 +2936,7 @@ void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
                     {
                         if ( nTempDelta )
                         {
-                            pItems[n-1]->mnPixSize++;
+                            rItems[n-1]->mnPixSize++;
                             nTempDelta--;
                         }
                         n--;
@@ -2946,7 +2946,7 @@ void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
                 while ( nTempDelta );
             }
             else
-                pItems[nPos]->mnPixSize += nDelta;
+                rItems[nPos]->mnPixSize += nDelta;
         }
 
         if ( bSmall )
@@ -2958,9 +2958,9 @@ void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
                     n = nPos+1;
                     do
                     {
-                        if ( nDelta && pItems[n]->mnPixSize )
+                        if ( nDelta && rItems[n]->mnPixSize )
                         {
-                            pItems[n]->mnPixSize--;
+                            rItems[n]->mnPixSize--;
                             nDelta--;
                         }
 
@@ -2975,14 +2975,14 @@ void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
                 n = nPos+1;
                 do
                 {
-                    if ( pItems[n]->mnPixSize-nDelta < 0 )
+                    if ( rItems[n]->mnPixSize-nDelta < 0 )
                     {
-                        nDelta -= pItems[n]->mnPixSize;
-                        pItems[n]->mnPixSize = 0;
+                        nDelta -= rItems[n]->mnPixSize;
+                        rItems[n]->mnPixSize = 0;
                     }
                     else
                     {
-                        pItems[n]->mnPixSize -= nDelta;
+                        rItems[n]->mnPixSize -= nDelta;
                         break;
                     }
                     n++;
@@ -2993,7 +2993,7 @@ void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
     }
 
     // update original sizes
-    ImplCalcLogSize( pItems, nItems );
+    ImplCalcLogSize( rItems, nItems );
 
     ImplUpdate();
 }
@@ -3048,35 +3048,35 @@ long SplitWindow::GetItemSize( sal_uInt16 nId, SplitWindowItemFlags nBits ) cons
             SplitWindowItemFlags nTempBits;
             sal_uInt16              i;
             nItems = pSet->mpItems.size();
-            ImplSplitItems& pItems = pSet->mpItems;
+            ImplSplitItems& rItems = pSet->mpItems;
             for ( i = 0; i < nItems; i++ )
             {
                 if ( i == nPos )
                     nTempBits = nBits;
                 else
-                    nTempBits = pItems[i]->mnBits;
+                    nTempBits = rItems[i]->mnBits;
                 if ( nTempBits & SplitWindowItemFlags::RelativeSize )
-                    nRelSize += pItems[i]->mnPixSize;
+                    nRelSize += rItems[i]->mnPixSize;
                 else if ( nTempBits & SplitWindowItemFlags::PercentSize )
-                    nPerSize += pItems[i]->mnPixSize;
+                    nPerSize += rItems[i]->mnPixSize;
             }
             nPerSize += nRelSize;
             if ( nBits & SplitWindowItemFlags::RelativeSize )
             {
                 if ( nRelSize )
-                    return (pItems[nPos]->mnPixSize+(nRelSize/2))/nRelSize;
+                    return (rItems[nPos]->mnPixSize+(nRelSize/2))/nRelSize;
                 else
                     return 1;
             }
             else if ( nBits & SplitWindowItemFlags::PercentSize )
             {
                 if ( nPerSize )
-                    return (pItems[nPos]->mnPixSize*100)/nPerSize;
+                    return (rItems[nPos]->mnPixSize*100)/nPerSize;
                 else
                     return 1;
             }
             else
-                return pItems[nPos]->mnPixSize;
+                return rItems[nPos]->mnPixSize;
         }
     }
     else