/**************************************************************
 * 
 * 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_canvas.hxx"

#include "dx_surfacebitmap.hxx"
#include "dx_impltools.hxx"
#include "dx_surfacegraphics.hxx"
#include "dx_graphicsprovider.hxx"

#include <canvas/debug.hxx>
#include <tools/diagnose_ex.h>

#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/range/b2irange.hxx>

#if defined(DX_DEBUG_IMAGES) 
# if OSL_DEBUG_LEVEL > 0
#  include <imdebug.h>
#  undef min
#  undef max
# endif
#endif

using namespace ::com::sun::star;

namespace dxcanvas
{
	namespace
	{
		//////////////////////////////////////////////////////////////////////////////////
		// DXColorBuffer
		//////////////////////////////////////////////////////////////////////////////////

		struct DXColorBuffer : public canvas::IColorBuffer
		{
        public:
            DXColorBuffer( const COMReference<surface_type>& rSurface,
						   const ::basegfx::B2IVector&       rSize ) :
                mpSurface(rSurface),
                maSize(rSize),
                mbAlpha(false)
            {
            }

		// implementation of the 'IColorBuffer' interface
        public:

            virtual sal_uInt8* lock() const;
            virtual void       unlock() const;
            virtual sal_uInt32 getWidth() const;
            virtual sal_uInt32 getHeight() const;
            virtual sal_uInt32 getStride() const;
            virtual Format     getFormat() const;

        private:

            ::basegfx::B2IVector maSize;
#if DIRECTX_VERSION < 0x0900
			mutable DDSURFACEDESC aSurfaceDesc;
#else
			mutable D3DLOCKED_RECT maLockedRect;
#endif
			mutable COMReference<surface_type> mpSurface;
            bool mbAlpha;
		};

		sal_uInt8* DXColorBuffer::lock() const
		{
#if DIRECTX_VERSION < 0x0900
			rtl_fillMemory((void *)&aSurfaceDesc,sizeof(DDSURFACEDESC),0);
			aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);
			const DWORD dwFlags = DDLOCK_NOSYSLOCK|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WAIT|DDLOCK_READONLY;
			if(SUCCEEDED(mpSurface->Lock(NULL,&aSurfaceDesc,dwFlags,NULL)))
				return static_cast<sal_uInt8 *>(aSurfaceDesc.lpSurface);
#else
			if(SUCCEEDED(mpSurface->LockRect(&maLockedRect,NULL,D3DLOCK_NOSYSLOCK|D3DLOCK_READONLY)))
				return static_cast<sal_uInt8 *>(maLockedRect.pBits);
#endif
			return NULL;
		}

		void DXColorBuffer::unlock() const
		{
#if DIRECTX_VERSION < 0x0900
			mpSurface->Unlock(NULL);
#else
			mpSurface->UnlockRect();
#endif
		}

		sal_uInt32 DXColorBuffer::getWidth() const
		{
			return maSize.getX();
		}

		sal_uInt32 DXColorBuffer::getHeight() const
		{
			return maSize.getY();
		}

		sal_uInt32 DXColorBuffer::getStride() const
		{
#if DIRECTX_VERSION < 0x0900
			return aSurfaceDesc.lPitch;
#else
			return maLockedRect.Pitch;
#endif
		}

		canvas::IColorBuffer::Format DXColorBuffer::getFormat() const
		{
			return canvas::IColorBuffer::FMT_X8R8G8B8; 
		}

		//////////////////////////////////////////////////////////////////////////////////
		// GDIColorBuffer
		//////////////////////////////////////////////////////////////////////////////////

		struct GDIColorBuffer : public canvas::IColorBuffer
		{
        public:

			GDIColorBuffer( const BitmapSharedPtr&		rSurface,
							const ::basegfx::B2IVector& rSize ) :
                mpGDIPlusBitmap(rSurface),
                maSize(rSize),
                mbAlpha(true)
            {
            }

		// implementation of the 'IColorBuffer' interface
        public:

            virtual sal_uInt8* lock() const;
            virtual void       unlock() const;
            virtual sal_uInt32 getWidth() const;
            virtual sal_uInt32 getHeight() const;
            virtual sal_uInt32 getStride() const;
            virtual Format     getFormat() const;

        private:

            ::basegfx::B2IVector maSize;
            mutable Gdiplus::BitmapData aBmpData;
			BitmapSharedPtr mpGDIPlusBitmap;
            bool mbAlpha;
		};

		sal_uInt8* GDIColorBuffer::lock() const
		{
            aBmpData.Width = maSize.getX();
            aBmpData.Height = maSize.getY();
            aBmpData.Stride = 4*aBmpData.Width;
            aBmpData.PixelFormat = PixelFormat32bppARGB;
            aBmpData.Scan0 = NULL;
            const Gdiplus::Rect aRect( 0,0,aBmpData.Width,aBmpData.Height );
            if( Gdiplus::Ok != mpGDIPlusBitmap->LockBits( &aRect,
                                                          Gdiplus::ImageLockModeRead,
                                                          PixelFormat32bppARGB,
                                                          &aBmpData ) )
            {
                return NULL;
            }
            
			return static_cast<sal_uInt8*>(aBmpData.Scan0);
		}

		void GDIColorBuffer::unlock() const
		{
            mpGDIPlusBitmap->UnlockBits( &aBmpData );
		}

		sal_uInt32 GDIColorBuffer::getWidth() const
		{
			return maSize.getX();
		}

		sal_uInt32 GDIColorBuffer::getHeight() const
		{
			return maSize.getY();
		}

		sal_uInt32 GDIColorBuffer::getStride() const
		{
			return aBmpData.Stride;
		}

		canvas::IColorBuffer::Format GDIColorBuffer::getFormat() const
		{
			return canvas::IColorBuffer::FMT_A8R8G8B8;
		}
	}

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::DXSurfaceBitmap
	//////////////////////////////////////////////////////////////////////////////////

	DXSurfaceBitmap::DXSurfaceBitmap( const ::basegfx::B2IVector&					rSize,
                                      const canvas::ISurfaceProxyManagerSharedPtr&	rMgr,
                                      const IDXRenderModuleSharedPtr&				rRenderModule,
                                      bool											bWithAlpha ) : 
        mpGdiPlusUser( GDIPlusUser::createInstance() ),
        maSize(rSize),
        mpRenderModule(rRenderModule),
        mpSurfaceManager(rMgr),
        mpSurfaceProxy(),
        mpSurface(),
		mpGDIPlusBitmap(),
        mpGraphics(),
        mpColorBuffer(),
        mbIsSurfaceDirty(true),
        mbAlpha(bWithAlpha)
	{
		init();
	}

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::getSize
	//////////////////////////////////////////////////////////////////////////////////

    ::basegfx::B2IVector DXSurfaceBitmap::getSize() const
    {
        return maSize;
    }

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::init
	//////////////////////////////////////////////////////////////////////////////////

	void DXSurfaceBitmap::init()
	{
		// create container for pixel data
		if(mbAlpha)
		{
			mpGDIPlusBitmap.reset( 
				new Gdiplus::Bitmap( 
					maSize.getX(),
					maSize.getY(),
					PixelFormat32bppARGB 
					));
            mpGraphics.reset( tools::createGraphicsFromBitmap(mpGDIPlusBitmap) );

			// create the colorbuffer object, which is basically a simple
			// wrapper around the directx surface. the colorbuffer is the
			// interface which is used by the surfaceproxy to support any
			// kind of underlying structure for the pixel data container.
			mpColorBuffer.reset(new GDIColorBuffer(mpGDIPlusBitmap,maSize));
		}
		else
		{
			mpSurface = mpRenderModule->createSystemMemorySurface(maSize);

			// create the colorbuffer object, which is basically a simple
			// wrapper around the directx surface. the colorbuffer is the
			// interface which is used by the surfaceproxy to support any
			// kind of underlying structure for the pixel data container.
			mpColorBuffer.reset(new DXColorBuffer(mpSurface,maSize));
		}

		// create a (possibly hardware accelerated) mirror surface.
		mpSurfaceProxy = mpSurfaceManager->createSurfaceProxy(mpColorBuffer);
	}

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::resize
	//////////////////////////////////////////////////////////////////////////////////

	bool DXSurfaceBitmap::resize( const ::basegfx::B2IVector& rSize )
	{
		if(maSize != rSize)
		{
			maSize = rSize;
			init();
		}

		return true;
	}

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::clear
	//////////////////////////////////////////////////////////////////////////////////

	void DXSurfaceBitmap::clear()
	{
		GraphicsSharedPtr pGraphics(getGraphics());
        Gdiplus::Color transColor(255,0,0,0);
		pGraphics->SetCompositingMode( Gdiplus::CompositingModeSourceCopy );
		pGraphics->Clear( transColor );
	}

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::hasAlpha
	//////////////////////////////////////////////////////////////////////////////////

	bool DXSurfaceBitmap::hasAlpha() const
	{
		return mbAlpha;
	}

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::getGraphics
	//////////////////////////////////////////////////////////////////////////////////

	GraphicsSharedPtr DXSurfaceBitmap::getGraphics()
	{
		// since clients will most probably draw directly
		// to the GDI+ bitmap, we need to mark it as dirty
		// to ensure that the corrosponding dxsurface will
		// be updated.
		mbIsSurfaceDirty = true;

		if(hasAlpha())
            return mpGraphics;
        else
            return createSurfaceGraphics(mpSurface);
	}

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::getBitmap
	//////////////////////////////////////////////////////////////////////////////////

	BitmapSharedPtr DXSurfaceBitmap::getBitmap() const
	{
		if(hasAlpha())
			return mpGDIPlusBitmap;

		BitmapSharedPtr pResult;

#if DIRECTX_VERSION < 0x0900
		DDSURFACEDESC aSurfaceDesc;
		rtl_fillMemory(&aSurfaceDesc,sizeof(DDSURFACEDESC),0);
		aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);
		const DWORD dwFlags = DDLOCK_NOSYSLOCK|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WAIT|DDLOCK_READONLY;

		// lock the directx surface to receive the pointer to the surface memory.
		if(SUCCEEDED(mpSurface->Lock(NULL,&aSurfaceDesc,dwFlags,NULL))) 
        {
			// decide about the format we pass the gdi+, the directx surface is always
			// 32bit, either with or without alpha component.
			Gdiplus::PixelFormat nFormat = hasAlpha() ? PixelFormat32bppARGB : PixelFormat32bppRGB;

			// construct a gdi+ bitmap from the raw pixel data. 
			pResult.reset(new Gdiplus::Bitmap( maSize.getX(),maSize.getY(),
                                               aSurfaceDesc.lPitch,
                                               nFormat,
                                               (BYTE *)aSurfaceDesc.lpSurface ));
            
			// unlock the directx surface
			mpSurface->Unlock(NULL);
		}
#else
		D3DLOCKED_RECT aLockedRect;
		if(SUCCEEDED(mpSurface->LockRect(&aLockedRect,NULL,D3DLOCK_NOSYSLOCK|D3DLOCK_READONLY)))
		{
			// decide about the format we pass the gdi+, the directx surface is always
			// 32bit, either with or without alpha component.
			Gdiplus::PixelFormat nFormat = hasAlpha() ? PixelFormat32bppARGB : PixelFormat32bppRGB;

			// construct a gdi+ bitmap from the raw pixel data. 
			pResult.reset(new Gdiplus::Bitmap( maSize.getX(),maSize.getY(),
												aLockedRect.Pitch,
												nFormat,
												(BYTE *)aLockedRect.pBits ));

			mpSurface->UnlockRect();
		}
#endif

		return pResult;
	}

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::draw
	//////////////////////////////////////////////////////////////////////////////////

	bool DXSurfaceBitmap::draw( double                           fAlpha,
                                const ::basegfx::B2DPoint&       rPos,
                                const ::basegfx::B2DPolyPolygon& rClipPoly,
                                const ::basegfx::B2DHomMatrix&   rTransform )
    {
        if( mbIsSurfaceDirty )
        {
            mpSurfaceProxy->setColorBufferDirty();
            mbIsSurfaceDirty = false;
        }

        return mpSurfaceProxy->draw( fAlpha, rPos, rClipPoly, rTransform );
    }

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::draw
	//////////////////////////////////////////////////////////////////////////////////

	bool DXSurfaceBitmap::draw( double                         fAlpha,
                                const ::basegfx::B2DPoint&     rPos,
                                const ::basegfx::B2DRange&     rArea,
                                const ::basegfx::B2DHomMatrix& rTransform )
    {
        if( mbIsSurfaceDirty )
        {
            mpSurfaceProxy->setColorBufferDirty();
            mbIsSurfaceDirty = false;
        }

        return mpSurfaceProxy->draw( fAlpha, rPos, rArea, rTransform );
    }

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::draw
	//////////////////////////////////////////////////////////////////////////////////

	bool DXSurfaceBitmap::draw( double                         fAlpha,
                                const ::basegfx::B2DPoint&     rPos,
                                const ::basegfx::B2DHomMatrix& rTransform )
    {
        if( mbIsSurfaceDirty )
        {
            mpSurfaceProxy->setColorBufferDirty();
            mbIsSurfaceDirty = false;
        }

        return mpSurfaceProxy->draw( fAlpha, rPos, rTransform );
    }

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::draw
	//////////////////////////////////////////////////////////////////////////////////

	bool DXSurfaceBitmap::draw( const ::basegfx::B2IRange& rArea )
	{
        if( mbIsSurfaceDirty )
        {
            mpSurfaceProxy->setColorBufferDirty();
            mbIsSurfaceDirty = false;
        }

		const double                  fAlpha(1.0);
		const ::basegfx::B2DHomMatrix aTransform;
		const ::basegfx::B2DRange     aIEEEArea( rArea );
		return mpSurfaceProxy->draw(fAlpha,
                                    ::basegfx::B2DPoint(),
                                    aIEEEArea,
                                    aTransform);
	}

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::imageDebugger
	//////////////////////////////////////////////////////////////////////////////////
#if defined(DX_DEBUG_IMAGES)
# if OSL_DEBUG_LEVEL > 0
	void DXSurfaceBitmap::imageDebugger()
	{
#if DIRECTX_VERSION < 0x0900
		DDSURFACEDESC aSurfaceDesc;
		rtl_fillMemory( &aSurfaceDesc,sizeof(DDSURFACEDESC),0 );
		aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);

		if( FAILED(mpSurface->Lock( NULL, 
									&aSurfaceDesc, 
									DDLOCK_NOSYSLOCK|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WAIT|DDLOCK_READONLY,
									NULL)) )
			return;

        imdebug("bgra w=%d h=%d %p", aSurfaceDesc.dwWidth, aSurfaceDesc.dwHeight, aSurfaceDesc.lpSurface);

        mpSurface->Unlock(NULL);
#else
		D3DLOCKED_RECT aLockedRect;
		if( FAILED(mpSurface->LockRect(&aLockedRect,NULL,D3DLOCK_NOSYSLOCK|D3DLOCK_READONLY)) )
            return;

        imdebug("bgra w=%d h=%d %p", maSize.getX(), 
                maSize.getY(), aLockedRect.pBits);
        mpSurface->UnlockRect();
#endif
	}
# endif
#endif

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::getData
	//////////////////////////////////////////////////////////////////////////////////

    uno::Sequence< sal_Int8 > DXSurfaceBitmap::getData( rendering::IntegerBitmapLayout&     /*bitmapLayout*/, 
                                                        const geometry::IntegerRectangle2D& rect )
    {
		if(hasAlpha())
		{
			uno::Sequence< sal_Int8 > aRes( (rect.X2-rect.X1)*(rect.Y2-rect.Y1)*4 ); // TODO(F1): Be format-agnostic here

			const Gdiplus::Rect aRect( tools::gdiPlusRectFromIntegerRectangle2D( rect ) );

			Gdiplus::BitmapData aBmpData;
			aBmpData.Width		 = rect.X2-rect.X1;
			aBmpData.Height		 = rect.Y2-rect.Y1;
			aBmpData.Stride 	 = 4*aBmpData.Width;
			aBmpData.PixelFormat = PixelFormat32bppARGB;
			aBmpData.Scan0		 = aRes.getArray(); 

			// TODO(F1): Support more pixel formats natively

			// read data from bitmap
			if( Gdiplus::Ok != mpGDIPlusBitmap->LockBits( &aRect,
												Gdiplus::ImageLockModeRead | Gdiplus::ImageLockModeUserInputBuf,
												PixelFormat32bppARGB, // TODO(F1): Adapt to
                                               							// Graphics native
				                    									// format/change
                														// getMemoryLayout
												&aBmpData ) )
			{
				// failed to lock, bail out
				return uno::Sequence< sal_Int8 >();
			}

			mpGDIPlusBitmap->UnlockBits( &aBmpData );

			return aRes;
		}
		else
		{
			sal_uInt32 nWidth = rect.X2-rect.X1;
			sal_uInt32 nHeight = rect.Y2-rect.Y1;

			uno::Sequence< sal_Int8 > aRes(nWidth*nHeight*4);

#if DIRECTX_VERSION < 0x0900
			DDSURFACEDESC aSurfaceDesc;
			rtl_fillMemory(&aSurfaceDesc,sizeof(DDSURFACEDESC),0);
			aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);
			const DWORD dwFlags = DDLOCK_NOSYSLOCK|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WAIT|DDLOCK_READONLY;

			// lock the directx surface to receive the pointer to the surface memory.
			if(FAILED(mpSurface->Lock(NULL,&aSurfaceDesc,dwFlags,NULL)))
				return uno::Sequence< sal_Int8 >();

			sal_uInt8 *pSrc = (sal_uInt8 *)((((BYTE *)aSurfaceDesc.lpSurface)+(rect.Y1*aSurfaceDesc.lPitch))+rect.X1);
			sal_uInt8 *pDst = (sal_uInt8 *)aRes.getArray();
			sal_uInt32 nSegmentSizeInBytes = nWidth<<4;
			for(sal_uInt32 y=0; y<nHeight; ++y) 
			{
				rtl_copyMemory(pDst,pSrc,nSegmentSizeInBytes);
				pDst += nSegmentSizeInBytes;
				pSrc += aSurfaceDesc.lPitch;
			}

			mpSurface->Unlock(NULL);
#else
			D3DLOCKED_RECT aLockedRect;
			if(FAILED(mpSurface->LockRect(&aLockedRect,NULL,D3DLOCK_NOSYSLOCK|D3DLOCK_READONLY)))
				return uno::Sequence< sal_Int8 >();

			sal_uInt8 *pSrc = (sal_uInt8 *)((((BYTE *)aLockedRect.pBits)+(rect.Y1*aLockedRect.Pitch))+rect.X1);
			sal_uInt8 *pDst = (sal_uInt8 *)aRes.getArray();
			sal_uInt32 nSegmentSizeInBytes = nWidth<<4;
			for(sal_uInt32 y=0; y<nHeight; ++y) 
			{
				rtl_copyMemory(pDst,pSrc,nSegmentSizeInBytes);
				pDst += nSegmentSizeInBytes;
				pSrc += aLockedRect.Pitch;
			}

			mpSurface->UnlockRect();
#endif
			return aRes;
		}
    }

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::setData
	//////////////////////////////////////////////////////////////////////////////////

    void DXSurfaceBitmap::setData( const uno::Sequence< sal_Int8 >& 	 data, 
                                   const rendering::IntegerBitmapLayout& /*bitmapLayout*/, 
                                   const geometry::IntegerRectangle2D& 	 rect )
    {
		if(hasAlpha())
		{
			const Gdiplus::Rect aRect( tools::gdiPlusRectFromIntegerRectangle2D( rect ) );

			Gdiplus::BitmapData aBmpData;
			aBmpData.Width		 = rect.X2-rect.X1;
			aBmpData.Height		 = rect.Y2-rect.Y1;
			aBmpData.Stride 	 = 4*aBmpData.Width;
			aBmpData.PixelFormat = PixelFormat32bppARGB;
			aBmpData.Scan0		 = (void*)data.getConstArray(); 

			// TODO(F1): Support more pixel formats natively

			if( Gdiplus::Ok != mpGDIPlusBitmap->LockBits( &aRect,
												Gdiplus::ImageLockModeWrite | Gdiplus::ImageLockModeUserInputBuf,
												PixelFormat32bppARGB, // TODO: Adapt to
                                               							// Graphics native
                                                  						// format/change
                                                  						// getMemoryLayout
												&aBmpData ) )
			{
				throw uno::RuntimeException();
			}

			// commit data to bitmap
			mpGDIPlusBitmap->UnlockBits( &aBmpData );
		}
		else
		{
			sal_uInt32 nWidth = rect.X2-rect.X1;
			sal_uInt32 nHeight = rect.Y2-rect.Y1;

#if DIRECTX_VERSION < 0x0900
			DDSURFACEDESC aSurfaceDesc;
			rtl_fillMemory(&aSurfaceDesc,sizeof(DDSURFACEDESC),0);
			aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);
			const DWORD dwFlags = DDLOCK_NOSYSLOCK|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WAIT|DDLOCK_WRITEONLY;

			// lock the directx surface to receive the pointer to the surface memory.
			if(FAILED(mpSurface->Lock(NULL,&aSurfaceDesc,dwFlags,NULL)))
				throw uno::RuntimeException();

			sal_uInt8 *pSrc = (sal_uInt8 *)data.getConstArray();
			sal_uInt8 *pDst = (sal_uInt8 *)((((BYTE *)aSurfaceDesc.lpSurface)+(rect.Y1*aSurfaceDesc.lPitch))+rect.X1);
			sal_uInt32 nSegmentSizeInBytes = nWidth<<4;
			for(sal_uInt32 y=0; y<nHeight; ++y) 
			{
				rtl_copyMemory(pDst,pSrc,nSegmentSizeInBytes);
				pSrc += nSegmentSizeInBytes;
				pDst += aSurfaceDesc.lPitch;
			}

			mpSurface->Unlock(NULL);
#else
			// lock the directx surface to receive the pointer to the surface memory.
			D3DLOCKED_RECT aLockedRect;
			if(FAILED(mpSurface->LockRect(&aLockedRect,NULL,D3DLOCK_NOSYSLOCK|D3DLOCK_READONLY)))
				throw uno::RuntimeException();

			sal_uInt8 *pSrc = (sal_uInt8 *)data.getConstArray();
			sal_uInt8 *pDst = (sal_uInt8 *)((((BYTE *)aLockedRect.pBits)+(rect.Y1*aLockedRect.Pitch))+rect.X1);
			sal_uInt32 nSegmentSizeInBytes = nWidth<<4;
			for(sal_uInt32 y=0; y<nHeight; ++y) 
			{
				rtl_copyMemory(pDst,pSrc,nSegmentSizeInBytes);
				pSrc += nSegmentSizeInBytes;
				pDst += aLockedRect.Pitch;
			}

			mpSurface->UnlockRect();
#endif
		}

        mbIsSurfaceDirty = true;
    }

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::setPixel
	//////////////////////////////////////////////////////////////////////////////////

    void DXSurfaceBitmap::setPixel( const uno::Sequence< sal_Int8 >&      color, 
                                    const rendering::IntegerBitmapLayout& /*bitmapLayout*/, 
                                    const geometry::IntegerPoint2D&       pos )
    {
		if(hasAlpha())
		{
			const geometry::IntegerSize2D aSize( maSize.getX(),maSize.getY() );

			ENSURE_ARG_OR_THROW( pos.X >= 0 && pos.X < aSize.Width, 
							"CanvasHelper::setPixel: X coordinate out of bounds" );
			ENSURE_ARG_OR_THROW( pos.Y >= 0 && pos.Y < aSize.Height, 
							"CanvasHelper::setPixel: Y coordinate out of bounds" );
			ENSURE_ARG_OR_THROW( color.getLength() > 3, 
							"CanvasHelper::setPixel: not enough color components" );

			if( Gdiplus::Ok != mpGDIPlusBitmap->SetPixel( pos.X, pos.Y, 
												Gdiplus::Color( tools::sequenceToArgb( color ))))
			{
				throw uno::RuntimeException();
			}
		}
		else
		{
			ENSURE_ARG_OR_THROW( pos.X >= 0 && pos.X < maSize.getX(), 
							"CanvasHelper::setPixel: X coordinate out of bounds" );
			ENSURE_ARG_OR_THROW( pos.Y >= 0 && pos.Y < maSize.getY(), 
							"CanvasHelper::setPixel: Y coordinate out of bounds" );
			ENSURE_ARG_OR_THROW( color.getLength() > 3, 
							"CanvasHelper::setPixel: not enough color components" );

			Gdiplus::Color aColor(tools::sequenceToArgb(color));

#if DIRECTX_VERSION < 0x0900
			DDSURFACEDESC aSurfaceDesc;
			rtl_fillMemory(&aSurfaceDesc,sizeof(DDSURFACEDESC),0);
			aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);
			const DWORD dwFlags = DDLOCK_NOSYSLOCK|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WAIT|DDLOCK_WRITEONLY;

			// lock the directx surface to receive the pointer to the surface memory.
			if(FAILED(mpSurface->Lock(NULL,&aSurfaceDesc,dwFlags,NULL)))
				throw uno::RuntimeException();

			sal_uInt32 *pDst = (sal_uInt32 *)((((BYTE *)aSurfaceDesc.lpSurface)+(pos.Y*aSurfaceDesc.lPitch))+pos.X);
			*pDst = aColor.GetValue();
			mpSurface->Unlock(NULL);
#else
			// lock the directx surface to receive the pointer to the surface memory.
			D3DLOCKED_RECT aLockedRect;
			if(FAILED(mpSurface->LockRect(&aLockedRect,NULL,D3DLOCK_NOSYSLOCK|D3DLOCK_READONLY)))
				throw uno::RuntimeException();

			sal_uInt32 *pDst = (sal_uInt32 *)((((BYTE *)aLockedRect.pBits)+(pos.Y*aLockedRect.Pitch))+pos.X);
			*pDst = aColor.GetValue();
			mpSurface->UnlockRect();
#endif
		}

        mbIsSurfaceDirty = true;
    }

	//////////////////////////////////////////////////////////////////////////////////
	// DXSurfaceBitmap::getPixel
	//////////////////////////////////////////////////////////////////////////////////

    uno::Sequence< sal_Int8 > DXSurfaceBitmap::getPixel( rendering::IntegerBitmapLayout&   /*bitmapLayout*/, 
                                                         const geometry::IntegerPoint2D&   pos )
    {
		if(hasAlpha())
		{
			const geometry::IntegerSize2D aSize( maSize.getX(),maSize.getY() );

			ENSURE_ARG_OR_THROW( pos.X >= 0 && pos.X < aSize.Width, 
							"CanvasHelper::getPixel: X coordinate out of bounds" );
			ENSURE_ARG_OR_THROW( pos.Y >= 0 && pos.Y < aSize.Height, 
							"CanvasHelper::getPixel: Y coordinate out of bounds" );

			Gdiplus::Color aColor;

			if( Gdiplus::Ok != mpGDIPlusBitmap->GetPixel( pos.X, pos.Y, &aColor ) )
				return uno::Sequence< sal_Int8 >();
	        
			return tools::argbToIntSequence(aColor.GetValue());
		}
		else
		{
			ENSURE_ARG_OR_THROW( pos.X >= 0 && pos.X < maSize.getX(), 
							"CanvasHelper::getPixel: X coordinate out of bounds" );
			ENSURE_ARG_OR_THROW( pos.Y >= 0 && pos.Y < maSize.getY(), 
							"CanvasHelper::getPixel: Y coordinate out of bounds" );

#if DIRECTX_VERSION < 0x0900
			DDSURFACEDESC aSurfaceDesc;
			rtl_fillMemory(&aSurfaceDesc,sizeof(DDSURFACEDESC),0);
			aSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);
			const DWORD dwFlags = DDLOCK_NOSYSLOCK|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WAIT|DDLOCK_READONLY;

			// lock the directx surface to receive the pointer to the surface memory.
			if(FAILED(mpSurface->Lock(NULL,&aSurfaceDesc,dwFlags,NULL)))
				throw uno::RuntimeException();

			sal_uInt32 *pDst = (sal_uInt32 *)((((BYTE *)aSurfaceDesc.lpSurface)+(pos.Y*aSurfaceDesc.lPitch))+pos.X);
			Gdiplus::Color aColor(*pDst);
			mpSurface->Unlock(NULL);
#else
			// lock the directx surface to receive the pointer to the surface memory.
			D3DLOCKED_RECT aLockedRect;
			if(FAILED(mpSurface->LockRect(&aLockedRect,NULL,D3DLOCK_NOSYSLOCK|D3DLOCK_READONLY)))
				throw uno::RuntimeException();

			sal_uInt32 *pDst = (sal_uInt32 *)((((BYTE *)aLockedRect.pBits)+(pos.Y*aLockedRect.Pitch))+pos.X);
			Gdiplus::Color aColor(*pDst);
			mpSurface->UnlockRect();
#endif
			
			return tools::argbToIntSequence(aColor.GetValue());
		}
    }

	//////////////////////////////////////////////////////////////////////////////////
	// End of file
	//////////////////////////////////////////////////////////////////////////////////
}