[Libreoffice-commits] .: 3 commits - vcl/source

Tomaž Vajngerl tvajngerl at kemper.freedesktop.org
Thu Jul 26 12:01:45 PDT 2012


 vcl/source/gdi/bitmap3.cxx  |   64 -----------------------------
 vcl/source/gdi/bitmapex.cxx |   97 ++------------------------------------------
 2 files changed, 5 insertions(+), 156 deletions(-)

New commits:
commit 47ab19faef29f0d6ec163c417c1f38ed06078e36
Author: Tomaž Vajngerl <quikee at gmail.com>
Date:   Thu Jul 26 20:58:31 2012 +0200

    Only make transparent mask when the angle is not 0, 90, 180 or 270.
    
    Change-Id: I46798192d019967f74e4d118b1dd322072cd3997

diff --git a/vcl/source/gdi/bitmapex.cxx b/vcl/source/gdi/bitmapex.cxx
index d4fea95..e7df476 100644
--- a/vcl/source/gdi/bitmapex.cxx
+++ b/vcl/source/gdi/bitmapex.cxx
@@ -393,11 +393,13 @@ sal_Bool BitmapEx::ScaleCropRotate(
 {
     bool bRet = false;
 
-    const bool bTransparentRotate = ( Color( COL_TRANSPARENT ) == rFillColor );
-
     if( !!aBitmap )
     {
-        if( bTransparentRotate )
+        const bool bTransparentRotate = ( Color( COL_TRANSPARENT ) == rFillColor );
+
+        bool bRightAngleRotation = (nAngle10 == 0 || nAngle10 == 900 || nAngle10 == 1800 || nAngle10 == 2700);
+
+        if( !bRightAngleRotation && bTransparentRotate )
         {
             if( eTransparent == TRANSPARENT_COLOR )
             {
commit d37ea5bc4b3370f9181de2f74a6c27c02c77bb5d
Author: Tomaž Vajngerl <quikee at gmail.com>
Date:   Thu Jul 26 20:41:59 2012 +0200

    Remove useless code separaion comments in bitmapex.cxx
    
    Change-Id: Ic77244abfc68da4b5e64d2159d5700e8ac03a999

diff --git a/vcl/source/gdi/bitmapex.cxx b/vcl/source/gdi/bitmapex.cxx
index beba5d5..d4fea95 100644
--- a/vcl/source/gdi/bitmapex.cxx
+++ b/vcl/source/gdi/bitmapex.cxx
@@ -48,18 +48,12 @@
 #include <image.h>
 #include <impimagetree.hxx>
 
-// ------------
-// - BitmapEx -
-// ------------
-
 BitmapEx::BitmapEx() :
         eTransparent( TRANSPARENT_NONE ),
         bAlpha      ( sal_False )
 {
 }
 
-// ------------------------------------------------------------------
-
 BitmapEx::BitmapEx( const BitmapEx& rBitmapEx ) :
         aBitmap             ( rBitmapEx.aBitmap ),
         aMask               ( rBitmapEx.aMask ),
@@ -92,8 +86,6 @@ BitmapEx::BitmapEx( const BitmapEx& rBitmapEx, Point aSrc, Size aSize ) :
     CopyPixel( aDestRect, aSrcRect, &rBitmapEx );
 }
 
-// ------------------------------------------------------------------
-
 BitmapEx::BitmapEx( const ResId& rResId ) :
         eTransparent( TRANSPARENT_NONE ),
         bAlpha      ( sal_False )
@@ -119,8 +111,6 @@ BitmapEx::BitmapEx( const ResId& rResId ) :
     }
 }
 
-// ------------------------------------------------------------------
-
 BitmapEx::BitmapEx( const Bitmap& rBmp ) :
         aBitmap     ( rBmp ),
         aBitmapSize ( aBitmap.GetSizePixel() ),
@@ -129,8 +119,6 @@ BitmapEx::BitmapEx( const Bitmap& rBmp ) :
 {
 }
 
-// ------------------------------------------------------------------
-
 BitmapEx::BitmapEx( const Bitmap& rBmp, const Bitmap& rMask ) :
         aBitmap         ( rBmp ),
         aMask           ( rMask ),
@@ -149,8 +137,6 @@ BitmapEx::BitmapEx( const Bitmap& rBmp, const Bitmap& rMask ) :
     }
 }
 
-// ------------------------------------------------------------------
-
 BitmapEx::BitmapEx( const Bitmap& rBmp, const AlphaMask& rAlphaMask ) :
         aBitmap         ( rBmp ),
         aMask           ( rAlphaMask.ImplGetBitmap() ),
@@ -168,8 +154,6 @@ BitmapEx::BitmapEx( const Bitmap& rBmp, const AlphaMask& rAlphaMask ) :
         aBitmap.Convert( BMP_CONVERSION_24BIT );
 }
 
-// ------------------------------------------------------------------
-
 BitmapEx::BitmapEx( const Bitmap& rBmp, const Color& rTransparentColor ) :
         aBitmap             ( rBmp ),
         aBitmapSize         ( aBitmap.GetSizePixel() ),
@@ -183,16 +167,10 @@ BitmapEx::BitmapEx( const Bitmap& rBmp, const Color& rTransparentColor ) :
                 "BitmapEx::BitmapEx(): size mismatch for bitmap and alpha mask." );
 }
 
-// ------------------------------------------------------------------
-
 BitmapEx::~BitmapEx()
 {
 }
 
-// ------------------------------------------------------------------
-
-// ------------------------------------------------------------------
-
 BitmapEx& BitmapEx::operator=( const BitmapEx& rBitmapEx )
 {
     if( &rBitmapEx != this )
@@ -208,8 +186,6 @@ BitmapEx& BitmapEx::operator=( const BitmapEx& rBitmapEx )
     return *this;
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::operator==( const BitmapEx& rBitmapEx ) const
 {
     if( eTransparent != rBitmapEx.eTransparent )
@@ -230,8 +206,6 @@ sal_Bool BitmapEx::operator==( const BitmapEx& rBitmapEx ) const
     return( ( aMask == rBitmapEx.aMask ) && ( bAlpha == rBitmapEx.bAlpha ) );
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::IsEqual( const BitmapEx& rBmpEx ) const
 {
     return( rBmpEx.eTransparent == eTransparent &&
@@ -240,15 +214,11 @@ sal_Bool BitmapEx::IsEqual( const BitmapEx& rBmpEx ) const
             rBmpEx.aMask.IsEqual( aMask ) );
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::IsEmpty() const
 {
     return( aBitmap.IsEmpty() && aMask.IsEmpty() );
 }
 
-// ------------------------------------------------------------------
-
 void BitmapEx::SetEmpty()
 {
     aBitmap.SetEmpty();
@@ -257,29 +227,21 @@ void BitmapEx::SetEmpty()
     bAlpha = sal_False;
 }
 
-// ------------------------------------------------------------------
-
 void BitmapEx::Clear()
 {
     SetEmpty();
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::IsTransparent() const
 {
     return( eTransparent != TRANSPARENT_NONE );
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::IsAlpha() const
 {
     return( IsTransparent() && bAlpha );
 }
 
-// ------------------------------------------------------------------
-
 Bitmap BitmapEx::GetBitmap( const Color* pTransReplaceColor ) const
 {
     Bitmap aRetBmp( aBitmap );
@@ -302,8 +264,6 @@ Bitmap BitmapEx::GetBitmap( const Color* pTransReplaceColor ) const
     return aRetBmp;
 }
 
-// ------------------------------------------------------------------
-
 Bitmap BitmapEx::GetMask() const
 {
     Bitmap aRet( aMask );
@@ -314,8 +274,6 @@ Bitmap BitmapEx::GetMask() const
     return aRet;
 }
 
-// ------------------------------------------------------------------
-
 AlphaMask BitmapEx::GetAlpha() const
 {
     AlphaMask aAlpha;
@@ -328,8 +286,6 @@ AlphaMask BitmapEx::GetAlpha() const
     return aAlpha;
 }
 
-// ------------------------------------------------------------------
-
 sal_uLong BitmapEx::GetSizeBytes() const
 {
     sal_uLong nSizeBytes = aBitmap.GetSizeBytes();
@@ -340,8 +296,6 @@ sal_uLong BitmapEx::GetSizeBytes() const
     return nSizeBytes;
 }
 
-// ------------------------------------------------------------------
-
 sal_uLong BitmapEx::GetChecksum() const
 {
     sal_uInt32  nCrc = aBitmap.GetChecksum();
@@ -362,15 +316,11 @@ sal_uLong BitmapEx::GetChecksum() const
     return nCrc;
 }
 
-// ------------------------------------------------------------------
-
 void BitmapEx::SetSizePixel( const Size& rNewSize )
 {
     Scale( rNewSize );
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::Invert()
 {
     sal_Bool bRet = sal_False;
@@ -386,8 +336,6 @@ sal_Bool BitmapEx::Invert()
     return bRet;
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::Mirror( sal_uLong nMirrorFlags )
 {
     sal_Bool bRet = sal_False;
@@ -403,8 +351,6 @@ sal_Bool BitmapEx::Mirror( sal_uLong nMirrorFlags )
     return bRet;
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::Scale( const double& rScaleX, const double& rScaleY, sal_uLong nScaleFlag )
 {
     sal_Bool bRet = sal_False;
@@ -425,8 +371,6 @@ sal_Bool BitmapEx::Scale( const double& rScaleX, const double& rScaleY, sal_uLon
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool BitmapEx::Scale( const Size& rNewSize, sal_uLong nScaleFlag )
 {
     sal_Bool bRet;
@@ -532,8 +476,6 @@ sal_Bool BitmapEx::Rotate( long nAngle10, const Color& rFillColor )
     return bRet;
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::Crop( const Rectangle& rRectPixel )
 {
     sal_Bool bRet = sal_False;
@@ -554,22 +496,16 @@ sal_Bool BitmapEx::Crop( const Rectangle& rRectPixel )
     return bRet;
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::Convert( BmpConversion eConversion )
 {
     return( !!aBitmap ? aBitmap.Convert( eConversion ) : sal_False );
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::ReduceColors( sal_uInt16 nNewColorCount, BmpReduce eReduce )
 {
     return( !!aBitmap ? aBitmap.ReduceColors( nNewColorCount, eReduce ) : sal_False );
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::Expand( sal_uLong nDX, sal_uLong nDY, const Color* pInitColor, sal_Bool bExpandTransparent )
 {
     sal_Bool bRet = sal_False;
@@ -593,8 +529,6 @@ sal_Bool BitmapEx::Expand( sal_uLong nDX, sal_uLong nDY, const Color* pInitColor
     return bRet;
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::CopyPixel( const Rectangle& rRectDst, const Rectangle& rRectSrc,
                           const BitmapEx* pBmpExSrc )
 {
@@ -682,8 +616,6 @@ sal_Bool BitmapEx::CopyPixel( const Rectangle& rRectDst, const Rectangle& rRectS
     return bRet;
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::Erase( const Color& rFillColor )
 {
     sal_Bool bRet = sal_False;
@@ -711,29 +643,21 @@ sal_Bool BitmapEx::Erase( const Color& rFillColor )
     return bRet;
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::Dither( sal_uLong nDitherFlags )
 {
     return( !!aBitmap ? aBitmap.Dither( nDitherFlags ) : sal_False );
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::Replace( const Color& rSearchColor, const Color& rReplaceColor, sal_uLong nTol )
 {
     return( !!aBitmap ? aBitmap.Replace( rSearchColor, rReplaceColor, nTol ) : sal_False );
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::Replace( const Color* pSearchColors, const Color* pReplaceColors, sal_uLong nColorCount, const sal_uLong* pTols )
 {
     return( !!aBitmap ? aBitmap.Replace( pSearchColors, pReplaceColors, nColorCount, (sal_uLong*) pTols ) : sal_False );
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::Adjust( short nLuminancePercent, short nContrastPercent,
                        short nChannelRPercent, short nChannelGPercent, short nChannelBPercent,
                        double fGamma, sal_Bool bInvert )
@@ -743,30 +667,22 @@ sal_Bool BitmapEx::Adjust( short nLuminancePercent, short nContrastPercent,
                                         fGamma, bInvert ) : sal_False );
 }
 
-// ------------------------------------------------------------------
-
 sal_Bool BitmapEx::Filter( BmpFilter eFilter, const BmpFilterParam* pFilterParam, const Link* pProgress )
 {
     return( !!aBitmap ? aBitmap.Filter( eFilter, pFilterParam, pProgress ) : sal_False );
 }
 
-// ------------------------------------------------------------------
-
 void BitmapEx::Draw( OutputDevice* pOutDev, const Point& rDestPt ) const
 {
     pOutDev->DrawBitmapEx( rDestPt, *this );
 }
 
-// ------------------------------------------------------------------
-
 void BitmapEx::Draw( OutputDevice* pOutDev,
                      const Point& rDestPt, const Size& rDestSize ) const
 {
     pOutDev->DrawBitmapEx( rDestPt, rDestSize, *this );
 }
 
-// ------------------------------------------------------------------
-
 BitmapEx BitmapEx:: AutoScaleBitmap(BitmapEx & aBitmap, const long aStandardSize)
 {
     Point aEmptyPoint(0,0);
@@ -821,7 +737,6 @@ BitmapEx BitmapEx:: AutoScaleBitmap(BitmapEx & aBitmap, const long aStandardSize
 
     return aRet;
 }
-// ------------------------------------------------------------------
 
 sal_uInt8 BitmapEx::GetTransparency(sal_Int32 nX, sal_Int32 nY) const
 {
@@ -893,8 +808,6 @@ sal_uInt8 BitmapEx::GetTransparency(sal_Int32 nX, sal_Int32 nY) const
     return nTransparency;
 }
 
-// ------------------------------------------------------------------
-
 SvStream& operator<<( SvStream& rOStm, const BitmapEx& rBitmapEx )
 {
     rBitmapEx.aBitmap.Write( rOStm );
@@ -911,8 +824,6 @@ SvStream& operator<<( SvStream& rOStm, const BitmapEx& rBitmapEx )
     return rOStm;
 }
 
-// ------------------------------------------------------------------
-
 SvStream& operator>>( SvStream& rIStm, BitmapEx& rBitmapEx )
 {
     Bitmap aBmp;
commit 376927e48c0d6da2933e9cf3eb8b8a2b92bf843a
Author: Tomaž Vajngerl <quikee at gmail.com>
Date:   Thu Jul 26 20:38:31 2012 +0200

    Remove useless code separaion comments in bitmap3.cpp
    
    Change-Id: I402835cf2bcdab48065eed251ba193dda6c27ad4

diff --git a/vcl/source/gdi/bitmap3.cxx b/vcl/source/gdi/bitmap3.cxx
index edae9e1..66198e3 100644
--- a/vcl/source/gdi/bitmap3.cxx
+++ b/vcl/source/gdi/bitmap3.cxx
@@ -82,8 +82,6 @@ const extern sal_uLong nVCLRLut[ 6 ] = { 16, 17, 18, 19, 20, 21 };
 const extern sal_uLong nVCLGLut[ 6 ] = { 0, 6, 12, 18, 24, 30 };
 const extern sal_uLong nVCLBLut[ 6 ] = { 0, 36, 72, 108, 144, 180 };
 
-// ------------------------------------------------------------------------
-
 const extern sal_uLong nVCLDitherLut[ 256 ] =
 {
        0, 49152, 12288, 61440,  3072, 52224, 15360, 64512,   768, 49920, 13056,
@@ -112,8 +110,6 @@ const extern sal_uLong nVCLDitherLut[ 256 ] =
    25856, 38144, 21760
 };
 
-// ------------------------------------------------------------------------
-
 const extern sal_uLong nVCLLut[ 256 ] =
 {
          0,  1286,  2572,  3858,  5144,  6430,  7716,  9002,
@@ -150,8 +146,6 @@ const extern sal_uLong nVCLLut[ 256 ] =
     318928,320214,321500,322786,324072,325358,326644,327930
 };
 
-// ------------------------------------------------------------------------
-
 const long FloydMap[256] =
 {
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -172,8 +166,6 @@ const long FloydMap[256] =
     5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
 };
 
-// ------------------------------------------------------------------------
-
 const long FloydError1[61] =
 {
     -7680, -7424, -7168, -6912, -6656, -6400, -6144,
@@ -186,8 +178,6 @@ const long FloydError1[61] =
     5888, 6144, 6400, 6656, 6912, 7168, 7424, 7680
 };
 
-// ------------------------------------------------------------------------
-
 const long FloydError3[61] =
 {
     -23040, -22272, -21504, -20736, -19968, -19200,
@@ -201,8 +191,6 @@ const long FloydError3[61] =
     19200, 19968, 20736, 21504, 22272, 23040
 };
 
-// ------------------------------------------------------------------------
-
 const long FloydError5[61] =
 {
     -38400, -37120, -35840, -34560, -33280, -32000,
@@ -217,8 +205,6 @@ const long FloydError5[61] =
     38400
 };
 
-// ------------------------------------------------------------------------
-
 const long FloydError7[61] =
 {
     -53760, -51968, -50176, -48384, -46592, -44800,
@@ -233,8 +219,6 @@ const long FloydError7[61] =
     53760
 };
 
-// ------------------------------------------------------------------------
-
 const long FloydIndexMap[6] =
 {
     -30,  21, 72, 123, 174, 225
@@ -362,8 +346,6 @@ sal_Bool Bitmap::Convert( BmpConversion eConversion )
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplMakeMono( sal_uInt8 cThreshold )
 {
     BitmapReadAccess*   pReadAcc = AcquireReadAccess();
@@ -435,8 +417,6 @@ sal_Bool Bitmap::ImplMakeMono( sal_uInt8 cThreshold )
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplMakeMonoDither()
 {
     BitmapReadAccess*   pReadAcc = AcquireReadAccess();
@@ -511,8 +491,6 @@ sal_Bool Bitmap::ImplMakeMonoDither()
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplMakeGreyscales( sal_uInt16 nGreys )
 {
     DBG_ASSERT( nGreys == 16 || nGreys == 256, "Only 16 or 256 greyscales are supported!" );
@@ -625,8 +603,6 @@ sal_Bool Bitmap::ImplMakeGreyscales( sal_uInt16 nGreys )
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplConvertUp( sal_uInt16 nBitCount, Color* pExtColor )
 {
     DBG_ASSERT( nBitCount > GetBitCount(), "New BitCount must be greater!" );
@@ -701,8 +677,6 @@ sal_Bool Bitmap::ImplConvertUp( sal_uInt16 nBitCount, Color* pExtColor )
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplConvertDown( sal_uInt16 nBitCount, Color* pExtColor )
 {
     DBG_ASSERT( nBitCount <= GetBitCount(), "New BitCount must be lower ( or equal when pExtColor is set )!" );
@@ -827,8 +801,6 @@ sal_Bool Bitmap::ImplConvertDown( sal_uInt16 nBitCount, Color* pExtColor )
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplConvertGhosted()
 {
     Bitmap              aNewBmp;
@@ -903,8 +875,6 @@ sal_Bool Bitmap::ImplConvertGhosted()
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::Scale( const double& rScaleX, const double& rScaleY, sal_uLong nScaleFlag )
 {
     bool bRet;
@@ -950,8 +920,6 @@ sal_Bool Bitmap::Scale( const double& rScaleX, const double& rScaleY, sal_uLong
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::Scale( const Size& rNewSize, sal_uLong nScaleFlag )
 {
     const Size  aSize( GetSizePixel() );
@@ -969,8 +937,6 @@ sal_Bool Bitmap::Scale( const Size& rNewSize, sal_uLong nScaleFlag )
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplScaleFast( const double& rScaleX, const double& rScaleY )
 {
     const Size  aSizePix( GetSizePixel() );
@@ -1040,8 +1006,6 @@ sal_Bool Bitmap::ImplScaleFast( const double& rScaleX, const double& rScaleY )
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rScaleY )
 {
     const Size  aSizePix( GetSizePixel() );
@@ -1276,8 +1240,6 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::Dither( sal_uLong nDitherFlags )
 {
     sal_Bool bRet = sal_False;
@@ -1296,8 +1258,6 @@ sal_Bool Bitmap::Dither( sal_uLong nDitherFlags )
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplDitherMatrix()
 {
     BitmapReadAccess*   pReadAcc = AcquireReadAccess();
@@ -1366,8 +1326,6 @@ sal_Bool Bitmap::ImplDitherMatrix()
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplDitherFloyd()
 {
     const Size  aSize( GetSizePixel() );
@@ -1507,8 +1465,6 @@ sal_Bool Bitmap::ImplDitherFloyd()
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplDitherFloyd16()
 {
     BitmapReadAccess*   pReadAcc = AcquireReadAccess();
@@ -1598,8 +1554,6 @@ sal_Bool Bitmap::ImplDitherFloyd16()
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ReduceColors( sal_uInt16 nColorCount, BmpReduce eReduce )
 {
     sal_Bool bRet;
@@ -1621,8 +1575,6 @@ sal_Bool Bitmap::ReduceColors( sal_uInt16 nColorCount, BmpReduce eReduce )
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplReduceSimple( sal_uInt16 nColorCount )
 {
     Bitmap              aNewBmp;
@@ -1685,16 +1637,12 @@ sal_Bool Bitmap::ImplReduceSimple( sal_uInt16 nColorCount )
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 struct PopularColorCount
 {
     sal_uInt32  mnIndex;
     sal_uInt32  mnCount;
 };
 
-// ------------------------------------------------------------------------
-
 extern "C" int __LOADONCALLAPI ImplPopularCmpFnc( const void* p1, const void* p2 )
 {
     int nRet;
@@ -1709,8 +1657,6 @@ extern "C" int __LOADONCALLAPI ImplPopularCmpFnc( const void* p1, const void* p2
     return nRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplReducePopular( sal_uInt16 nColCount )
 {
     BitmapReadAccess*   pRAcc = AcquireReadAccess();
@@ -1856,8 +1802,6 @@ sal_Bool Bitmap::ImplReducePopular( sal_uInt16 nColCount )
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::ImplReduceMedian( sal_uInt16 nColCount )
 {
     BitmapReadAccess*   pRAcc = AcquireReadAccess();
@@ -1947,8 +1891,6 @@ sal_Bool Bitmap::ImplReduceMedian( sal_uInt16 nColCount )
     return bRet;
 }
 
-// ------------------------------------------------------------------------
-
 void Bitmap::ImplMedianCut( sal_uLong* pColBuf, BitmapPalette& rPal,
                             long nR1, long nR2, long nG1, long nG2, long nB1, long nB2,
                             long nColors, long nPixels, long& rIndex )
@@ -2080,22 +2022,16 @@ void Bitmap::ImplMedianCut( sal_uLong* pColBuf, BitmapPalette& rPal,
     }
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::Vectorize( PolyPolygon& rPolyPoly, sal_uLong nFlags, const Link* pProgress )
 {
     return ImplVectorizer().ImplVectorize( *this, rPolyPoly, nFlags, pProgress );
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::Vectorize( GDIMetaFile& rMtf, sal_uInt8 cReduce, sal_uLong nFlags, const Link* pProgress )
 {
     return ImplVectorizer().ImplVectorize( *this, rMtf, cReduce, nFlags, pProgress );
 }
 
-// ------------------------------------------------------------------------
-
 sal_Bool Bitmap::Adjust( short nLuminancePercent, short nContrastPercent,
                      short nChannelRPercent, short nChannelGPercent, short nChannelBPercent,
                      double fGamma, sal_Bool bInvert )


More information about the Libreoffice-commits mailing list