CWS-TOOLING: integrate CWS canvas06

2008-11-14 18:59:03 +0100 thb  r263697 : Reverted fAlpha setup to previous state, as this was bogus as well - code path is apparently not taken for test, but anyway
2008-11-13 21:32:45 +0100 thb  r263663 : WaE fix (and a bad bug as well - int color would have overflown)
2008-11-13 16:51:37 +0100 pl  r263654 : remove warnings
2008-11-13 09:46:28 +0100 thb  r263623 : #i95317# Fixed typo (thx WaE for finding)
2008-11-12 21:25:19 +0100 thb  r263617 : #i96047# call update() on hidden sprite shape as well, to force actual hiding
2008-11-12 21:23:31 +0100 thb  r263616 : #i95209# Merge from CWS thb11 - revives canvasbitmap unit tests, fixes nasty corner case in x11 salbmp (for 16bpp)
2008-11-12 21:21:46 +0100 thb  r263615 : #i95197# Shuffled code to make valgrind quiet during bmp loading
2008-11-12 21:18:06 +0100 thb  r263614 : #i93382# Make --disable-moz build work
2008-11-12 21:16:55 +0100 thb  r263613 : #i95317# Fixed mis-named traits methods for min and max numbers
2008-11-12 20:59:01 +0100 thb  r263612 : #i95317#, #i92902#: migrate CWS canvas06 to SVN.

5 files changed, 311 insertions, 38 deletions

diff --git a/vcl/source/gdi/bitmap2.cxx b/vcl/source/gdi/bitmap2.cxx
index de9da1fb638f..39aa9da8c470 100644
--- a/vcl/source/gdi/bitmap2.cxx
+++ b/vcl/source/gdi/bitmap2.cxx
@@ -756,18 +756,18 @@ BOOL Bitmap::ImplWriteDIB( SvStream& rOStm, BitmapReadAccess& rAcc, BOOL bCompre
         // MapMode is integer-based, and suffers from roundoffs,
         // especially if maPrefSize is small. Trying to circumvent
         // that by performing part of the math in floating point.
-        const Size aScale10000(
+        const Size aScale100000(
             OutputDevice::LogicToLogic( Size(100000L,
                                              100000L),
-                                        maPrefMapMode,
-                                        MAP_100TH_MM ) );
-        const double fScaleX((double)aScale10000.Width() * maPrefSize.Width());
-        const double fScaleY((double)aScale10000.Height() * maPrefSize.Height());
-        if( fabs(fScaleX) > 0.000000001 &&
-            fabs(fScaleY) > 0.000000001 )
+                                        MAP_100TH_MM,
+                                        maPrefMapMode ) );
+        const double fBmpWidthM((double)maPrefSize.Width() / aScale100000.Width() );
+        const double fBmpHeightM((double)maPrefSize.Height() / aScale100000.Height() );
+        if( fabs(fBmpWidthM) > 0.000000001 &&
+            fabs(fBmpHeightM) > 0.000000001 )
         {
-            aHeader.nXPelsPerMeter = (UINT32)(rAcc.Width() / fScaleX + .5);
-            aHeader.nYPelsPerMeter = (UINT32)(rAcc.Height() / fScaleY + .5);
+            aHeader.nXPelsPerMeter = (UINT32)(rAcc.Width() / fBmpWidthM + .5);
+            aHeader.nYPelsPerMeter = (UINT32)(rAcc.Height() / fBmpHeightM + .5);
         }
     }
 
diff --git a/vcl/source/gdi/cvtsvm.cxx b/vcl/source/gdi/cvtsvm.cxx
index fce0a042a12f..0f999573ef89 100644
--- a/vcl/source/gdi/cvtsvm.cxx
+++ b/vcl/source/gdi/cvtsvm.cxx
@@ -408,9 +408,7 @@ void SVMConverter::ImplConvertFromSVM1( SvStream& rIStm, GDIMetaFile& rMtf )
     rIStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
 
     char    aCode[ 5 ];
-    MapMode aMapMode;
     Size    aPrefSz;
-    INT32   nActions;
     INT16   nSize;
     INT16   nVersion;
 
@@ -420,11 +418,11 @@ void SVMConverter::ImplConvertFromSVM1( SvStream& rIStm, GDIMetaFile& rMtf )
     rIStm >> nVersion;                              // Version
     rIStm >> aPrefSz.Width();                       // PrefSize.Width()
     rIStm >> aPrefSz.Height();                      // PrefSize.Height()
-    ImplReadMapMode( rIStm, aMapMode );             // MapMode
-    rIStm >> nActions;                              // Action count
 
     // Header-Kennung und Versionsnummer pruefen
-    if( ( memcmp( aCode, "SVGDI", sizeof( aCode ) ) != 0 ) || ( nVersion != 200 ) )
+    if( rIStm.GetError()
+        || ( memcmp( aCode, "SVGDI", sizeof( aCode ) ) != 0 )
+        || ( nVersion != 200 ) )
     {
         rIStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
         rIStm.SetNumberFormatInt( nOldFormat );
@@ -432,17 +430,22 @@ void SVMConverter::ImplConvertFromSVM1( SvStream& rIStm, GDIMetaFile& rMtf )
     }
     else
     {
+        MapMode     aMapMode;
         Polygon     aActionPoly;
         Rectangle   aRect;
         Point       aPt, aPt1;
         Size        aSz;
         Color       aActionColor;
         INT32       nTmp, nTmp1, nActionSize;
+        INT32       nActions;
         INT16       nType;
 
         sal_uInt32  nUnicodeCommentStreamPos = 0;
         INT32       nUnicodeCommentActionNumber = 0;
 
+        ImplReadMapMode( rIStm, aMapMode );             // MapMode
+        rIStm >> nActions;                              // Action count
+
         rMtf.SetPrefSize( aPrefSz );
         rMtf.SetPrefMapMode( aMapMode );
 
diff --git a/vcl/source/gdi/impgraph.cxx b/vcl/source/gdi/impgraph.cxx
index 8525d17ea041..6291c011fee1 100644
--- a/vcl/source/gdi/impgraph.cxx
+++ b/vcl/source/gdi/impgraph.cxx
@@ -1504,7 +1504,7 @@ SvStream& operator>>( SvStream& rIStm, ImpGraphic& rImpGraphic )
         // read Id
         rIStm >> nTmp;
 
-        if( NATIVE_FORMAT_50 == nTmp )
+        if( !rIStm.GetError() && NATIVE_FORMAT_50 == nTmp )
         {
             Graphic         aGraphic;
             GfxLink         aLink;
diff --git a/vcl/source/helper/canvasbitmap.cxx b/vcl/source/helper/canvasbitmap.cxx
index 7b450f6c0fa9..1e487b141d80 100644
--- a/vcl/source/helper/canvasbitmap.cxx
+++ b/vcl/source/helper/canvasbitmap.cxx
@@ -150,9 +150,6 @@ VclCanvasBitmap::VclCanvasBitmap( const BitmapEx& rBitmap ) :
         m_aLayout.ScanLineStride = m_pBmpAcc->GetScanlineSize();
         m_aLayout.PlaneStride    = 0;
 
-        if( !(m_pBmpAcc->GetScanlineFormat() & BMP_FORMAT_TOP_DOWN) )
-            m_aLayout.ScanLineStride *= -1;
-
         switch( m_pBmpAcc->GetScanlineFormat() )
         {
             case BMP_FORMAT_1BIT_MSB_PAL:
@@ -436,8 +433,6 @@ VclCanvasBitmap::VclCanvasBitmap( const BitmapEx& rBitmap ) :
             const Size aSize = m_aBitmap.GetSizePixel();
             m_aLayout.ScanLineBytes  =
             m_aLayout.ScanLineStride = (aSize.Width()*m_nBitsPerOutputPixel + 7)/8;
-            if( !(m_pBmpAcc->GetScanlineFormat() & BMP_FORMAT_TOP_DOWN) )
-                m_aLayout.ScanLineStride *= -1;
         }
     }
 }
@@ -515,8 +510,12 @@ uno::Sequence< sal_Int8 > SAL_CALL VclCanvasBitmap::getData( rendering::IntegerB
     bitmapLayout.ScanLineBytes =
     bitmapLayout.ScanLineStride= aRequestedBytes.getWidth();
 
+    sal_Int32 nScanlineStride=bitmapLayout.ScanLineStride;
     if( !(m_pBmpAcc->GetScanlineFormat() & BMP_FORMAT_TOP_DOWN) )
-        bitmapLayout.ScanLineStride *= -1;
+    {
+        pOutBuf += bitmapLayout.ScanLineStride*(aRequestedBytes.getHeight()-1);
+        nScanlineStride *= -1;
+    }
 
     if( !m_aBmpEx.IsTransparent() )
     {
@@ -527,7 +526,7 @@ uno::Sequence< sal_Int8 > SAL_CALL VclCanvasBitmap::getData( rendering::IntegerB
         {
             Scanline pScan = m_pBmpAcc->GetScanline(y);
             rtl_copyMemory(pOutBuf, pScan+aRequestedBytes.Left(), aRequestedBytes.getWidth());
-            pOutBuf += bitmapLayout.ScanLineStride;
+            pOutBuf += nScanlineStride;
         }
     }
     else
@@ -568,7 +567,7 @@ uno::Sequence< sal_Int8 > SAL_CALL VclCanvasBitmap::getData( rendering::IntegerB
                 }
             }
 
-            pOutBuf += bitmapLayout.ScanLineStride;
+            pOutBuf += nScanlineStride;
         }
     }
 
@@ -870,6 +869,59 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertToARGB( con
     return aRes;
 }
 
+uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
+{
+    vos::OGuard aGuard( Application::GetSolarMutex() );
+
+    const sal_Size  nLen( deviceColor.getLength() );
+    const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
+    ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
+                         "number of channels no multiple of pixel element count",
+                         static_cast<rendering::XBitmapPalette*>(this), 01);
+
+    uno::Sequence< rendering::ARGBColor > aRes(nLen/nComponentsPerPixel);
+    rendering::ARGBColor* pOut( aRes.getArray() );
+
+    if( m_bPalette )
+    {
+        OSL_ENSURE(m_nIndexIndex != -1,
+                   "Invalid color channel indices");
+        ENSURE_OR_THROW(m_pBmpAcc,
+                        "Unable to get BitmapAccess");
+
+        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
+        {
+            const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
+                sal::static_int_cast<USHORT>(deviceColor[i+m_nIndexIndex]));
+
+            // TODO(F3): Convert result to sRGB color space
+            const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
+            *pOut++ = rendering::ARGBColor(nAlpha,
+                                           nAlpha*toDoubleColor(aCol.GetRed()),
+                                           nAlpha*toDoubleColor(aCol.GetGreen()),
+                                           nAlpha*toDoubleColor(aCol.GetBlue()));
+        }
+    }
+    else
+    {
+        OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
+                   "Invalid color channel indices");
+
+        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
+        {
+            // TODO(F3): Convert result to sRGB color space
+            const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
+            *pOut++ = rendering::ARGBColor(
+                nAlpha,
+                nAlpha*deviceColor[i+m_nRedIndex],
+                nAlpha*deviceColor[i+m_nGreenIndex],
+                nAlpha*deviceColor[i+m_nBlueIndex]);
+        }
+    }
+
+    return aRes;
+}
+
 uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromRGB( const uno::Sequence<rendering::RGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
 {
     vos::OGuard aGuard( Application::GetSolarMutex() );
@@ -950,6 +1002,48 @@ uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromARGB( const uno::Se
     return aRes;
 }
 
+uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromPARGB( const uno::Sequence<rendering::ARGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
+{
+    vos::OGuard aGuard( Application::GetSolarMutex() );
+
+    const sal_Size  nLen( rgbColor.getLength() );
+    const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
+
+    uno::Sequence< double > aRes(nLen*nComponentsPerPixel);
+    double* pColors=aRes.getArray();
+
+    if( m_bPalette )
+    {
+        for( sal_Size i=0; i<nLen; ++i )
+        {
+            const double nAlpha( rgbColor[i].Alpha );
+            pColors[m_nIndexIndex] = m_pBmpAcc->GetBestPaletteIndex(
+                    BitmapColor(toByteColor(rgbColor[i].Red / nAlpha),
+                                toByteColor(rgbColor[i].Green / nAlpha),
+                                toByteColor(rgbColor[i].Blue / nAlpha)));
+            if( m_nAlphaIndex != -1 )
+                pColors[m_nAlphaIndex] = nAlpha;
+
+            pColors += nComponentsPerPixel;
+        }
+    }
+    else
+    {
+        for( sal_Size i=0; i<nLen; ++i )
+        {
+            const double nAlpha( rgbColor[i].Alpha );
+            pColors[m_nRedIndex]   = rgbColor[i].Red / nAlpha;
+            pColors[m_nGreenIndex] = rgbColor[i].Green / nAlpha;
+            pColors[m_nBlueIndex]  = rgbColor[i].Blue / nAlpha;
+            if( m_nAlphaIndex != -1 )
+                pColors[m_nAlphaIndex] = nAlpha;
+
+            pColors += nComponentsPerPixel;
+        }
+    }
+    return aRes;
+}
+
 sal_Int32 SAL_CALL VclCanvasBitmap::getBitsPerPixel(  ) throw (uno::RuntimeException)
 {
     vos::OGuard aGuard( Application::GetSolarMutex() );
@@ -1163,6 +1257,65 @@ uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToAR
     return aRes;
 }
 
+uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToPARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
+{
+    vos::OGuard aGuard( Application::GetSolarMutex() );
+
+    const BYTE*     pIn( reinterpret_cast<const BYTE*>(deviceColor.getConstArray()) );
+    const sal_Size  nLen( deviceColor.getLength() );
+    const sal_Int32 nNumColors((nLen*8 + m_nBitsPerOutputPixel-1)/m_nBitsPerOutputPixel);
+
+    uno::Sequence< rendering::ARGBColor > aRes(nNumColors);
+    rendering::ARGBColor* pOut( aRes.getArray() );
+
+    ENSURE_OR_THROW(m_pBmpAcc,
+                    "Unable to get BitmapAccess");
+
+    if( m_aBmpEx.IsTransparent() )
+    {
+        const long      nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
+        const sal_Int32 nBytesPerPixel((m_nBitsPerOutputPixel+7)/8);
+        const sal_uInt8 nAlphaFactor( m_aBmpEx.IsAlpha() ? 1 : 255 );
+        for( sal_Size i=0; i<nLen; i+=nBytesPerPixel )
+        {
+            // if palette, index is guaranteed to be 8 bit
+            const BitmapColor aCol =
+                m_bPalette ?
+                m_pBmpAcc->GetPaletteColor(*pIn) :
+                m_pBmpAcc->GetPixelFromData(pIn,0);
+
+            // TODO(F3): Convert result to sRGB color space
+            const double nAlpha( 1.0 - toDoubleColor(nAlphaFactor*pIn[nNonAlphaBytes]) );
+            *pOut++ = rendering::ARGBColor(nAlpha,
+                                           nAlpha*toDoubleColor(aCol.GetRed()),
+                                           nAlpha*toDoubleColor(aCol.GetGreen()),
+                                           nAlpha*toDoubleColor(aCol.GetBlue()));
+            pIn += nBytesPerPixel;
+        }
+    }
+    else
+    {
+        for( sal_Int32 i=0; i<nNumColors; ++i )
+        {
+            const BitmapColor aCol =
+                m_bPalette ?
+                m_pBmpAcc->GetPaletteColor(
+                    sal::static_int_cast<USHORT>(
+                        m_pBmpAcc->GetPixelFromData(
+                            pIn, i ))) :
+                m_pBmpAcc->GetPixelFromData(pIn, i);
+
+            // TODO(F3): Convert result to sRGB color space
+            *pOut++ = rendering::ARGBColor(1.0,
+                                           toDoubleColor(aCol.GetRed()),
+                                           toDoubleColor(aCol.GetGreen()),
+                                           toDoubleColor(aCol.GetBlue()));
+        }
+    }
+
+    return aRes;
+}
+
 uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromRGB( const uno::Sequence<rendering::RGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
 {
     vos::OGuard aGuard( Application::GetSolarMutex() );
@@ -1261,6 +1414,56 @@ uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromARGB( co
     return aRes;
 }
 
+uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromPARGB( const uno::Sequence<rendering::ARGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
+{
+    vos::OGuard aGuard( Application::GetSolarMutex() );
+
+    const sal_Size  nLen( rgbColor.getLength() );
+    const sal_Int32 nNumBytes((nLen*m_nBitsPerOutputPixel+7)/8);
+
+    uno::Sequence< sal_Int8 > aRes(nNumBytes);
+    BYTE* pColors=reinterpret_cast<BYTE*>(aRes.getArray());
+
+    if( m_aBmpEx.IsTransparent() )
+    {
+        const long nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
+        for( sal_Size i=0; i<nLen; ++i )
+        {
+            const double nAlpha( rgbColor[i].Alpha );
+            const BitmapColor aCol(toByteColor(rgbColor[i].Red / nAlpha),
+                                   toByteColor(rgbColor[i].Green / nAlpha),
+                                   toByteColor(rgbColor[i].Blue / nAlpha));
+            const BitmapColor aCol2 =
+                m_bPalette ?
+                BitmapColor(
+                    sal::static_int_cast<BYTE>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
+                aCol;
+
+            m_pBmpAcc->SetPixelOnData(pColors,0,aCol2);
+            pColors   += nNonAlphaBytes;
+            *pColors++ = 255 - toByteColor(nAlpha);
+        }
+    }
+    else
+    {
+        for( sal_Size i=0; i<nLen; ++i )
+        {
+            const BitmapColor aCol(toByteColor(rgbColor[i].Red),
+                                   toByteColor(rgbColor[i].Green),
+                                   toByteColor(rgbColor[i].Blue));
+            const BitmapColor aCol2 =
+                m_bPalette ?
+                BitmapColor(
+                    sal::static_int_cast<BYTE>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
+                aCol;
+
+            m_pBmpAcc->SetPixelOnData(pColors,i,aCol2);
+        }
+    }
+
+    return aRes;
+}
+
 BitmapEx VclCanvasBitmap::getBitmapEx() const
 {
     return m_aBmpEx;
diff --git a/vcl/source/helper/canvastools.cxx b/vcl/source/helper/canvastools.cxx
index 3a239d7c3b3c..ca2803fd6009 100644
--- a/vcl/source/helper/canvastools.cxx
+++ b/vcl/source/helper/canvastools.cxx
@@ -250,28 +250,61 @@ namespace vcl
                     {
                         // read ARGB color
                         aARGBColors = rLayout.ColorSpace->convertIntegerToARGB(aPixelData);
-                        for( sal_Int32 x=0; x<nWidth; ++x )
+
+                        if( rWriteAcc->HasPalette() )
                         {
-                            const rendering::ARGBColor& rColor=aARGBColors[x];
-                            rWriteAcc->SetPixel( aRect.Y1, x,
-                                                 BitmapColor( toByteColor(rColor.Red),
-                                                              toByteColor(rColor.Green),
-                                                              toByteColor(rColor.Blue) ));
-                            rAlphaAcc->SetPixel( aRect.Y1, x,
-                                                 BitmapColor( 255 - toByteColor(rColor.Alpha) ));
+                            for( sal_Int32 x=0; x<nWidth; ++x )
+                            {
+                                const rendering::ARGBColor& rColor=aARGBColors[x];
+                                rWriteAcc->SetPixel( aRect.Y1, x,
+                                                     rWriteAcc->GetBestPaletteIndex(
+                                                         BitmapColor( toByteColor(rColor.Red),
+                                                                      toByteColor(rColor.Green),
+                                                                      toByteColor(rColor.Blue))) );
+                                rAlphaAcc->SetPixel( aRect.Y1, x,
+                                                     BitmapColor( 255 - toByteColor(rColor.Alpha) ));
+                            }
+                        }
+                        else
+                        {
+                            for( sal_Int32 x=0; x<nWidth; ++x )
+                            {
+                                const rendering::ARGBColor& rColor=aARGBColors[x];
+                                rWriteAcc->SetPixel( aRect.Y1, x,
+                                                     BitmapColor( toByteColor(rColor.Red),
+                                                                  toByteColor(rColor.Green),
+                                                                  toByteColor(rColor.Blue) ));
+                                rAlphaAcc->SetPixel( aRect.Y1, x,
+                                                     BitmapColor( 255 - toByteColor(rColor.Alpha) ));
+                            }
                         }
                     }
                     else
                     {
                         // read RGB color
                         aRGBColors = rLayout.ColorSpace->convertIntegerToRGB(aPixelData);
-                        for( sal_Int32 x=0; x<nWidth; ++x )
+                        if( rWriteAcc->HasPalette() )
+                        {
+                            for( sal_Int32 x=0; x<nWidth; ++x )
+                            {
+                                const rendering::RGBColor& rColor=aRGBColors[x];
+                                rWriteAcc->SetPixel( aRect.Y1, x,
+                                                     rWriteAcc->GetBestPaletteIndex(
+                                                         BitmapColor( toByteColor(rColor.Red),
+                                                                      toByteColor(rColor.Green),
+                                                                      toByteColor(rColor.Blue))) );
+                            }
+                        }
+                        else
                         {
-                            const rendering::RGBColor& rColor=aRGBColors[x];
-                            rWriteAcc->SetPixel( aRect.Y1, x,
-                                                 BitmapColor( toByteColor(rColor.Red),
-                                                              toByteColor(rColor.Green),
-                                                              toByteColor(rColor.Blue) ));
+                            for( sal_Int32 x=0; x<nWidth; ++x )
+                            {
+                                const rendering::RGBColor& rColor=aRGBColors[x];
+                                rWriteAcc->SetPixel( aRect.Y1, x,
+                                                     BitmapColor( toByteColor(rColor.Red),
+                                                                  toByteColor(rColor.Green),
+                                                                  toByteColor(rColor.Blue) ));
+                            }
                         }
                     }
                 }
@@ -404,7 +437,7 @@ namespace vcl
                 { // limit scoped access
                     ScopedBitmapWriteAccess pWriteAccess( aBitmap.AcquireWriteAccess(),
                                                           aBitmap );
-                    ScopedBitmapWriteAccess pAlphaWriteAccess( aAlpha.AcquireWriteAccess(),
+                    ScopedBitmapWriteAccess pAlphaWriteAccess( nAlphaDepth ? aAlpha.AcquireWriteAccess() : NULL,
                                                                aAlpha );
 
                     ENSURE_OR_THROW(pWriteAccess.get() != NULL,
@@ -652,6 +685,23 @@ namespace vcl
                     }
                     return aRes;
                 }
+                virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+                {
+                    const double*  pIn( deviceColor.getConstArray() );
+                    const sal_Size nLen( deviceColor.getLength() );
+                    ENSURE_ARG_OR_THROW2(nLen%4==0,
+                                         "number of channels no multiple of 4",
+                                         static_cast<rendering::XColorSpace*>(this), 0);
+
+                    uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
+                    rendering::ARGBColor* pOut( aRes.getArray() );
+                    for( sal_Size i=0; i<nLen; i+=4 )
+                    {
+                        *pOut++ = rendering::ARGBColor(pIn[3],pIn[3]*pIn[0],pIn[3]*pIn[1],pIn[3]*pIn[2]);
+                        pIn += 4;
+                    }
+                    return aRes;
+                }
                 virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
                 {
                     const rendering::RGBColor* pIn( rgbColor.getConstArray() );
@@ -686,6 +736,23 @@ namespace vcl
                     }
                     return aRes;
                 }
+                virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
+                {
+                    const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
+                    const sal_Size              nLen( rgbColor.getLength() );
+
+                    uno::Sequence< double > aRes(nLen*4);
+                    double* pColors=aRes.getArray();
+                    for( sal_Size i=0; i<nLen; ++i )
+                    {
+                        *pColors++ = pIn->Red/pIn->Alpha;
+                        *pColors++ = pIn->Green/pIn->Alpha;
+                        *pColors++ = pIn->Blue/pIn->Alpha;
+                        *pColors++ = pIn->Alpha;
+                        ++pIn;
+                    }
+                    return aRes;
+                }
 
             public:
                 StandardColorSpace() : m_aComponentTags(4)