/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_vcl.hxx"

// bootstrap stuff
#include <sal/main.h>
#include <rtl/bootstrap.hxx>
#include <rtl/ref.hxx>
#include <comphelper/processfactory.hxx>
#include <comphelper/regpathhelper.hxx>
#include <cppuhelper/servicefactory.hxx>
#include <cppuhelper/bootstrap.hxx>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/lang/XInitialization.hpp>
#include <com/sun/star/registry/XSimpleRegistry.hpp>
#include <com/sun/star/util/Endianness.hpp>
#include <com/sun/star/rendering/ColorComponentTag.hpp>
#include <com/sun/star/rendering/ColorSpaceType.hpp>
#include <com/sun/star/rendering/RenderingIntent.hpp>
#include <com/sun/star/rendering/XIntegerReadOnlyBitmap.hpp>
#include <com/sun/star/rendering/XIntegerBitmapColorSpace.hpp>
#include <com/sun/star/rendering/XBitmapPalette.hpp>

#include <ucbhelper/contentbroker.hxx>
#include <ucbhelper/configurationkeys.hxx>
#include <cppuhelper/compbase3.hxx>

#include <tools/diagnose_ex.h>
#include <tools/extendapplicationenvironment.hxx>

#include "vcl/svapp.hxx"
#include "vcl/canvastools.hxx"
#include "vcl/canvasbitmap.hxx"
#include "vcl/dialog.hxx"
#include "vcl/outdev.hxx"
#include "vcl/bmpacc.hxx"
#include "vcl/virdev.hxx"
#include "vcl/bitmapex.hxx"


using namespace ::com::sun::star;
using namespace ::vcl::unotools;

// -----------------------------------------------------------------------

void Main();

// -----------------------------------------------------------------------

SAL_IMPLEMENT_MAIN()
{
    tools::extendApplicationEnvironment();

    uno::Reference< lang::XMultiServiceFactory > xMS;
    xMS = cppu::createRegistryServiceFactory( 
        rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "applicat.rdb" ) ), 
        sal_True );

    InitVCL( xMS );
    ::Main();
    DeInitVCL();

    return 0;
}

// -----------------------------------------------------------------------

namespace com { namespace sun { namespace star { namespace rendering
{

bool operator==( const RGBColor& rLHS, const ARGBColor& rRHS )
{
    return rLHS.Red == rRHS.Red && rLHS.Green == rRHS.Green && rLHS.Blue == rRHS.Blue;
}
bool operator==( const ARGBColor& rLHS, const RGBColor& rRHS )
{
    return rLHS.Red == rRHS.Red && rLHS.Green == rRHS.Green && rLHS.Blue == rRHS.Blue;
}

} } } }

//----------------------------------------------------------------------------------

namespace
{

class TestApp : public Application
{
public:
	virtual void   Main();
	virtual USHORT Exception( USHORT nError );
};

class TestWindow : public Dialog
{
	public:
		TestWindow() : Dialog( (Window *) NULL )
		{
			SetText( rtl::OUString::createFromAscii( "CanvasBitmap test harness" ) );
			SetSizePixel( Size( 1024, 1024 ) );
			EnablePaint( true );
			Show();
		}

		virtual ~TestWindow() {}
		virtual void Paint( const Rectangle& rRect );
};

//----------------------------------------------------------------------------------

static bool g_failure=false;

void test( bool bResult, const char* msg )
{
    if( bResult )
    {
        OSL_TRACE("Testing: %s - PASSED", msg);
    }
    else
    {
        g_failure = true;
        OSL_TRACE("Testing: %s - FAILED", msg);
    }
}

//----------------------------------------------------------------------------------

bool rangeCheck( const rendering::RGBColor& rColor )
{
    return rColor.Red < 0.0 || rColor.Red > 1.0 ||
        rColor.Green < 0.0 || rColor.Green > 1.0 ||
        rColor.Blue < 0.0 || rColor.Blue > 1.0;
}

//----------------------------------------------------------------------------------

void checkCanvasBitmap( const rtl::Reference<VclCanvasBitmap>& xBmp, 
                        const char*                            msg,
                        int                                    nOriginalDepth )
{
    OSL_TRACE("-------------------------");
    OSL_TRACE("Testing %s, with depth %d", msg, nOriginalDepth);

    BitmapEx aContainedBmpEx( xBmp->getBitmapEx() );
    Bitmap   aContainedBmp( aContainedBmpEx.GetBitmap() );
    int      nDepth = nOriginalDepth;

    {
        ScopedBitmapReadAccess pAcc( aContainedBmp.AcquireReadAccess(),
                                     aContainedBmp );
        nDepth = pAcc->GetBitCount();
    }

    test( aContainedBmp.GetSizePixel() == Size(200,200),
          "Original bitmap size" );

    test( xBmp->getSize().Width == 200 && xBmp->getSize().Height == 200,
          "Original bitmap size via API" );

    test( xBmp->hasAlpha() == aContainedBmpEx.IsTransparent(),
          "Correct alpha state" );

    test( xBmp->getScaledBitmap( geometry::RealSize2D(500,500), sal_False ).is(),
          "getScaledBitmap()" );

    rendering::IntegerBitmapLayout aLayout;
    uno::Sequence<sal_Int8> aPixelData = xBmp->getData(aLayout, geometry::IntegerRectangle2D(0,0,1,1));
    
    const sal_Int32 nExpectedBitsPerPixel(
        aContainedBmpEx.IsTransparent() ? std::max(8,nDepth)+8 : nDepth);
    test( aLayout.ScanLines == 1,
          "# scanlines" );
    test( aLayout.ScanLineBytes == (nExpectedBitsPerPixel+7)/8,
          "# scanline bytes" );
    test( aLayout.ScanLineStride == (nExpectedBitsPerPixel+7)/8 ||
          aLayout.ScanLineStride == -(nExpectedBitsPerPixel+7)/8,
          "# scanline stride" );
    test( aLayout.PlaneStride == 0,
          "# plane stride" );

    test( aLayout.ColorSpace.is(),
          "Color space there" );

    test( aLayout.Palette.is() == (nDepth <= 8),
          "Palette existance conforms to bitmap" );

    uno::Sequence<sal_Int8> aPixelData2 = xBmp->getPixel( aLayout, geometry::IntegerPoint2D(0,0) );
    
    test( aPixelData2.getLength() == aPixelData.getLength(),
          "getData and getPixel return same amount of data" );

    aPixelData = xBmp->getData(aLayout, geometry::IntegerRectangle2D(0,0,200,1));
    test( aLayout.ScanLines == 1,
          "# scanlines" );
    test( aLayout.ScanLineBytes == (200*nExpectedBitsPerPixel+7)/8,
          "# scanline bytes" );
    test( aLayout.ScanLineStride == (200*nExpectedBitsPerPixel+7)/8 ||
          aLayout.ScanLineStride == -(200*nExpectedBitsPerPixel+7)/8,
          "# scanline stride" );

    uno::Sequence< rendering::RGBColor >  aRGBColors  = xBmp->convertIntegerToRGB( aPixelData );
    uno::Sequence< rendering::ARGBColor > aARGBColors = xBmp->convertIntegerToARGB( aPixelData );

    const rendering::RGBColor*  pRGBStart ( aRGBColors.getConstArray() );
    const rendering::RGBColor*  pRGBEnd   ( aRGBColors.getConstArray()+aRGBColors.getLength() );
    const rendering::ARGBColor* pARGBStart( aARGBColors.getConstArray() );
    std::pair<const rendering::RGBColor*,
        const rendering::ARGBColor*> aRes = std::mismatch( pRGBStart, pRGBEnd, pARGBStart );
    test( aRes.first == pRGBEnd,
          "argb and rgb colors are equal" );

    test( std::find_if(pRGBStart,pRGBEnd,&rangeCheck) == pRGBEnd,
          "rgb colors are within [0,1] range" );

    test( pRGBStart[0].Red == 1.0 && pRGBStart[0].Green == 1.0 && pRGBStart[0].Blue == 1.0,
          "First pixel is white" );
    test( pARGBStart[1].Alpha == 1.0,
          "Second pixel is opaque" );
    if( aContainedBmpEx.IsTransparent() )
    {
        test( pARGBStart[0].Alpha == 0.0,
              "First pixel is fully transparent" );
    }
 
    test( pRGBStart[1].Red == 0.0 && pRGBStart[1].Green == 0.0 && pRGBStart[1].Blue == 0.0,
          "Second pixel is black" );

    if( nOriginalDepth > 8 )
    {
        const Color aCol(COL_GREEN);
        test( pRGBStart[5].Red == vcl::unotools::toDoubleColor(aCol.GetRed()) && 
              pRGBStart[5].Green == vcl::unotools::toDoubleColor(aCol.GetGreen()) && 
              pRGBStart[5].Blue == vcl::unotools::toDoubleColor(aCol.GetBlue()),
              "Sixth pixel is green" );
    }
    else if( nDepth <= 8 )
    {
        uno::Reference<rendering::XBitmapPalette> xPal = xBmp->getPalette();
        test( xPal.is(),
              "8bit or less: needs palette" );
        test( xPal->getNumberOfEntries() == 1L << nOriginalDepth,
              "Palette has correct entry count" );
        uno::Sequence<double> aIndex;
        test( xPal->setIndex(aIndex,sal_True,0) == sal_False,
              "Palette is read-only" );
        test( xPal->getIndex(aIndex,0),
              "Palette entry 0 is opaque" );
        test( xPal->getColorSpace().is(),
              "Palette has a valid color space" );
    }

    test( pRGBStart[150].Red == 1.0 && pRGBStart[150].Green == 1.0 && pRGBStart[150].Blue == 1.0,
          "150th pixel is white" );

    if( nOriginalDepth > 8 )
    {
        const uno::Sequence<sal_Int8> aComponentTags( xBmp->getComponentTags() );
        uno::Sequence<rendering::ARGBColor> aARGBColor(1);
        uno::Sequence<rendering::RGBColor>  aRGBColor(1);
        uno::Sequence<sal_Int8> aPixel3, aPixel4;

        const Color aCol(COL_GREEN);
        aARGBColor[0].Red   = vcl::unotools::toDoubleColor(aCol.GetRed());
        aARGBColor[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
        aARGBColor[0].Blue  = vcl::unotools::toDoubleColor(aCol.GetBlue());
        aARGBColor[0].Alpha = 1.0;

        aRGBColor[0].Red   = vcl::unotools::toDoubleColor(aCol.GetRed());
        aRGBColor[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
        aRGBColor[0].Blue  = vcl::unotools::toDoubleColor(aCol.GetBlue());

        aPixel3 = xBmp->convertIntegerFromARGB( aARGBColor );
        aPixel4 = xBmp->getPixel( aLayout, geometry::IntegerPoint2D(5,0) );
        test( aPixel3 == aPixel4,
              "Green pixel from bitmap matches with manually converted green pixel" );

        if( !aContainedBmpEx.IsTransparent() )
        {
            aPixel3 = xBmp->convertIntegerFromRGB( aRGBColor );
            test( aPixel3 == aPixel4,
                  "Green pixel from bitmap matches with manually RGB-converted green pixel" );
        }
    }
}

//----------------------------------------------------------------------------------

void checkBitmapImport( const rtl::Reference<VclCanvasBitmap>& xBmp, 
                        const char*                            msg,
                        int                                    nOriginalDepth )
{
    OSL_TRACE("-------------------------");
    OSL_TRACE("Testing %s, with depth %d", msg, nOriginalDepth);

    BitmapEx aContainedBmpEx( xBmp->getBitmapEx() );
    Bitmap   aContainedBmp( aContainedBmpEx.GetBitmap() );
    int      nDepth = nOriginalDepth;

    {
        ScopedBitmapReadAccess pAcc( aContainedBmp.AcquireReadAccess(),
                                     aContainedBmp );
        nDepth = pAcc->GetBitCount();
    }

    test( aContainedBmp.GetSizePixel() == Size(200,200),
          "Original bitmap size" );

    test( xBmp->getSize().Width == 200 && xBmp->getSize().Height == 200,
          "Original bitmap size via API" );

    test( xBmp->hasAlpha() == aContainedBmpEx.IsTransparent(),
          "Correct alpha state" );

    test( xBmp->getScaledBitmap( geometry::RealSize2D(500,500), sal_False ).is(),
          "getScaledBitmap()" );

    rendering::IntegerBitmapLayout aLayout;
    uno::Sequence<sal_Int8> aPixelData = xBmp->getData(aLayout, geometry::IntegerRectangle2D(0,0,1,1));
    
    const sal_Int32 nExpectedBitsPerPixel(
        aContainedBmpEx.IsTransparent() ? std::max(8,nDepth)+8 : nDepth);
    test( aLayout.ScanLines == 1,
          "# scanlines" );
    test( aLayout.ScanLineBytes == (nExpectedBitsPerPixel+7)/8,
          "# scanline bytes" );
    test( aLayout.ScanLineStride == (nExpectedBitsPerPixel+7)/8 ||
          aLayout.ScanLineStride == -(nExpectedBitsPerPixel+7)/8,
          "# scanline stride" );
    test( aLayout.PlaneStride == 0,
          "# plane stride" );

    test( aLayout.ColorSpace.is(),
          "Color space there" );

    test( aLayout.Palette.is() == (nDepth <= 8),
          "Palette existance conforms to bitmap" );

    uno::Sequence<sal_Int8> aPixelData2 = xBmp->getPixel( aLayout, geometry::IntegerPoint2D(0,0) );
    
    test( aPixelData2.getLength() == aPixelData.getLength(),
          "getData and getPixel return same amount of data" );

    aPixelData = xBmp->getData(aLayout, geometry::IntegerRectangle2D(0,0,200,1));
    test( aLayout.ScanLines == 1,
          "# scanlines" );
    test( aLayout.ScanLineBytes == (200*nExpectedBitsPerPixel+7)/8,
          "# scanline bytes" );
    test( aLayout.ScanLineStride == (200*nExpectedBitsPerPixel+7)/8 ||
          aLayout.ScanLineStride == -(200*nExpectedBitsPerPixel+7)/8,
          "# scanline stride" );

    uno::Sequence< rendering::RGBColor >  aRGBColors  = xBmp->convertIntegerToRGB( aPixelData );
    uno::Sequence< rendering::ARGBColor > aARGBColors = xBmp->convertIntegerToARGB( aPixelData );

    const rendering::RGBColor*  pRGBStart ( aRGBColors.getConstArray() );
    const rendering::RGBColor*  pRGBEnd   ( aRGBColors.getConstArray()+aRGBColors.getLength() );
    const rendering::ARGBColor* pARGBStart( aARGBColors.getConstArray() );
    std::pair<const rendering::RGBColor*,
        const rendering::ARGBColor*> aRes = std::mismatch( pRGBStart, pRGBEnd, pARGBStart );
    test( aRes.first == pRGBEnd,
          "argb and rgb colors are equal" );

    test( std::find_if(pRGBStart,pRGBEnd,&rangeCheck) == pRGBEnd,
          "rgb colors are within [0,1] range" );

    test( pRGBStart[0].Red == 1.0 && pRGBStart[0].Green == 1.0 && pRGBStart[0].Blue == 1.0,
          "First pixel is white" );
    test( pARGBStart[1].Alpha == 1.0,
          "Second pixel is opaque" );
    if( aContainedBmpEx.IsTransparent() )
    {
        test( pARGBStart[0].Alpha == 0.0,
              "First pixel is fully transparent" );
    }
 
    test( pRGBStart[1].Red == 0.0 && pRGBStart[1].Green == 0.0 && pRGBStart[1].Blue == 0.0,
          "Second pixel is black" );

    if( nOriginalDepth > 8 )
    {
        const Color aCol(COL_GREEN);
        test( pRGBStart[5].Red == vcl::unotools::toDoubleColor(aCol.GetRed()) && 
              pRGBStart[5].Green == vcl::unotools::toDoubleColor(aCol.GetGreen()) && 
              pRGBStart[5].Blue == vcl::unotools::toDoubleColor(aCol.GetBlue()),
              "Sixth pixel is green" );
    }
    else if( nDepth <= 8 )
    {
        uno::Reference<rendering::XBitmapPalette> xPal = xBmp->getPalette();
        test( xPal.is(),
              "8bit or less: needs palette" );
        test( xPal->getNumberOfEntries() == 1L << nOriginalDepth,
              "Palette has correct entry count" );
        uno::Sequence<double> aIndex;
        test( xPal->setIndex(aIndex,sal_True,0) == sal_False,
              "Palette is read-only" );
        test( xPal->getIndex(aIndex,0),
              "Palette entry 0 is opaque" );
        test( xPal->getColorSpace().is(),
              "Palette has a valid color space" );
    }

    test( pRGBStart[150].Red == 1.0 && pRGBStart[150].Green == 1.0 && pRGBStart[150].Blue == 1.0,
          "150th pixel is white" );

    if( nOriginalDepth > 8 )
    {
        const uno::Sequence<sal_Int8> aComponentTags( xBmp->getComponentTags() );
        uno::Sequence<rendering::ARGBColor> aARGBColor(1);
        uno::Sequence<rendering::RGBColor>  aRGBColor(1);
        uno::Sequence<sal_Int8> aPixel3, aPixel4;

        const Color aCol(COL_GREEN);
        aARGBColor[0].Red   = vcl::unotools::toDoubleColor(aCol.GetRed());
        aARGBColor[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
        aARGBColor[0].Blue  = vcl::unotools::toDoubleColor(aCol.GetBlue());
        aARGBColor[0].Alpha = 1.0;

        aRGBColor[0].Red   = vcl::unotools::toDoubleColor(aCol.GetRed());
        aRGBColor[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
        aRGBColor[0].Blue  = vcl::unotools::toDoubleColor(aCol.GetBlue());

        aPixel3 = xBmp->convertIntegerFromARGB( aARGBColor );
        aPixel4 = xBmp->getPixel( aLayout, geometry::IntegerPoint2D(5,0) );
        test( aPixel3 == aPixel4,
              "Green pixel from bitmap matches with manually converted green pixel" );

        if( !aContainedBmpEx.IsTransparent() )
        {
            aPixel3 = xBmp->convertIntegerFromRGB( aRGBColor );
            test( aPixel3 == aPixel4,
                  "Green pixel from bitmap matches with manually RGB-converted green pixel" );
        }
    }
}

//----------------------------------------------------------------------------------

class TestBitmap : public cppu::WeakImplHelper3< rendering::XIntegerReadOnlyBitmap,
                                                 rendering::XBitmapPalette,
                                                 rendering::XIntegerBitmapColorSpace >
{
private:
    geometry::IntegerSize2D        maSize;
    uno::Sequence<sal_Int8>        maComponentTags;
    uno::Sequence<sal_Int32>       maComponentBitCounts;
    rendering::IntegerBitmapLayout maLayout;
    const sal_Int32                mnBitsPerPixel;

    // XBitmap
    virtual geometry::IntegerSize2D SAL_CALL getSize() throw (uno::RuntimeException) { return maSize; }
    virtual ::sal_Bool SAL_CALL hasAlpha(  ) throw (uno::RuntimeException) { return mnBitsPerPixel != 8; }
    virtual uno::Reference< rendering::XBitmap > SAL_CALL getScaledBitmap( const geometry::RealSize2D&, 
                                                                           sal_Bool ) throw (uno::RuntimeException) { return this; }

    // XIntegerReadOnlyBitmap
    virtual uno::Sequence< ::sal_Int8 > SAL_CALL getData( rendering::IntegerBitmapLayout&     bitmapLayout, 
                                                          const geometry::IntegerRectangle2D& rect ) throw (lang::IndexOutOfBoundsException, 
                                                                                                            rendering::VolatileContentDestroyedException, uno::RuntimeException)
    {
        test( rect.X1 >= 0, "X1 within bounds" );
        test( rect.Y1 >= 0, "Y1 within bounds" );
        test( rect.X2 <= maSize.Width,  "X2 within bounds" );
        test( rect.Y2 <= maSize.Height, "Y2 within bounds" );

        bitmapLayout = getMemoryLayout();

        const sal_Int32 nWidth  = rect.X2-rect.X1;
        const sal_Int32 nHeight = rect.Y2-rect.Y1;
        const sal_Int32 nScanlineLen = (nWidth * mnBitsPerPixel + 7)/8;
        uno::Sequence<sal_Int8> aRes( nScanlineLen * nHeight );
        sal_Int8* pOut = aRes.getArray();

        bitmapLayout.ScanLines     = nHeight;
        bitmapLayout.ScanLineBytes = 
        bitmapLayout.ScanLineStride= nScanlineLen;
        
        if( mnBitsPerPixel == 8 )
        {
            for( sal_Int32 y=0; y<nHeight; ++y )
            {
                for( sal_Int32 x=0; x<nWidth; ++x )
                    pOut[ y*nScanlineLen + x ] = sal_Int8(x);
            }
        }
        else
        {
            for( sal_Int32 y=0; y<nHeight; ++y )
            {
                for( sal_Int32 x=0; x<nWidth; ++x )
                {
                    pOut[ y*nScanlineLen + 4*x     ] = sal_Int8(rect.X1);
                    pOut[ y*nScanlineLen + 4*x + 1 ] = sal_Int8(rect.Y2);
                    pOut[ y*nScanlineLen + 4*x + 2 ] = sal_Int8(x);
                    pOut[ y*nScanlineLen + 4*x + 3 ] = sal_Int8(rect.Y1);
                }
            }
        }

        return aRes;
    }

    virtual uno::Sequence< ::sal_Int8 > SAL_CALL getPixel( rendering::IntegerBitmapLayout&, 
                                                           const geometry::IntegerPoint2D&  ) throw (lang::IndexOutOfBoundsException, 
                                                                                                     rendering::VolatileContentDestroyedException, uno::RuntimeException)
    {
        test(false, "Method not implemented");
        return uno::Sequence< sal_Int8 >();
    }

    virtual uno::Reference< rendering::XBitmapPalette > SAL_CALL getPalette(  ) throw (uno::RuntimeException)
    {
        uno::Reference< XBitmapPalette > aRet;
        if( mnBitsPerPixel == 8 )
            aRet.set(this);
        return aRet;
    }

    virtual rendering::IntegerBitmapLayout SAL_CALL getMemoryLayout(  ) throw (uno::RuntimeException)
    {
        rendering::IntegerBitmapLayout aLayout( maLayout );

        const sal_Int32 nScanlineLen = (maSize.Width * mnBitsPerPixel + 7)/8;

        aLayout.ScanLines     = maSize.Height;
        aLayout.ScanLineBytes = 
        aLayout.ScanLineStride= nScanlineLen;
        aLayout.Palette = getPalette();
        aLayout.ColorSpace.set( this );

        return aLayout;
    }

    // XBitmapPalette
    virtual sal_Int32 SAL_CALL getNumberOfEntries() throw (uno::RuntimeException)
    {
        test( getPalette().is(),
              "Got palette interface call without handing out palette?!" );

        return 255;
    }

    virtual ::sal_Bool SAL_CALL getIndex( uno::Sequence< double >& entry, 
                                          ::sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, 
                                                                      uno::RuntimeException)
    {
        test( getPalette().is(),
              "Got palette interface call without handing out palette?!" );
        test( nIndex >= 0 && nIndex < 256,
              "Index out of range" );
        entry = colorToStdColorSpaceSequence( 
            Color(UINT8(nIndex), 
                  UINT8(nIndex), 
                  UINT8(nIndex)) );

        return sal_True; // no palette transparency here.
    }

    virtual ::sal_Bool SAL_CALL setIndex( const uno::Sequence< double >&, 
                                          ::sal_Bool, 
                                          ::sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, 
                                                                      lang::IllegalArgumentException, 
                                                                      uno::RuntimeException)
    {
        test( getPalette().is(),
              "Got palette interface call without handing out palette?!" );
        test( nIndex >= 0 && nIndex < 256,
              "Index out of range" );
        return sal_False;
    }

    struct PaletteColorSpaceHolder: public rtl::StaticWithInit<uno::Reference<rendering::XColorSpace>,
                                                               PaletteColorSpaceHolder> 
    {
        uno::Reference<rendering::XColorSpace> operator()()
        {
            return vcl::unotools::createStandardColorSpace();
        }
    }; 

    virtual uno::Reference< rendering::XColorSpace > SAL_CALL getColorSpace(  ) throw (uno::RuntimeException)
    {
        // this is the method from XBitmapPalette. Return palette color
        // space here
        return PaletteColorSpaceHolder::get();
    }

    // XIntegerBitmapColorSpace
    virtual ::sal_Int8 SAL_CALL getType(  ) throw (uno::RuntimeException)
    {
        return rendering::ColorSpaceType::RGB;
    }

    virtual uno::Sequence< sal_Int8 > SAL_CALL getComponentTags(  ) throw (uno::RuntimeException)
    {
        return maComponentTags;
    }

    virtual ::sal_Int8 SAL_CALL getRenderingIntent(  ) throw (uno::RuntimeException)
    {
        return rendering::RenderingIntent::PERCEPTUAL;
    }

    virtual uno::Sequence< beans::PropertyValue > SAL_CALL getProperties(  ) throw (uno::RuntimeException)
    {
        test(false, "Method not implemented");
        return uno::Sequence< ::beans::PropertyValue >();
    }

    virtual uno::Sequence< double > SAL_CALL convertColorSpace( const uno::Sequence< double >&, 
                                                                const uno::Reference< rendering::XColorSpace >& ) throw (uno::RuntimeException)
    {
        test(false, "Method not implemented");
        return uno::Sequence< double >();
    }

    virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& ) throw (lang::IllegalArgumentException, 
                                                                                                                uno::RuntimeException)
    {
        test(false, "Method not implemented");
        return uno::Sequence< rendering::RGBColor >();
    }

    virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& ) throw (lang::IllegalArgumentException, 
                                                                                                                  uno::RuntimeException)
    {
        test(false, "Method not implemented");
        return uno::Sequence< rendering::ARGBColor >();
    }

    virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& ) throw (lang::IllegalArgumentException, 
                                                                                                                   uno::RuntimeException)
    {
        test(false, "Method not implemented");
        return uno::Sequence< rendering::ARGBColor >();
    }

    virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& ) throw (lang::IllegalArgumentException, 
                                                                                                                  uno::RuntimeException)
    {
        test(false, "Method not implemented");
        return uno::Sequence< double >();
    }

    virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& ) throw (lang::IllegalArgumentException, 
                                                                                                                    uno::RuntimeException)
    {
        test(false, "This method is not expected to be called!");
        return uno::Sequence< double >();
    }

    virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& ) throw (lang::IllegalArgumentException, 
                                                                                                                    uno::RuntimeException)
    {
        test(false, "This method is not expected to be called!");
        return uno::Sequence< double >();
    }

    virtual ::sal_Int32 SAL_CALL getBitsPerPixel(  ) throw (uno::RuntimeException)
    {
        return mnBitsPerPixel;
    }

    virtual uno::Sequence< ::sal_Int32 > SAL_CALL getComponentBitCounts(  ) throw (uno::RuntimeException)
    {
        return maComponentBitCounts;
    }

    virtual ::sal_Int8 SAL_CALL getEndianness(  ) throw (uno::RuntimeException)
    {
        return util::Endianness::LITTLE;
    }

    virtual uno::Sequence< double > SAL_CALL convertFromIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& , 
                                                                           const uno::Reference< rendering::XColorSpace >& ) throw (lang::IllegalArgumentException, 
                                                                                                                                    uno::RuntimeException)
    {
        test(false, "Method not implemented");
        return uno::Sequence< double >();
    }

    virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertToIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& , 
                                                                             const uno::Reference< rendering::XIntegerBitmapColorSpace >& ) throw (lang::IllegalArgumentException, 
                                                                                                                                                   uno::RuntimeException)
    {
        test(false, "Method not implemented");
        return uno::Sequence< sal_Int8 >();
    }

    virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertIntegerToRGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, 
                                                                                                                                       uno::RuntimeException)
    {
        const uno::Sequence< rendering::ARGBColor > aTemp( convertIntegerToARGB(deviceColor) );
        const sal_Size nLen(aTemp.getLength());
        uno::Sequence< rendering::RGBColor > aRes( nLen );
        rendering::RGBColor* pOut = aRes.getArray();
        for( sal_Size i=0; i<nLen; ++i )
        {
            *pOut++ = rendering::RGBColor(aTemp[i].Red,
                                          aTemp[i].Green,
                                          aTemp[i].Blue);
        }

        return aRes;
    }

    virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, 
                                                                                                                                         uno::RuntimeException)
    {
        const sal_Size  nLen( deviceColor.getLength() );
        const sal_Int32 nBytesPerPixel(mnBitsPerPixel == 8 ? 1 : 4);
        test(nLen%nBytesPerPixel==0, 
             "number of channels no multiple of pixel element count");

        uno::Sequence< rendering::ARGBColor > aRes( nLen / nBytesPerPixel );
        rendering::ARGBColor* pOut( aRes.getArray() );

        if( getPalette().is() )
        {
            for( sal_Size i=0; i<nLen; ++i )
            {
                *pOut++ = rendering::ARGBColor(
                    1.0,
                    vcl::unotools::toDoubleColor(deviceColor[i]),
                    vcl::unotools::toDoubleColor(deviceColor[i]),
                    vcl::unotools::toDoubleColor(deviceColor[i]));
            }
        }
        else
        {
            for( sal_Size i=0; i<nLen; i+=4 )
            {
                *pOut++ = rendering::ARGBColor(
                    vcl::unotools::toDoubleColor(deviceColor[i+3]),
                    vcl::unotools::toDoubleColor(deviceColor[i+0]),
                    vcl::unotools::toDoubleColor(deviceColor[i+1]),
                    vcl::unotools::toDoubleColor(deviceColor[i+2]));
            }
        }

        return aRes;
    }

    virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToPARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, 
                                                                                                                                         uno::RuntimeException)
    {
        const sal_Size  nLen( deviceColor.getLength() );
        const sal_Int32 nBytesPerPixel(mnBitsPerPixel == 8 ? 1 : 4);
        test(nLen%nBytesPerPixel==0, 
             "number of channels no multiple of pixel element count");

        uno::Sequence< rendering::ARGBColor > aRes( nLen / nBytesPerPixel );
        rendering::ARGBColor* pOut( aRes.getArray() );

        if( getPalette().is() )
        {
            for( sal_Size i=0; i<nLen; ++i )
            {
                *pOut++ = rendering::ARGBColor(
                    1.0,
                    vcl::unotools::toDoubleColor(deviceColor[i]),
                    vcl::unotools::toDoubleColor(deviceColor[i]),
                    vcl::unotools::toDoubleColor(deviceColor[i]));
            }
        }
        else
        {
            for( sal_Size i=0; i<nLen; i+=4 )
            {
                const double fAlpha=vcl::unotools::toDoubleColor(deviceColor[i+3]);
                *pOut++ = rendering::ARGBColor(
                    fAlpha,
                    fAlpha*vcl::unotools::toDoubleColor(deviceColor[i+0]),
                    fAlpha*vcl::unotools::toDoubleColor(deviceColor[i+1]),
                    fAlpha*vcl::unotools::toDoubleColor(deviceColor[i+2]));
            }
        }

        return aRes;
    }

    virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromRGB( const uno::Sequence< rendering::RGBColor >& ) throw (lang::IllegalArgumentException, 
                                                                                                                             uno::RuntimeException)
    {
        test(false, "Method not implemented");
        return uno::Sequence< sal_Int8 >();
    }

    virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromARGB( const uno::Sequence< rendering::ARGBColor >& ) throw (lang::IllegalArgumentException, 
                                                                                                                               uno::RuntimeException)
    {
        test(false, "Method not implemented");
        return uno::Sequence< sal_Int8 >();
    }

    virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromPARGB( const uno::Sequence< rendering::ARGBColor >& ) throw (lang::IllegalArgumentException, 
                                                                                                                                uno::RuntimeException)
    {
        test(false, "Method not implemented");
        return uno::Sequence< sal_Int8 >();
    }

public:
    TestBitmap( const geometry::IntegerSize2D& rSize, bool bPalette ) :
        maSize(rSize),
        maComponentTags(),
        maComponentBitCounts(),
        maLayout(),
        mnBitsPerPixel( bPalette ? 8 : 32 )
    {
        if( bPalette )
        {
            maComponentTags.realloc(1);
            maComponentTags[0] = rendering::ColorComponentTag::INDEX;

            maComponentBitCounts.realloc(1);
            maComponentBitCounts[0] = 8;
        }
        else
        {
            maComponentTags.realloc(4);
            sal_Int8* pTags = maComponentTags.getArray();
            pTags[0]        = rendering::ColorComponentTag::RGB_BLUE;
            pTags[1]        = rendering::ColorComponentTag::RGB_GREEN;
            pTags[2]        = rendering::ColorComponentTag::RGB_RED;
            pTags[3]        = rendering::ColorComponentTag::ALPHA;

            maComponentBitCounts.realloc(4);
            sal_Int32* pCounts = maComponentBitCounts.getArray();
            pCounts[0]         = 8;
            pCounts[1]         = 8;
            pCounts[2]         = 8;
            pCounts[3]         = 8;
        }

        maLayout.ScanLines      = 0;
        maLayout.ScanLineBytes  = 0;
        maLayout.ScanLineStride = 0;
        maLayout.PlaneStride    = 0;
        maLayout.ColorSpace.clear();
        maLayout.Palette.clear();
        maLayout.IsMsbFirst     = sal_False;
    }
};


//----------------------------------------------------------------------------------

void TestWindow::Paint( const Rectangle& )
{
    static sal_Int8 lcl_depths[]={1,4,8,16,24};

    try
    {
        // Testing VclCanvasBitmap wrapper
        // ===============================

        for( unsigned int i=0; i<sizeof(lcl_depths)/sizeof(*lcl_depths); ++i )
        {
            const sal_Int8 nDepth( lcl_depths[i] );
            Bitmap aBitmap(Size(200,200),nDepth);
            aBitmap.Erase(COL_WHITE);
            {
                ScopedBitmapWriteAccess pAcc(aBitmap.AcquireWriteAccess(),
                                             aBitmap);
                if( pAcc.get() )
                {
                    BitmapColor aBlack(0);
                    BitmapColor aWhite(0);
                    if( pAcc->HasPalette() )
                    {
                        aBlack.SetIndex( sal::static_int_cast<BYTE>(pAcc->GetBestPaletteIndex(BitmapColor(0,0,0))) );
                        aWhite.SetIndex( sal::static_int_cast<BYTE>(pAcc->GetBestPaletteIndex(BitmapColor(255,255,255))) );
                    }
                    else
                    {
                        aBlack = Color(COL_BLACK);
                        aWhite = Color(COL_WHITE);
                    }
                    pAcc->SetFillColor(COL_GREEN);
                    pAcc->FillRect(Rectangle(0,0,100,100));
                    pAcc->SetPixel(0,0,aWhite);
                    pAcc->SetPixel(0,1,aBlack);
                    pAcc->SetPixel(0,2,aWhite);
                }
            }
    
            rtl::Reference<VclCanvasBitmap> xBmp( new VclCanvasBitmap(aBitmap) );

            checkCanvasBitmap( xBmp, "single bitmap", nDepth );

            Bitmap aMask(Size(200,200),1);
            aMask.Erase(COL_WHITE);
            {
                ScopedBitmapWriteAccess pAcc(aMask.AcquireWriteAccess(),
                                             aMask);
                if( pAcc.get() )
                {
                    pAcc->SetFillColor(COL_BLACK);
                    pAcc->FillRect(Rectangle(0,0,100,100));
                    pAcc->SetPixel(0,0,BitmapColor(1));
                    pAcc->SetPixel(0,1,BitmapColor(0));
                    pAcc->SetPixel(0,2,BitmapColor(1));
                }
            }
    
            xBmp.set( new VclCanvasBitmap(BitmapEx(aBitmap,aMask)) );

            checkCanvasBitmap( xBmp, "masked bitmap", nDepth );

            AlphaMask aAlpha(Size(200,200));
            aAlpha.Erase(255);
            {
                BitmapWriteAccess* pAcc = aAlpha.AcquireWriteAccess();
                if( pAcc )
                {
                    pAcc->SetFillColor(COL_BLACK);
                    pAcc->FillRect(Rectangle(0,0,100,100));
                    pAcc->SetPixel(0,0,BitmapColor(255));
                    pAcc->SetPixel(0,1,BitmapColor(0));
                    pAcc->SetPixel(0,2,BitmapColor(255));
                    aAlpha.ReleaseAccess(pAcc);
                }
            }
    
            xBmp.set( new VclCanvasBitmap(BitmapEx(aBitmap,aAlpha)) );

            checkCanvasBitmap( xBmp, "alpha bitmap", nDepth );
        }

        // Testing XBitmap import
        // ======================
        uno::Reference< rendering::XIntegerReadOnlyBitmap > xTestBmp(
            new TestBitmap( geometry::IntegerSize2D(10,10), true ));

        BitmapEx aBmp = vcl::unotools::bitmapExFromXBitmap(xTestBmp);
        test( aBmp.IsTransparent() == false,
              "Palette bitmap is not transparent" );
        test( aBmp.GetSizePixel() == Size(10,10),
              "Bitmap has size (10,10)" );
        test( aBmp.GetBitCount() == 8,
              "Bitmap has bitcount of 8" );
        {
            BitmapReadAccess* pBmpAcc   = aBmp.GetBitmap().AcquireReadAccess();

            test( pBmpAcc,
                  "Bitmap has valid BitmapReadAccess" );

            test(pBmpAcc->GetPixel(0,0) == BitmapColor(0),
                 "(0,0) correct content");
            test(pBmpAcc->GetPixel(2,2) == BitmapColor(2),
                 "(2,2) correct content");
            test(pBmpAcc->GetPixel(2,9) == BitmapColor(9),
                 "(9,2) correct content");

            aBmp.GetBitmap().ReleaseAccess(pBmpAcc);
        }

        xTestBmp.set( new TestBitmap( geometry::IntegerSize2D(10,10), false ));

        aBmp = vcl::unotools::bitmapExFromXBitmap(xTestBmp);
        test( aBmp.IsTransparent() == TRUE,
              "Palette bitmap is transparent" );
        test( aBmp.IsAlpha() == TRUE,
              "Palette bitmap has alpha" );
        test( aBmp.GetSizePixel() == Size(10,10),
              "Bitmap has size (10,10)" );
        test( aBmp.GetBitCount() == 24,
              "Bitmap has bitcount of 24" );
        {
            BitmapReadAccess* pBmpAcc   = aBmp.GetBitmap().AcquireReadAccess();
            BitmapReadAccess* pAlphaAcc = aBmp.GetAlpha().AcquireReadAccess();

            test( pBmpAcc,
                  "Bitmap has valid BitmapReadAccess" );
            test( pAlphaAcc,
                  "Bitmap has valid alpha BitmapReadAccess" );

            test(pBmpAcc->GetPixel(0,0) == BitmapColor(0,1,0),
                 "(0,0) correct content");
            test(pAlphaAcc->GetPixel(0,0) == BitmapColor(255),
                 "(0,0) correct alpha content");
            test(pBmpAcc->GetPixel(2,2) == BitmapColor(0,3,2),
                 "(2,2) correct content");
            test(pAlphaAcc->GetPixel(2,2) == BitmapColor(253),
                 "(2,2) correct alpha content");
            test(pBmpAcc->GetPixel(2,9) == BitmapColor(0,3,9),
                 "(9,2) correct content");
            test(pAlphaAcc->GetPixel(2,9) == BitmapColor(253),
                 "(9,2) correct alpha content");

            aBmp.GetAlpha().ReleaseAccess(pAlphaAcc);
            aBmp.GetBitmap().ReleaseAccess(pBmpAcc);
        }
    }
    catch( uno::Exception& )
    {
        DBG_UNHANDLED_EXCEPTION();
        exit(2);
    }
    catch( std::exception& )
    {
        OSL_TRACE( "Caught std exception!" );
    }

    if( g_failure )
        exit(2);
}

} // namespace

void Main()
{
	TestWindow aWindow;
	aWindow.Execute();
	aWindow.SetText( XubString( RTL_CONSTASCII_USTRINGPARAM( "VCL - canvasbitmaptest" ) ) );

	Application::Execute();
}