make conversions between BitmapColor and sal_uInt8 explicit

Implicit conversions are a dangerous cause of confusion as seen
in http://markmail.org/thread/a4copx2di7cxeowg and require tricky
rewrites to work around them, this change cleans them up and
disables them for all code outside of the immutable binfilter.

11 files changed, 105 insertions, 112 deletions

diff --git a/vcl/source/gdi/bitmap.cxx b/vcl/source/gdi/bitmap.cxx
index d7ae4f09aca3..409cf5cf2828 100644
--- a/vcl/source/gdi/bitmap.cxx
+++ b/vcl/source/gdi/bitmap.cxx
@@ -1039,7 +1039,7 @@ sal_Bool Bitmap::CopyPixel( const Rectangle& rRectDst,
 
                             for( long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
                                 for( long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
-                                    pWriteAcc->SetPixel( nDstY, nDstX, pMap[ pReadAcc->GetPixel( nSrcY, nSrcX ).GetIndex() ] );
+                                    pWriteAcc->SetPixelIndex( nDstY, nDstX, pMap[ pReadAcc->GetPixelIndex( nSrcY, nSrcX ) ] );
 
                             delete[] pMap;
                         }
@@ -1047,7 +1047,7 @@ sal_Bool Bitmap::CopyPixel( const Rectangle& rRectDst,
                         {
                             for( long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
                                 for( long nSrcX = aRectSrc.Left(), nDstX = aRectDst.Left(); nSrcX < nSrcEndX; nSrcX++, nDstX++ )
-                                    pWriteAcc->SetPixel( nDstY, nDstX, pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nSrcY, nSrcX ) ) );
+                                    pWriteAcc->SetPixel( nDstY, nDstX, pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nSrcY, nSrcX ) ) );
                         }
                         else
                             for( long nSrcY = aRectSrc.Top(); nSrcY < nSrcEndY; nSrcY++, nDstY++ )
@@ -1313,7 +1313,7 @@ Bitmap Bitmap::CreateMask( const Color& rTransColor, sal_uLong nTol ) const
                     {
                         for( long nX = 0L; nX < nWidth; nX++ )
                         {
-                            aCol = pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nY, nX ) );
+                            aCol = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nX ) );
                             nR = aCol.GetRed();
                             nG = aCol.GetGreen();
                             nB = aCol.GetBlue();
@@ -1444,16 +1444,14 @@ sal_Bool Bitmap::Replace( const Bitmap& rMask, const Color& rReplaceColor )
             const sal_uInt16 nActColors = pAcc->GetPaletteEntryCount();
             const sal_uInt16 nMaxColors = 1 << pAcc->GetBitCount();
 
-            // erst einmal naechste Farbe nehmen
+            // default to the nearest color
             aReplace = pAcc->GetBestMatchingColor( rReplaceColor );
 
-            // falls Palettenbild, und die zu setzende Farbe ist nicht
-            // in der Palette, suchen wir nach freien Eintraegen (teuer)
-            if( pAcc->GetPaletteColor( (sal_uInt8) aReplace ) != BitmapColor( rReplaceColor ) )
+            // for paletted images without a matching palette entry
+            // look for an unused palette entry (NOTE: expensive!)
+            if( pAcc->GetPaletteColor( aReplace.GetIndex() ) != BitmapColor( rReplaceColor ) )
             {
-                // erst einmal nachsehen, ob wir unsere ReplaceColor
-                // nicht auf einen freien Platz am Ende der Palette
-                // setzen koennen
+                // if the palette has empty entries use the last one
                 if( nActColors < nMaxColors )
                 {
                     pAcc->SetPaletteEntryCount( nActColors + 1 );
@@ -1469,7 +1467,7 @@ sal_Bool Bitmap::Replace( const Bitmap& rMask, const Color& rReplaceColor )
 
                     for( long nY = 0L; nY < nHeight; nY++ )
                         for( long nX = 0L; nX < nWidth; nX++ )
-                            pFlags[ (sal_uInt8) pAcc->GetPixel( nY, nX ) ] = sal_True;
+                            pFlags[ pAcc->GetPixelIndex( nY, nX ) ] = sal_True;
 
                     for( sal_uInt16 i = 0UL; i < nMaxColors; i++ )
                     {
@@ -1523,7 +1521,7 @@ sal_Bool Bitmap::Replace( const AlphaMask& rAlpha, const Color& rMergeColor )
             for( long nX = 0L; nX < nWidth; nX++ )
             {
                 aCol = pAcc->GetColor( nY, nX );
-                pNewAcc->SetPixel( nY, nX, aCol.Merge( rMergeColor, 255 - (sal_uInt8) pAlphaAcc->GetPixel( nY, nX ) ) );
+                pNewAcc->SetPixel( nY, nX, aCol.Merge( rMergeColor, 255 - pAlphaAcc->GetPixelIndex( nY, nX ) ) );
             }
         }
 
@@ -1935,7 +1933,7 @@ sal_Bool Bitmap::Blend( const AlphaMask& rAlpha, const Color& rBackgroundColor )
             for( long nX = 0L; nX < nWidth; ++nX )
                 pAcc->SetPixel( nY, nX,
                                 pAcc->GetPixel( nY, nX ).Merge( rBackgroundColor,
-                                                                255 - pAlphaAcc->GetPixel( nY, nX ) ) );
+                                                                255 - pAlphaAcc->GetPixelIndex( nY, nX ) ) );
 
         bRet = sal_True;
     }
diff --git a/vcl/source/gdi/bitmap2.cxx b/vcl/source/gdi/bitmap2.cxx
index 680d8a888eda..5992dd62cf0b 100644
--- a/vcl/source/gdi/bitmap2.cxx
+++ b/vcl/source/gdi/bitmap2.cxx
@@ -531,7 +531,7 @@ sal_Bool Bitmap::ImplReadDIBBits( SvStream& rIStm, DIBInfoHeader& rHeader, Bitma
                                 cTmp = *pTmp++;
                             }
 
-                            rAcc.SetPixel( nY, nX, sal::static_int_cast<sal_uInt8>(( cTmp >> --nShift ) & 1) );
+                            rAcc.SetPixelIndex( nY, nX, (cTmp >> --nShift) & 1);
                         }
                     }
                 }
@@ -555,7 +555,7 @@ sal_Bool Bitmap::ImplReadDIBBits( SvStream& rIStm, DIBInfoHeader& rHeader, Bitma
                                 cTmp = *pTmp++;
                             }
 
-                            rAcc.SetPixel( nY, nX, sal::static_int_cast<sal_uInt8>(( cTmp >> ( --nShift << 2UL ) ) & 0x0f) );
+                            rAcc.SetPixelIndex( nY, nX, (cTmp >> ( --nShift << 2UL ) ) & 0x0f);
                         }
                     }
                 }
@@ -570,7 +570,7 @@ sal_Bool Bitmap::ImplReadDIBBits( SvStream& rIStm, DIBInfoHeader& rHeader, Bitma
                         rIStm.Read( pTmp = pBuf, nAlignedWidth );
 
                         for( long nX = 0L; nX < nWidth; nX++ )
-                            rAcc.SetPixel( nY, nX, *pTmp++ );
+                            rAcc.SetPixelIndex( nY, nX, *pTmp++ );
                     }
                 }
                 break;
@@ -970,7 +970,7 @@ sal_Bool Bitmap::ImplWriteDIBBits( SvStream& rOStm, BitmapReadAccess& rAcc,
                                 cTmp = 0;
                             }
 
-                            cTmp |= ( (sal_uInt8) rAcc.GetPixel( nY, nX ) << --nShift );
+                            cTmp |= rAcc.GetPixelIndex( nY, nX ) << --nShift;
                         }
 
                         *pTmp = cTmp;
@@ -995,7 +995,7 @@ sal_Bool Bitmap::ImplWriteDIBBits( SvStream& rOStm, BitmapReadAccess& rAcc,
                                 cTmp = 0;
                             }
 
-                            cTmp |= ( (sal_uInt8) rAcc.GetPixel( nY, nX ) << ( --nShift << 2L ) );
+                            cTmp |= rAcc.GetPixelIndex( nY, nX ) << ( --nShift << 2L );
                         }
                         *pTmp = cTmp;
                         rOStm.Write( pBuf, nAlignedWidth );
@@ -1010,7 +1010,7 @@ sal_Bool Bitmap::ImplWriteDIBBits( SvStream& rOStm, BitmapReadAccess& rAcc,
                         pTmp = pBuf;
 
                         for( long nX = 0L; nX < nWidth; nX++ )
-                            *pTmp++ = rAcc.GetPixel( nY, nX );
+                            *pTmp++ = rAcc.GetPixelIndex( nY, nX );
 
                         rOStm.Write( pBuf, nAlignedWidth );
                     }
@@ -1082,16 +1082,16 @@ void Bitmap::ImplDecodeRLE( sal_uInt8* pBuffer, DIBInfoHeader& rHeader,
                         cTmp = *pRLE++;
 
                         if( nX < nWidth )
-                            rAcc.SetPixel( nY, nX++, cTmp >> 4 );
+                            rAcc.SetPixelIndex( nY, nX++, cTmp >> 4 );
 
                         if( nX < nWidth )
-                            rAcc.SetPixel( nY, nX++, cTmp & 0x0f );
+                            rAcc.SetPixelIndex( nY, nX++, cTmp & 0x0f );
                     }
 
                     if( nRunByte & 1 )
                     {
                         if( nX < nWidth )
-                            rAcc.SetPixel( nY, nX++, *pRLE >> 4 );
+                            rAcc.SetPixelIndex( nY, nX++, *pRLE >> 4 );
 
                         pRLE++;
                     }
@@ -1104,7 +1104,7 @@ void Bitmap::ImplDecodeRLE( sal_uInt8* pBuffer, DIBInfoHeader& rHeader,
                     for( sal_uLong i = 0UL; i < nRunByte; i++ )
                     {
                         if( nX < nWidth )
-                            rAcc.SetPixel( nY, nX++, *pRLE );
+                            rAcc.SetPixelIndex( nY, nX++, *pRLE );
 
                         pRLE++;
                     }
@@ -1137,19 +1137,19 @@ void Bitmap::ImplDecodeRLE( sal_uInt8* pBuffer, DIBInfoHeader& rHeader,
                 for( sal_uLong i = 0UL; i < nRunByte; i++ )
                 {
                     if( nX < nWidth )
-                        rAcc.SetPixel( nY, nX++, cTmp >> 4 );
+                        rAcc.SetPixelIndex( nY, nX++, cTmp >> 4 );
 
                     if( nX < nWidth )
-                        rAcc.SetPixel( nY, nX++, cTmp & 0x0f );
+                        rAcc.SetPixelIndex( nY, nX++, cTmp & 0x0f );
                 }
 
                 if( ( nCountByte & 1 ) && ( nX < nWidth ) )
-                    rAcc.SetPixel( nY, nX++, cTmp >> 4 );
+                    rAcc.SetPixelIndex( nY, nX++, cTmp >> 4 );
             }
             else
             {
                 for( sal_uLong i = 0UL; ( i < nCountByte ) && ( nX < nWidth ); i++ )
-                    rAcc.SetPixel( nY, nX++, cTmp );
+                    rAcc.SetPixelIndex( nY, nX++, cTmp );
             }
         }
     }
@@ -1180,9 +1180,10 @@ sal_Bool Bitmap::ImplWriteRLE( SvStream& rOStm, BitmapReadAccess& rAcc, sal_Bool
         while( nX < nWidth )
         {
             nCount = 1L;
-            cPix = rAcc.GetPixel( nY, nX++ );
+            cPix = rAcc.GetPixelIndex( nY, nX++ );
 
-            while( ( nX < nWidth ) && ( nCount < 255L ) && ( cPix == rAcc.GetPixel( nY, nX ) ) )
+            while( ( nX < nWidth ) && ( nCount < 255L )
+                && ( cPix == rAcc.GetPixelIndex( nY, nX ) ) )
             {
                 nX++;
                 nCount++;
@@ -1200,7 +1201,8 @@ sal_Bool Bitmap::ImplWriteRLE( SvStream& rOStm, BitmapReadAccess& rAcc, sal_Bool
                 nSaveIndex = nX - 1UL;
                 bFound = sal_False;
 
-                while( ( nX < nWidth ) && ( nCount < 256L ) && ( cPix = rAcc.GetPixel( nY, nX ) ) != cLast )
+                while( ( nX < nWidth ) && ( nCount < 256L )
+                    && ( cPix = rAcc.GetPixelIndex( nY, nX ) ) != cLast )
                 {
                     nX++; nCount++;
                     cLast = cPix;
@@ -1219,10 +1221,10 @@ sal_Bool Bitmap::ImplWriteRLE( SvStream& rOStm, BitmapReadAccess& rAcc, sal_Bool
                     {
                         for ( sal_uLong i = 0; i < nCount; i++, pTmp++ )
                         {
-                            *pTmp = (sal_uInt8) rAcc.GetPixel( nY, nSaveIndex++ ) << 4;
+                            *pTmp = rAcc.GetPixelIndex( nY, nSaveIndex++ ) << 4;
 
                             if ( ++i < nCount )
-                                *pTmp |= rAcc.GetPixel( nY, nSaveIndex++ );
+                                *pTmp |= rAcc.GetPixelIndex( nY, nSaveIndex++ );
                         }
 
                         nCount = ( nCount + 1 ) >> 1;
@@ -1230,7 +1232,7 @@ sal_Bool Bitmap::ImplWriteRLE( SvStream& rOStm, BitmapReadAccess& rAcc, sal_Bool
                     else
                     {
                         for( sal_uLong i = 0UL; i < nCount; i++ )
-                            *pTmp++ = rAcc.GetPixel( nY, nSaveIndex++ );
+                            *pTmp++ = rAcc.GetPixelIndex( nY, nSaveIndex++ );
                     }
 
                     if ( nCount & 1 )
@@ -1244,12 +1246,12 @@ sal_Bool Bitmap::ImplWriteRLE( SvStream& rOStm, BitmapReadAccess& rAcc, sal_Bool
                 else
                 {
                     *pTmp++ = 1;
-                    *pTmp++ = (sal_uInt8) rAcc.GetPixel( nY, nSaveIndex ) << ( bRLE4 ? 4 : 0 );
+                    *pTmp++ = rAcc.GetPixelIndex( nY, nSaveIndex ) << (bRLE4 ? 4 : 0);
 
                     if ( nCount == 3 )
                     {
                         *pTmp++ = 1;
-                        *pTmp++ = (sal_uInt8) rAcc.GetPixel( nY, ++nSaveIndex ) << ( bRLE4 ? 4 : 0 );
+                        *pTmp++ = rAcc.GetPixelIndex( nY, ++nSaveIndex ) << ( bRLE4 ? 4 : 0 );
                         nBufCount += 4;
                     }
                     else
diff --git a/vcl/source/gdi/bitmap3.cxx b/vcl/source/gdi/bitmap3.cxx
index 34dc80ac18cd..2f91cb5e073f 100644
--- a/vcl/source/gdi/bitmap3.cxx
+++ b/vcl/source/gdi/bitmap3.cxx
@@ -383,7 +383,8 @@ sal_Bool Bitmap::ImplMakeMono( sal_uInt8 cThreshold )
                 {
                     for( long nX = 0L; nX < nWidth; nX++ )
                     {
-                        if( pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nY, nX ) ).GetLuminance() >=
+                        const sal_uInt8 cIndex = pReadAcc->GetPixelIndex( nY, nX );
+                        if( pReadAcc->GetPaletteColor( cIndex ).GetLuminance() >=
                             cThreshold )
                         {
                             pWriteAcc->SetPixel( nY, nX, aWhite );
@@ -459,7 +460,8 @@ sal_Bool Bitmap::ImplMakeMonoDither()
                 {
                     for( long nX = 0L, nModY = nY % 16; nX < nWidth; nX++ )
                     {
-                        if( pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nY, nX ) ).GetLuminance() >
+                        const sal_uInt8 cIndex = pReadAcc->GetPixelIndex( nY, nX );
+                        if( pReadAcc->GetPaletteColor( cIndex ).GetLuminance() >
                             pDitherMatrix[ nModY ][ nX % 16 ] )
                         {
                             pWriteAcc->SetPixel( nY, nX, aWhite );
@@ -541,9 +543,9 @@ sal_Bool Bitmap::ImplMakeGreyscales( sal_uInt16 nGreys )
                     {
                         for( long nX = 0L; nX < nWidth; nX++ )
                         {
-                            pWriteAcc->SetPixel( nY, nX,
-                                (sal_uInt8) ( pReadAcc->GetPaletteColor(
-                                    pReadAcc->GetPixel( nY, nX ) ).GetLuminance() >> nShift ) );
+                            const sal_uInt8 cIndex = pReadAcc->GetPixelIndex( nY, nX );
+                            pWriteAcc->SetPixelIndex( nY, nX,
+                                (pReadAcc->GetPaletteColor( cIndex ).GetLuminance() >> nShift) );
                         }
                     }
                 }
@@ -591,7 +593,7 @@ sal_Bool Bitmap::ImplMakeGreyscales( sal_uInt16 nGreys )
                 {
                     for( long nY = 0L; nY < nHeight; nY++ )
                         for( long nX = 0L; nX < nWidth; nX++ )
-                            pWriteAcc->SetPixel( nY, nX, sal::static_int_cast<sal_uInt8>(( pReadAcc->GetPixel( nY, nX ) ).GetLuminance() >> nShift) );
+                            pWriteAcc->SetPixelIndex( nY, nX, (pReadAcc->GetPixel( nY, nX ) ).GetLuminance() >> nShift );
                 }
 
                 aNewBmp.ReleaseAccess( pWriteAcc );
@@ -666,7 +668,7 @@ sal_Bool Bitmap::ImplConvertUp( sal_uInt16 nBitCount, Color* pExtColor )
                 {
                     for( long nY = 0L; nY < nHeight; nY++ )
                         for( long nX = 0L; nX < nWidth; nX++ )
-                            pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nY, nX ) ) );
+                            pWriteAcc->SetPixel( nY, nX, pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nX ) ) );
                 }
                 else
                 {
@@ -752,7 +754,7 @@ sal_Bool Bitmap::ImplConvertDown( sal_uInt16 nBitCount, Color* pExtColor )
                 for( nX = 0L, pQLine2 = !nY ? pErrQuad1 : pErrQuad2; nX < nWidth; nX++ )
                 {
                     if( pReadAcc->HasPalette() )
-                        pQLine2[ nX ] = pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nYTmp, nX ) );
+                        pQLine2[ nX ] = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nYTmp, nX ) );
                     else
                         pQLine2[ nX ] = pReadAcc->GetPixel( nYTmp, nX );
                 }
@@ -760,9 +762,9 @@ sal_Bool Bitmap::ImplConvertDown( sal_uInt16 nBitCount, Color* pExtColor )
 
             for( nY = 0L; nY < nHeight; nY++, nYTmp++ )
             {
-                // erstes ZeilenPixel
+                // first pixel in the line
                 cIndex = (sal_uInt8) aColorMap.GetBestPaletteIndex( pQLine1[ 0 ].ImplGetColor() );
-                pWriteAcc->SetPixel( nY, 0, cIndex );
+                pWriteAcc->SetPixelIndex( nY, 0, cIndex );
 
                 for( nX = 1L; nX < nWidth1; nX++ )
                 {
@@ -772,14 +774,14 @@ sal_Bool Bitmap::ImplConvertDown( sal_uInt16 nBitCount, Color* pExtColor )
                     pQLine2[ nX-- ].ImplAddColorError1( aErrQuad );
                     pQLine2[ nX-- ].ImplAddColorError5( aErrQuad );
                     pQLine2[ nX++ ].ImplAddColorError3( aErrQuad );
-                    pWriteAcc->SetPixel( nY, nX, cIndex );
+                    pWriteAcc->SetPixelIndex( nY, nX, cIndex );
                 }
 
                 // letztes ZeilenPixel
                 if( nX < nWidth )
                 {
                     cIndex = (sal_uInt8) aColorMap.GetBestPaletteIndex( pQLine1[ nWidth1 ].ImplGetColor() );
-                    pWriteAcc->SetPixel( nY, nX, cIndex );
+                    pWriteAcc->SetPixelIndex( nY, nX, cIndex );
                 }
 
                 // Zeilenpuffer neu fuellen/kopieren
@@ -791,7 +793,7 @@ sal_Bool Bitmap::ImplConvertDown( sal_uInt16 nBitCount, Color* pExtColor )
                     for( nX = 0L; nX < nWidth; nX++ )
                     {
                         if( pReadAcc->HasPalette() )
-                                pQLine2[ nX ] = pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nYTmp, nX ) );
+                            pQLine2[ nX ] = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nYTmp, nX ) );
                         else
                             pQLine2[ nX ] = pReadAcc->GetPixel( nYTmp, nX );
                     }
@@ -1058,7 +1060,7 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca
                 {
                     if( 1 == nWidth )
                     {
-                        aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nY, 0 ) );
+                        aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, 0 ) );
 
                         for( nX = 0L; nX < nNewWidth; nX++ )
                             pWriteAcc->SetPixel( nY, nX, aCol0 );
@@ -1069,8 +1071,8 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca
                         {
                             nTemp = pLutInt[ nX ];
 
-                            aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nY, nTemp++ ) );
-                            aCol1 = pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nY, nTemp ) );
+                            aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nTemp++ ) );
+                            aCol1 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nTemp ) );
 
                             nTemp = pLutFrac[ nX ];
 
@@ -1162,7 +1164,7 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca
                     {
                         if( 1 == nHeight )
                         {
-                            aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixel( 0, nX ) );
+                            aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( 0, nX ) );
 
                             for( nY = 0L; nY < nNewHeight; nY++ )
                                 pWriteAcc->SetPixel( nY, nX, aCol0 );
@@ -1173,8 +1175,8 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca
                             {
                                 nTemp = pLutInt[ nY ];
 
-                                aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nTemp++, nX ) );
-                                aCol1 = pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nTemp, nX ) );
+                                aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nTemp++, nX ) );
+                                aCol1 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nTemp, nX ) );
 
                                 nTemp = pLutFrac[ nY ];
 
@@ -1287,7 +1289,7 @@ sal_Bool Bitmap::ImplDitherMatrix()
             {
                 for( sal_uLong nX = 0UL, nModY = ( nY & 0x0FUL ) << 4UL; nX < nWidth; nX++ )
                 {
-                    const BitmapColor   aCol( pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nY, nX ) ) );
+                    const BitmapColor   aCol( pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nX ) ) );
                     const sal_uLong         nD = nVCLDitherLut[ nModY + ( nX & 0x0FUL ) ];
                     const sal_uLong         nR = ( nVCLLut[ aCol.GetRed() ] + nD ) >> 16UL;
                     const sal_uLong         nG = ( nVCLLut[ aCol.GetGreen() ] + nD ) >> 16UL;
@@ -1375,7 +1377,7 @@ sal_Bool Bitmap::ImplDitherFloyd()
             {
                 for( nZ = 0; nZ < nWidth; nZ++ )
                 {
-                    aColor = pReadAcc->GetPaletteColor( pReadAcc->GetPixel( 0, nZ ) );
+                    aColor = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( 0, nZ ) );
 
                     *pTmp++ = (long) aColor.GetBlue() << 12;
                     *pTmp++ = (long) aColor.GetGreen() << 12;
@@ -1406,7 +1408,7 @@ sal_Bool Bitmap::ImplDitherFloyd()
                     {
                         for( nZ = 0; nZ < nWidth; nZ++ )
                         {
-                            aColor = pReadAcc->GetPaletteColor( pReadAcc->GetPixel( nY, nZ ) );
+                            aColor = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nZ ) );
 
                             *pTmp++ = (long) aColor.GetBlue() << 12;
                             *pTmp++ = (long) aColor.GetGreen() << 12;
@@ -1432,7 +1434,7 @@ sal_Bool Bitmap::ImplDitherFloyd()
                 CALC_TABLES7;
                 nX -= 5;
                 CALC_TABLES5;
-                pWriteAcc->SetPixel( nYAcc, 0, BitmapColor( (sal_uInt8) ( nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ] ) ) );
+                pWriteAcc->SetPixelIndex( nYAcc, 0, static_cast<sal_uInt8>(nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ]) );
 
                 // mittlere Pixel ueber Schleife
                 long nXAcc;
@@ -1443,7 +1445,7 @@ sal_Bool Bitmap::ImplDitherFloyd()
                     nX -= 8;
                     CALC_TABLES3;
                     CALC_TABLES5;
-                    pWriteAcc->SetPixel( nYAcc, nXAcc, BitmapColor( (sal_uInt8) ( nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ] ) ) );
+                    pWriteAcc->SetPixelIndex( nYAcc, nXAcc, static_cast<sal_uInt8>(nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ]) );
                 }
 
                 // letztes Pixel gesondert betrachten
@@ -1451,7 +1453,7 @@ sal_Bool Bitmap::ImplDitherFloyd()
                 nX -= 5;
                 CALC_TABLES3;
                 CALC_TABLES5;
-                pWriteAcc->SetPixel( nYAcc, nWidth1, BitmapColor( (sal_uInt8) ( nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ] ) ) );
+                pWriteAcc->SetPixelIndex( nYAcc, nWidth1, static_cast<sal_uInt8>(nVCLBLut[ nBC ] + nVCLGLut[nGC ] + nVCLRLut[nRC ]) );
             }
 
             delete[] p1;
@@ -1626,13 +1628,13 @@ sal_Bool Bitmap::ImplReduceSimple( sal_uInt16 nColorCount )
             {
                 for( long nY = 0L; nY < nHeight; nY++ )
                     for( long nX =0L; nX < nWidth; nX++ )
-                        pWAcc->SetPixel( nY, nX, (sal_uInt8) aOct.GetBestPaletteIndex( pRAcc->GetPaletteColor( pRAcc->GetPixel( nY, nX ) ) ) );
+                        pWAcc->SetPixelIndex( nY, nX, static_cast<sal_uInt8>(aOct.GetBestPaletteIndex( pRAcc->GetPaletteColor( pRAcc->GetPixelIndex( nY, nX ) ))) );
             }
             else
             {
                 for( long nY = 0L; nY < nHeight; nY++ )
                     for( long nX =0L; nX < nWidth; nX++ )
-                        pWAcc->SetPixel( nY, nX, (sal_uInt8) aOct.GetBestPaletteIndex( pRAcc->GetPixel( nY, nX ) ) );
+                        pWAcc->SetPixelIndex( nY, nX, static_cast<sal_uInt8>(aOct.GetBestPaletteIndex( pRAcc->GetPixel( nY, nX ) )) );
             }
 
             aNewBmp.ReleaseAccess( pWAcc );
@@ -1729,7 +1731,7 @@ sal_Bool Bitmap::ImplReducePopular( sal_uInt16 nColCount )
             {
                 for( nX = 0L; nX < nWidth; nX++ )
                 {
-                    const BitmapColor& rCol = pRAcc->GetPaletteColor( pRAcc->GetPixel( nY, nX ) );
+                    const BitmapColor& rCol = pRAcc->GetPaletteColor( pRAcc->GetPixelIndex( nY, nX ) );
                     pCountTable[ ( ( ( (sal_uInt32) rCol.GetRed() ) >> nRightShiftBits ) << nLeftShiftBits2 ) |
                                  ( ( ( (sal_uInt32) rCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) |
                                  ( ( (sal_uInt32) rCol.GetBlue() ) >> nRightShiftBits ) ].mnCount++;
@@ -1781,7 +1783,7 @@ sal_Bool Bitmap::ImplReducePopular( sal_uInt16 nColCount )
                 {
                     for( nX = 0L; nX < nWidth; nX++ )
                     {
-                        const BitmapColor& rCol = pRAcc->GetPaletteColor( pRAcc->GetPixel( nY, nX ) );
+                        const BitmapColor& rCol = pRAcc->GetPaletteColor( pRAcc->GetPixelIndex( nY, nX ) );
                         aDstCol.SetIndex( pIndexMap[ ( ( ( (sal_uInt32) rCol.GetRed() ) >> nRightShiftBits ) << nLeftShiftBits2 ) |
                                                      ( ( ( (sal_uInt32) rCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) |
                                                      ( ( (sal_uInt32) rCol.GetBlue() ) >> nRightShiftBits ) ] );
@@ -1867,7 +1869,7 @@ sal_Bool Bitmap::ImplReduceMedian( sal_uInt16 nColCount )
                 {
                     for( long nX = 0L; nX < nWidth; nX++ )
                     {
-                        const BitmapColor& rCol = pRAcc->GetPaletteColor( pRAcc->GetPixel( nY, nX ) );
+                        const BitmapColor& rCol = pRAcc->GetPaletteColor( pRAcc->GetPixelIndex( nY, nX ) );
                         pColBuf[ RGB15( rCol.GetRed() >> 3, rCol.GetGreen() >> 3, rCol.GetBlue() >> 3 ) ]++;
                     }
                 }
@@ -1894,7 +1896,7 @@ sal_Bool Bitmap::ImplReduceMedian( sal_uInt16 nColCount )
             pWAcc->SetPalette( aPal );
             for( long nY = 0L; nY < nHeight; nY++ )
                 for( long nX = 0L; nX < nWidth; nX++ )
-                    pWAcc->SetPixel( nY, nX, (sal_uInt8) aMap.GetBestPaletteIndex( pRAcc->GetColor( nY, nX ) ) );
+                    pWAcc->SetPixelIndex( nY, nX, static_cast<sal_uInt8>( aMap.GetBestPaletteIndex( pRAcc->GetColor( nY, nX ) )) );
 
             rtl_freeMemory( pColBuf );
             aNewBmp.ReleaseAccess( pWAcc );
diff --git a/vcl/source/gdi/bitmap4.cxx b/vcl/source/gdi/bitmap4.cxx
index cc922149d109..da2f23d1aa4b 100644
--- a/vcl/source/gdi/bitmap4.cxx
+++ b/vcl/source/gdi/bitmap4.cxx
@@ -856,7 +856,7 @@ sal_Bool Bitmap::ImplMosaic( const BmpFilterParam* pFilterParam, const Link* /*p
                         {
                             for( nX = nX1; nX <= nX2; nX++ )
                             {
-                                const BitmapColor& rCol = pReadAcc->GetPaletteColor( (sal_uInt8) pReadAcc->GetPixel( nY, nX ) );
+                                const BitmapColor& rCol = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nX ) );
                                 nSumR += rCol.GetRed();
                                 nSumG += rCol.GetGreen();
                                 nSumB += rCol.GetBlue();
diff --git a/vcl/source/gdi/bmpacc2.cxx b/vcl/source/gdi/bmpacc2.cxx
index dc5410bbadf9..45b5063eb25a 100644
--- a/vcl/source/gdi/bmpacc2.cxx
+++ b/vcl/source/gdi/bmpacc2.cxx
@@ -32,7 +32,7 @@
 
 IMPL_FORMAT_GETPIXEL_NOMASK( _1BIT_MSB_PAL )
 {
-    return( pScanline[ nX >> 3 ] & ( 1 << ( 7 - ( nX & 7 ) ) ) ? 1 : 0 );
+    return BitmapColor( pScanline[ nX >> 3 ] & ( 1 << ( 7 - ( nX & 7 ) ) ) ? 1 : 0 );
 }
 
 // ------------------------------------------------------------------
@@ -49,7 +49,7 @@ IMPL_FORMAT_SETPIXEL_NOMASK( _1BIT_MSB_PAL )
 
 IMPL_FORMAT_GETPIXEL_NOMASK( _1BIT_LSB_PAL )
 {
-    return( pScanline[ nX >> 3 ] & ( 1 << ( nX & 7 ) ) ? 1 : 0 );
+    return BitmapColor( pScanline[ nX >> 3 ] & ( 1 << ( nX & 7 ) ) ? 1 : 0 );
 }
 
 // ------------------------------------------------------------------
@@ -66,7 +66,7 @@ IMPL_FORMAT_SETPIXEL_NOMASK( _1BIT_LSB_PAL )
 
 IMPL_FORMAT_GETPIXEL_NOMASK( _4BIT_MSN_PAL )
 {
-    return( ( pScanline[ nX >> 1 ] >> ( nX & 1 ? 0 : 4 ) ) & 0x0f );
+    return BitmapColor( ( pScanline[ nX >> 1 ] >> ( nX & 1 ? 0 : 4 ) ) & 0x0f );
 }
 
 // ------------------------------------------------------------------
@@ -83,7 +83,7 @@ IMPL_FORMAT_SETPIXEL_NOMASK( _4BIT_MSN_PAL )
 
 IMPL_FORMAT_GETPIXEL_NOMASK( _4BIT_LSN_PAL )
 {
-    return( ( pScanline[ nX >> 1 ] >> ( nX & 1 ? 4 : 0 ) ) & 0x0f );
+    return BitmapColor( ( pScanline[ nX >> 1 ] >> ( nX & 1 ? 4 : 0 ) ) & 0x0f );
 }
 
 // ------------------------------------------------------------------
@@ -100,7 +100,7 @@ IMPL_FORMAT_SETPIXEL_NOMASK( _4BIT_LSN_PAL )
 
 IMPL_FORMAT_GETPIXEL_NOMASK( _8BIT_PAL )
 {
-    return pScanline[ nX ];
+    return BitmapColor( pScanline[ nX ] );
 }
 
 // ------------------------------------------------------------------
diff --git a/vcl/source/gdi/octree.cxx b/vcl/source/gdi/octree.cxx
index 6ce2f7fc0ca3..ef164a2d3503 100644
--- a/vcl/source/gdi/octree.cxx
+++ b/vcl/source/gdi/octree.cxx
@@ -130,7 +130,7 @@ void Octree::ImplCreateOctree()
             {
                 for( long nX = 0; nX < nWidth; nX++ )
                 {
-                    pColor = &(BitmapColor&) pAcc->GetPaletteColor( pAcc->GetPixel( nY, nX ) );
+                    pColor = &(BitmapColor&) pAcc->GetPaletteColor( pAcc->GetPixelIndex( nY, nX ) );
                     nLevel = 0L;
                     ImplAdd( &pTree );
 
diff --git a/vcl/source/gdi/outdev2.cxx b/vcl/source/gdi/outdev2.cxx
index d1b25b871f8e..9a90ae414fe6 100644
--- a/vcl/source/gdi/outdev2.cxx
+++ b/vcl/source/gdi/outdev2.cxx
@@ -1666,8 +1666,8 @@ Bitmap OutputDevice::ImplBlendWithAlpha( Bitmap              aBmp,
 
                     aSrcCol = pP->GetColor( nMapY, nMapX );
                     aDstCol = pB->GetColor( nY, nX );
-                    const sal_uInt8 nSrcOpaq = 255 - pA->GetPixel( nMapY, nMapX ).GetBlueOrIndex();
-                    const sal_uInt8 nDstOpaq  = 255 - pAlphaW->GetPixel( nY, nX ).GetBlueOrIndex();
+                    const sal_uInt8 nSrcOpaq = 255 - pA->GetPixelIndex( nMapY, nMapX );
+                    const sal_uInt8 nDstOpaq  = 255 - pAlphaW->GetPixelIndex( nY, nX );
 
                     aDstCol.SetRed( lcl_calcColor( aSrcCol.GetRed(), nSrcOpaq, aDstCol.GetRed() ) );
                     aDstCol.SetBlue( lcl_calcColor( aSrcCol.GetBlue(), nSrcOpaq, aDstCol.GetBlue() ) );
@@ -1711,8 +1711,8 @@ Bitmap OutputDevice::ImplBlendWithAlpha( Bitmap              aBmp,
 
                     aSrcCol = pP->GetColor( nMapY, nMapX );
                     aDstCol = pB->GetColor( nY, nX );
-                    const sal_uInt8 nSrcOpaq  = 255 - pA->GetPixel( nMapY, nMapX ).GetBlueOrIndex();
-                    const sal_uInt8 nDstOpaq  = 255 - pAlphaW->GetPixel( nY, nX ).GetBlueOrIndex();
+                    const sal_uInt8 nSrcOpaq  = 255 - pA->GetPixelIndex( nMapY, nMapX );
+                    const sal_uInt8 nDstOpaq  = 255 - pAlphaW->GetPixelIndex( nY, nX );
 
                     aDstCol.SetRed( lcl_calcColor( aSrcCol.GetRed(), nSrcOpaq, aDstCol.GetRed() ) );
                     aDstCol.SetBlue( lcl_calcColor( aSrcCol.GetBlue(), nSrcOpaq, aDstCol.GetBlue() ) );
@@ -1782,7 +1782,7 @@ Bitmap OutputDevice::ImplBlend( Bitmap              aBmp,
                     const sal_uLong nD = nVCLDitherLut[ nModY | ( nOutX & 0x0FL ) ];
 
                     aDstCol = pB->GetColor( nY, nX );
-                    aDstCol.Merge( pP->GetColor( nMapY, nMapX ), (sal_uInt8) pA->GetPixel( nMapY, nMapX ) );
+                    aDstCol.Merge( pP->GetColor( nMapY, nMapX ), pA->GetPixelIndex( nMapY, nMapX ) );
                     aIndex.SetIndex( (sal_uInt8) ( nVCLRLut[ ( nVCLLut[ aDstCol.GetRed() ] + nD ) >> 16UL ] +
                                               nVCLGLut[ ( nVCLLut[ aDstCol.GetGreen() ] + nD ) >> 16UL ] +
                                               nVCLBLut[ ( nVCLLut[ aDstCol.GetBlue() ] + nD ) >> 16UL ] ) );
diff --git a/vcl/source/gdi/pngread.cxx b/vcl/source/gdi/pngread.cxx
index 89e96799919f..3e798b5ea601 100644
--- a/vcl/source/gdi/pngread.cxx
+++ b/vcl/source/gdi/pngread.cxx
@@ -1485,7 +1485,7 @@ void PNGReaderImpl::ImplSetPixel( sal_uInt32 nY, sal_uInt32 nX, sal_uInt8 nPalIn
         return;
     nX >>= mnPreviewShift;
 
-    mpAcc->SetPixel( nY, nX, nPalIndex );
+    mpAcc->SetPixelIndex( nY, nX, nPalIndex );
 }
 
 // ------------------------------------------------------------------------
@@ -1515,8 +1515,8 @@ void PNGReaderImpl::ImplSetAlphaPixel( sal_uInt32 nY, sal_uInt32 nX,
         return;
     nX >>= mnPreviewShift;
 
-    mpAcc->SetPixel( nY, nX, nPalIndex );
-    mpMaskAcc->SetPixel( nY, nX, ~nAlpha );
+    mpAcc->SetPixelIndex( nY, nX, nPalIndex );
+    mpMaskAcc->SetPixelIndex( nY, nX, ~nAlpha );
 }
 
 // ------------------------------------------------------------------------
@@ -1530,7 +1530,7 @@ void PNGReaderImpl::ImplSetAlphaPixel( sal_uInt32 nY, sal_uInt32 nX,
     nX >>= mnPreviewShift;
 
     mpAcc->SetPixel( nY, nX, rBitmapColor );
-    mpMaskAcc->SetPixel( nY, nX, ~nAlpha );
+    mpMaskAcc->SetPixelIndex( nY, nX, ~nAlpha );
 }
 
 // ------------------------------------------------------------------------
diff --git a/vcl/source/gdi/pngwrite.cxx b/vcl/source/gdi/pngwrite.cxx
index fe10e4d4be01..459fcc2a2863 100644
--- a/vcl/source/gdi/pngwrite.cxx
+++ b/vcl/source/gdi/pngwrite.cxx
@@ -366,7 +366,7 @@ void PNGWriterImpl::ImplWritePalette()
 
 void PNGWriterImpl::ImplWriteTransparent ()
 {
-    const sal_uLong nTransIndex = mpAccess->GetBestMatchingColor( BMP_COL_TRANS );
+    const sal_uLong nTransIndex = mpAccess->GetBestPaletteIndex( BMP_COL_TRANS );
 
     ImplOpenChunk( PNGCHUNK_tRNS );
 
@@ -517,11 +517,11 @@ sal_uLong PNGWriterImpl::ImplGetFilter ( sal_uLong nY, sal_uLong nXStart, sal_uL
                     {
                         sal_uLong nShift = ( nXIndex & 7 ) ^ 7;
                         if ( nShift == 7)
-                            *pDest = (sal_uInt8)(mpAccess->GetPixel( nY, nX ) << nShift);
+                            *pDest = mpAccess->GetPixelIndex( nY, nX ) << nShift;
                         else if  ( nShift == 0 )
-                            *pDest++ |= (sal_uInt8) mpAccess->GetPixel( nY, nX ) << nShift;
+                            *pDest++ |= mpAccess->GetPixelIndex( nY, nX ) << nShift;
                         else
-                            *pDest |= (sal_uInt8) mpAccess->GetPixel( nY, nX ) << nShift;
+                            *pDest |= mpAccess->GetPixelIndex( nY, nX ) << nShift;
                     }
                     if ( ( nXIndex & 7 ) != 0 ) pDest++;    // byte is not completely used, so the
                 }                                           // bufferpointer is to correct
@@ -533,9 +533,9 @@ sal_uLong PNGWriterImpl::ImplGetFilter ( sal_uLong nY, sal_uLong nXStart, sal_uL
                     for ( nX = nXStart, nXIndex = 0; nX < mnWidth; nX+= nXAdd, nXIndex++ )
                     {
                         if( nXIndex & 1 )
-                            *pDest++ |= (sal_uInt8) mpAccess->GetPixel( nY, nX );
+                            *pDest++ |= mpAccess->GetPixelIndex( nY, nX );
                         else
-                            *pDest = (sal_uInt8) mpAccess->GetPixel( nY, nX ) << 4;
+                            *pDest = mpAccess->GetPixelIndex( nY, nX ) << 4;
                     }
                     if ( nXIndex & 1 ) pDest++;
                 }
@@ -544,7 +544,7 @@ sal_uLong PNGWriterImpl::ImplGetFilter ( sal_uLong nY, sal_uLong nXStart, sal_uL
                 case( 8 ):
                 {
                     for ( sal_uLong nX = nXStart; nX < mnWidth; nX+=nXAdd )
-                        *pDest++ = mpAccess->GetPixel( nY, nX );
+                        *pDest++ = mpAccess->GetPixelIndex( nY, nX );
                 }
                 break;
 
@@ -565,7 +565,7 @@ sal_uLong PNGWriterImpl::ImplGetFilter ( sal_uLong nY, sal_uLong nXStart, sal_uL
                         *pDest++ = rColor.GetRed();
                         *pDest++ = rColor.GetGreen();
                         *pDest++ = rColor.GetBlue();
-                        *pDest++ = 255 - mpMaskAccess->GetPixel( nY, nX );
+                        *pDest++ = 255 - mpMaskAccess->GetPixelIndex( nY, nX );
                     }
                 }
                 else
diff --git a/vcl/source/helper/canvasbitmap.cxx b/vcl/source/helper/canvasbitmap.cxx
index bffba6cfaef0..8ae3ccb987db 100644
--- a/vcl/source/helper/canvasbitmap.cxx
+++ b/vcl/source/helper/canvasbitmap.cxx
@@ -541,8 +541,8 @@ uno::Sequence< sal_Int8 > SAL_CALL VclCanvasBitmap::getData( rendering::IntegerB
                 // input less than a byte - copy via GetPixel()
                 for( long x=aRequestedArea.Left(); x<aRequestedArea.Right(); ++x )
                 {
-                    *pOutScan++ = m_pBmpAcc->GetPixel(y,x);
-                    *pOutScan++ = m_pAlphaAcc->GetPixel(y,x);
+                    *pOutScan++ = m_pBmpAcc->GetPixelIndex(y,x);
+                    *pOutScan++ = m_pAlphaAcc->GetPixelIndex(y,x);
                 }
             }
             else
@@ -556,7 +556,7 @@ uno::Sequence< sal_Int8 > SAL_CALL VclCanvasBitmap::getData( rendering::IntegerB
                 {
                     for( long i=0; i<nNonAlphaBytes; ++i )
                         *pOutScan++ = *pScan++;
-                    *pOutScan++ = m_pAlphaAcc->GetPixel(y,x);
+                    *pOutScan++ = m_pAlphaAcc->GetPixelIndex( y, x );
                 }
             }
 
@@ -618,8 +618,8 @@ uno::Sequence< sal_Int8 > SAL_CALL VclCanvasBitmap::getPixel( rendering::Integer
         if( m_nBitsPerInputPixel < 8 )
         {
             // input less than a byte - copy via GetPixel()
-            *pOutBuf++ = m_pBmpAcc->GetPixel(pos.Y,pos.X);
-            *pOutBuf   = m_pAlphaAcc->GetPixel(pos.Y,pos.X);
+            *pOutBuf++ = m_pBmpAcc->GetPixelIndex(pos.Y,pos.X);
+            *pOutBuf   = m_pAlphaAcc->GetPixelIndex(pos.Y,pos.X);
         }
         else
         {
@@ -629,7 +629,7 @@ uno::Sequence< sal_Int8 > SAL_CALL VclCanvasBitmap::getPixel( rendering::Integer
             // input integer multiple of byte - copy directly
             rtl_copyMemory(pOutBuf, pScan+nScanlineLeftOffset, nNonAlphaBytes );
             pOutBuf += nNonAlphaBytes;
-            *pOutBuf++ = m_pAlphaAcc->GetPixel(pos.Y,pos.X);
+            *pOutBuf++ = m_pAlphaAcc->GetPixelIndex(pos.Y,pos.X);
         }
     }
 
@@ -1176,10 +1176,7 @@ uno::Sequence<rendering::RGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToRGB
         {
             const BitmapColor aCol =
                 m_bPalette ?
-                m_pBmpAcc->GetPaletteColor(
-                    sal::static_int_cast<sal_uInt16>(
-                        m_pBmpAcc->GetPixelFromData(
-                            pIn, i ))) :
+                m_pBmpAcc->GetPaletteColor( m_pBmpAcc->GetPixelFromData( pIn, i ).GetIndex()) :
                 m_pBmpAcc->GetPixelFromData(pIn, i);
 
             // TODO(F3): Convert result to sRGB color space
@@ -1233,10 +1230,7 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToAR
         {
             const BitmapColor aCol =
                 m_bPalette ?
-                m_pBmpAcc->GetPaletteColor(
-                    sal::static_int_cast<sal_uInt16>(
-                        m_pBmpAcc->GetPixelFromData(
-                            pIn, i ))) :
+                m_pBmpAcc->GetPaletteColor( m_pBmpAcc->GetPixelFromData( pIn, i ).GetIndex() ) :
                 m_pBmpAcc->GetPixelFromData(pIn, i);
 
             // TODO(F3): Convert result to sRGB color space
@@ -1292,10 +1286,7 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToPA
         {
             const BitmapColor aCol =
                 m_bPalette ?
-                m_pBmpAcc->GetPaletteColor(
-                    sal::static_int_cast<sal_uInt16>(
-                        m_pBmpAcc->GetPixelFromData(
-                            pIn, i ))) :
+                m_pBmpAcc->GetPaletteColor( m_pBmpAcc->GetPixelFromData( pIn, i ).GetIndex() ) :
                 m_pBmpAcc->GetPixelFromData(pIn, i);
 
             // TODO(F3): Convert result to sRGB color space
diff --git a/vcl/source/helper/canvastools.cxx b/vcl/source/helper/canvastools.cxx
index 89e23415c6a0..ac425717785a 100644
--- a/vcl/source/helper/canvastools.cxx
+++ b/vcl/source/helper/canvastools.cxx
@@ -249,8 +249,8 @@ namespace vcl
                             for( sal_Int32 x=0; x<nWidth; ++x )
                             {
                                 const rendering::ARGBColor& rColor=aARGBColors[x];
-                                rWriteAcc->SetPixel( aRect.Y1, x,
-                                                     (sal_uInt8)rWriteAcc->GetBestPaletteIndex(
+                                rWriteAcc->SetPixelIndex( aRect.Y1, x,
+                                                     (sal_uInt8) rWriteAcc->GetBestPaletteIndex(
                                                          BitmapColor( toByteColor(rColor.Red),
                                                                       toByteColor(rColor.Green),
                                                                       toByteColor(rColor.Blue))) );
@@ -281,8 +281,8 @@ namespace vcl
                             for( sal_Int32 x=0; x<nWidth; ++x )
                             {
                                 const rendering::RGBColor& rColor=aRGBColors[x];
-                                rWriteAcc->SetPixel( aRect.Y1, x,
-                                                     (sal_uInt8)rWriteAcc->GetBestPaletteIndex(
+                                rWriteAcc->SetPixelIndex( aRect.Y1, x,
+                                                     (sal_uInt8) rWriteAcc->GetBestPaletteIndex(
                                                          BitmapColor( toByteColor(rColor.Red),
                                                                       toByteColor(rColor.Green),
                                                                       toByteColor(rColor.Blue))) );