xref: /trunk/main/vcl/unx/generic/gdi/salbmp.cxx (revision c82f2877)

/**************************************************************
 *
 * 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"

#include <string.h>
#include <stdio.h>
#include <errno.h>
#ifdef FREEBSD
#include <sys/types.h>
#endif

#include <osl/endian.h>
#include <rtl/memory.h>

#include <vcl/bitmap.hxx>
#include <vcl/salbtype.hxx>

#include <tools/prex.h>
#include "unx/Xproto.h"
#include <tools/postx.h>
#include <unx/salunx.h>
#include <unx/saldata.hxx>
#include <unx/saldisp.hxx>
#include <unx/salgdi.h>
#include <unx/salbmp.h>
#include <unx/salinst.h>

// -----------
// - Defines -
// -----------

#define SAL_DRAWPIXMAP_MAX_EXT 4096

// -------------
// - SalBitmap -
// -------------

SalBitmap* X11SalInstance::CreateSalBitmap()
{
    return new X11SalBitmap();
}

ImplSalBitmapCache*	X11SalBitmap::mpCache = NULL;
sal_uLong				X11SalBitmap::mnCacheInstCount = 0;

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

X11SalBitmap::X11SalBitmap() :
	mpDIB( NULL ),
	mpDDB( NULL )
{
}

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

X11SalBitmap::~X11SalBitmap()
{
	Destroy();
}

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

void X11SalBitmap::ImplCreateCache()
{
	if( !mnCacheInstCount++ )
		mpCache = new ImplSalBitmapCache;
}

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

void X11SalBitmap::ImplDestroyCache()
{
	DBG_ASSERT( mnCacheInstCount, "X11SalBitmap::ImplDestroyCache(): underflow" );

	if( mnCacheInstCount && !--mnCacheInstCount )
		delete mpCache, mpCache = NULL;
}

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

void X11SalBitmap::ImplRemovedFromCache()
{
	if( mpDDB )
		delete mpDDB, mpDDB = NULL;
}

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

BitmapBuffer* X11SalBitmap::ImplCreateDIB( const Size& rSize, sal_uInt16 nBitCount, const BitmapPalette& rPal )
{
	DBG_ASSERT( nBitCount == 1 || nBitCount == 4 || nBitCount == 8 || nBitCount == 16 || nBitCount == 24, "Unsupported BitCount!" );

	BitmapBuffer* pDIB = NULL;

	if( rSize.Width() && rSize.Height() )
	{
        try
        {
            pDIB = new BitmapBuffer;
        }
        catch( std::bad_alloc& )
        {
            pDIB = NULL;
        }

		if( pDIB )
		{
			const sal_uInt16 nColors = ( nBitCount <= 8 ) ? ( 1 << nBitCount ) : 0;

			pDIB->mnFormat = BMP_FORMAT_BOTTOM_UP;

			switch( nBitCount )
			{
				case( 1 ): pDIB->mnFormat |= BMP_FORMAT_1BIT_MSB_PAL; break;
				case( 4 ): pDIB->mnFormat |= BMP_FORMAT_4BIT_MSN_PAL; break;
				case( 8 ): pDIB->mnFormat |= BMP_FORMAT_8BIT_PAL; break;
#ifdef OSL_BIGENDIAN
                case(16 ):
                    pDIB->mnFormat|= BMP_FORMAT_16BIT_TC_MSB_MASK;
                    pDIB->maColorMask = ColorMask( 0xf800, 0x07e0, 0x001f );
                    break;
#else
                case(16 ):
                    pDIB->mnFormat|= BMP_FORMAT_16BIT_TC_LSB_MASK;
                    pDIB->maColorMask = ColorMask( 0xf800, 0x07e0, 0x001f );
                    break;
#endif
				default:
					nBitCount = 24;
					//fall through
				case 24:
					pDIB->mnFormat |= BMP_FORMAT_24BIT_TC_BGR;
				break;
			}

			pDIB->mnWidth = rSize.Width();
			pDIB->mnHeight = rSize.Height();
			pDIB->mnScanlineSize = AlignedWidth4Bytes( pDIB->mnWidth * nBitCount );
			pDIB->mnBitCount = nBitCount;

			if( nColors )
			{
				pDIB->maPalette = rPal;
				pDIB->maPalette.SetEntryCount( nColors );
			}

            try
            {
                pDIB->mpBits = new sal_uInt8[ pDIB->mnScanlineSize * pDIB->mnHeight ];
            }
            catch(std::bad_alloc&)
            {
                delete pDIB;
                pDIB = NULL;
            }
		}
	}
	else
		pDIB = NULL;

	return pDIB;
}

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

BitmapBuffer* X11SalBitmap::ImplCreateDIB( Drawable aDrawable,
                                           int nScreen,
                                           long nDrawableDepth,
                                           long nX, long nY,
                                           long nWidth, long nHeight )
{
	BitmapBuffer* pDIB = NULL;

	if( aDrawable && nWidth && nHeight && nDrawableDepth )
	{
		SalDisplay*	pSalDisp = GetX11SalData()->GetDisplay();
		SalXLib*	pXLib = pSalDisp->GetXLib();
		Display*	pXDisp = pSalDisp->GetDisplay();

        // do not die on XError here
		// alternatively one could check the coordinates for being offscreen
		// but this call can actually work on servers with backing store
		// defaults even if the rectangle is offscreen
		// so better catch the XError
        pXLib->PushXErrorLevel( true );
		XImage*	pImage = XGetImage( pXDisp, aDrawable, nX, nY, nWidth, nHeight, AllPlanes, ZPixmap );
		bool bWasError = pXLib->HasXErrorOccured() && pXLib->GetLastXErrorRequestCode() == X_GetImage;
		pXLib->PopXErrorLevel();

		if( ! bWasError && pImage && pImage->data )
		{
			const SalTwoRect		aTwoRect = { 0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight };
			BitmapBuffer			aSrcBuf;
			sal_uLong					nDstFormat = BMP_FORMAT_BOTTOM_UP;
			const BitmapPalette*	pDstPal = NULL;

			aSrcBuf.mnFormat = BMP_FORMAT_TOP_DOWN;
			aSrcBuf.mnWidth = nWidth;
			aSrcBuf.mnHeight = nHeight;
			aSrcBuf.mnBitCount = pImage->bits_per_pixel;
			aSrcBuf.mnScanlineSize = pImage->bytes_per_line;
			aSrcBuf.mpBits = (sal_uInt8*) pImage->data;

			pImage->red_mask = pSalDisp->GetVisual( nScreen ).red_mask;
			pImage->green_mask = pSalDisp->GetVisual( nScreen ).green_mask;
			pImage->blue_mask = pSalDisp->GetVisual( nScreen ).blue_mask;

			switch( aSrcBuf.mnBitCount )
			{
				case( 1 ):
				{
					aSrcBuf.mnFormat |= ( LSBFirst == pImage->bitmap_bit_order ? BMP_FORMAT_1BIT_LSB_PAL : BMP_FORMAT_1BIT_MSB_PAL );
					nDstFormat |= BMP_FORMAT_1BIT_MSB_PAL;
				}
				break;

				case( 4 ):
				{
					aSrcBuf.mnFormat |= ( LSBFirst == pImage->bitmap_bit_order ? BMP_FORMAT_4BIT_LSN_PAL : BMP_FORMAT_4BIT_MSN_PAL );
					nDstFormat |= BMP_FORMAT_4BIT_MSN_PAL;
				}
				break;

				case( 8 ):
				{
					aSrcBuf.mnFormat |= BMP_FORMAT_8BIT_PAL;
					nDstFormat |= BMP_FORMAT_8BIT_PAL;
				}
				break;

				case( 16 ):
				{
					nDstFormat |= BMP_FORMAT_24BIT_TC_BGR;
                    aSrcBuf.maColorMask = ColorMask( pImage->red_mask, pImage->green_mask, pImage->blue_mask );

					if( LSBFirst == pImage->byte_order )
                    {
					    aSrcBuf.mnFormat |= BMP_FORMAT_16BIT_TC_LSB_MASK;
					}
                    else
                    {
					    aSrcBuf.mnFormat |= BMP_FORMAT_16BIT_TC_MSB_MASK;
						// aSrcBuf.maColorMask = ColorMask( pImage->red_mask ), SWAPSHORT( pImage->green_mask ), SWAPSHORT( pImage->blue_mask ) );
                    }
				}
				break;

				case( 24 ):
				{
					if( ( LSBFirst == pImage->byte_order ) && ( pImage->red_mask == 0xFF ) )
						aSrcBuf.mnFormat |= BMP_FORMAT_24BIT_TC_RGB;
					else
						aSrcBuf.mnFormat |= BMP_FORMAT_24BIT_TC_BGR;

					nDstFormat |= BMP_FORMAT_24BIT_TC_BGR;
				}
				break;

				case( 32 ):
				{
					if( LSBFirst == pImage->byte_order )
						aSrcBuf.mnFormat |= (  pSalDisp->GetVisual(nScreen).red_mask == 0xFF ? BMP_FORMAT_32BIT_TC_RGBA : BMP_FORMAT_32BIT_TC_BGRA );
					else
						aSrcBuf.mnFormat |= (  pSalDisp->GetVisual(nScreen).red_mask == 0xFF ? BMP_FORMAT_32BIT_TC_ABGR : BMP_FORMAT_32BIT_TC_ARGB );

					nDstFormat |= BMP_FORMAT_24BIT_TC_BGR;
				}
				break;
			}

			BitmapPalette& rPal = aSrcBuf.maPalette;

			if( aSrcBuf.mnBitCount == 1 )
			{
				rPal.SetEntryCount( 2 );
				pDstPal = &rPal;

				rPal[ 0 ] = Color( COL_BLACK );
				rPal[ 1 ] = Color( COL_WHITE );
			}
			else if( aSrcBuf.mnBitCount <= 8 )
			{
				const SalColormap& rColMap = pSalDisp->GetColormap( nScreen );
				const sal_uInt16 nCols = Min( (sal_uLong)rColMap.GetUsed(), (sal_uLong)(1 << nDrawableDepth) );

				rPal.SetEntryCount( nCols );
				pDstPal = &rPal;

				for( sal_uInt16 i = 0; i < nCols; i++ )
				{
					const SalColor	nColor( rColMap.GetColor( i ) );
					BitmapColor&	rBmpCol = rPal[ i ];

					rBmpCol.SetRed( SALCOLOR_RED( nColor ) );
					rBmpCol.SetGreen( SALCOLOR_GREEN( nColor ) );
					rBmpCol.SetBlue( SALCOLOR_BLUE( nColor ) );
				}
			}

            nDstFormat = aSrcBuf.mnFormat;
			pDIB = StretchAndConvert( aSrcBuf, aTwoRect, nDstFormat,
                const_cast<BitmapPalette*>(pDstPal), &aSrcBuf.maColorMask );
			XDestroyImage( pImage );
		}
	}

	return pDIB;
}

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

XImage*	X11SalBitmap::ImplCreateXImage( SalDisplay *pSalDisp, int nScreen, long nDepth, const SalTwoRect& rTwoRect ) const
{
	XImage* pImage = NULL;

	if( !mpDIB && mpDDB )
	{
	    const_cast<X11SalBitmap*>(this)->mpDIB =
            ImplCreateDIB( mpDDB->ImplGetPixmap(),
                           mpDDB->ImplGetScreen(),
                           mpDDB->ImplGetDepth(),
                           0, 0,
                           mpDDB->ImplGetWidth(),
                           mpDDB->ImplGetHeight() );
	}

	if( mpDIB && mpDIB->mnWidth && mpDIB->mnHeight )
	{
		Display*	pXDisp = pSalDisp->GetDisplay();
		long		nWidth = rTwoRect.mnDestWidth;
		long		nHeight = rTwoRect.mnDestHeight;

		if( 1 == GetBitCount() )
			nDepth = 1;

		pImage = XCreateImage( pXDisp, pSalDisp->GetVisual( nScreen ).GetVisual(),
							   nDepth, ( 1 == nDepth ) ? XYBitmap :ZPixmap, 0, NULL,
							   nWidth, nHeight, 32, 0 );

		if( pImage )
		{
			BitmapBuffer*	pDstBuf;
			sal_uLong			nDstFormat = BMP_FORMAT_TOP_DOWN;
			BitmapPalette*	pPal = NULL;
			ColorMask*		pMask = NULL;

			switch( pImage->bits_per_pixel )
			{
				case( 1 ):
					nDstFormat |= ( LSBFirst == pImage->bitmap_bit_order ? BMP_FORMAT_1BIT_LSB_PAL : BMP_FORMAT_1BIT_MSB_PAL );
				break;

				case( 4 ):
					nDstFormat |= ( LSBFirst == pImage->bitmap_bit_order ? BMP_FORMAT_4BIT_LSN_PAL : BMP_FORMAT_4BIT_MSN_PAL );
				break;

				case( 8 ):
					nDstFormat |= BMP_FORMAT_8BIT_PAL;
				break;

				case( 16 ):
				{
                    #ifdef OSL_BIGENDIAN

                    if( MSBFirst == pImage->byte_order )
					    nDstFormat |= BMP_FORMAT_16BIT_TC_MSB_MASK;
                    else
					    nDstFormat |= BMP_FORMAT_16BIT_TC_LSB_MASK;

                    #else /* OSL_LITENDIAN */

					nDstFormat |= BMP_FORMAT_16BIT_TC_LSB_MASK;
					if( MSBFirst == pImage->byte_order )
                        pImage->byte_order = LSBFirst;

                    #endif

					pMask = new ColorMask( pImage->red_mask, pImage->green_mask, pImage->blue_mask );
				}
				break;

				case( 24 ):
				{
					if( ( LSBFirst == pImage->byte_order ) && ( pImage->red_mask == 0xFF ) )
						nDstFormat |= BMP_FORMAT_24BIT_TC_RGB;
					else
						nDstFormat |= BMP_FORMAT_24BIT_TC_BGR;
				}
				break;

				case( 32 ):
				{
					if( LSBFirst == pImage->byte_order )
						nDstFormat |= ( pImage->red_mask == 0xFF ? BMP_FORMAT_32BIT_TC_RGBA : BMP_FORMAT_32BIT_TC_BGRA );
					else
						nDstFormat |= ( pImage->red_mask == 0xFF ? BMP_FORMAT_32BIT_TC_ABGR : BMP_FORMAT_32BIT_TC_ARGB );
				}
				break;
			}

			if( pImage->depth == 1 )
			{
				pPal = new BitmapPalette( 2 );
				(*pPal)[ 0 ] = Color( COL_BLACK );
				(*pPal)[ 1 ] = Color( COL_WHITE );
			}
			else if( pImage->depth <= 8 )
			{
				const SalColormap& rColMap = pSalDisp->GetColormap( nScreen );
				const sal_uInt16 nCols = Min( (sal_uLong)rColMap.GetUsed(), (sal_uLong)(1 << pImage->depth) );

				pPal = new BitmapPalette( nCols );

				for( sal_uInt16 i = 0; i < nCols; i++ )
				{
					const SalColor	nColor( rColMap.GetColor( i ) );
					BitmapColor&	rBmpCol = (*pPal)[ i ];

					rBmpCol.SetRed( SALCOLOR_RED( nColor ) );
					rBmpCol.SetGreen( SALCOLOR_GREEN( nColor ) );
					rBmpCol.SetBlue( SALCOLOR_BLUE( nColor ) );
				}
			}

			pDstBuf = StretchAndConvert( *mpDIB, rTwoRect, nDstFormat, pPal, pMask );
			delete pPal;
			delete pMask;

			if( pDstBuf && pDstBuf->mpBits )
			{
				// set data in buffer as data member in pImage
				pImage->data = (char*) pDstBuf->mpBits;

				// destroy buffer; don't destroy allocated data in buffer
				delete pDstBuf;
			}
			else
			{
				XDestroyImage( pImage );
				pImage = NULL;
			}
		}
	}

	return pImage;
}

// -----------------------------------------------------------------------------
bool X11SalBitmap::ImplCreateFromDrawable( Drawable aDrawable,
                                           int nScreen, long nDrawableDepth,
                                           long nX, long nY, long nWidth, long nHeight )
{
	Destroy();

	if( aDrawable && nWidth && nHeight && nDrawableDepth )
		mpDDB = new ImplSalDDB( aDrawable, nScreen, nDrawableDepth, nX, nY, nWidth, nHeight );

	return( mpDDB != NULL );
}
// -----------------------------------------------------------------------------

bool
X11SalBitmap::SnapShot (Display* pDisplay, XLIB_Window hWindow)
{
    if (hWindow != None)
    {
        XWindowAttributes aAttribute;
        XGetWindowAttributes (pDisplay, hWindow, &aAttribute);
        if (aAttribute.map_state == IsViewable)
        {
            // get coordinates relative to root window
            XLIB_Window hPetitFleur;
            int nRootX, nRootY;

            if (XTranslateCoordinates (pDisplay, hWindow, aAttribute.root,
                                       0, 0, &nRootX, &nRootY, &hPetitFleur))
            {
                XWindowAttributes aRootAttribute;
                XGetWindowAttributes (pDisplay, aAttribute.root, &aRootAttribute);

                int width  = aAttribute.width;
                int height = aAttribute.height;
                int x      = nRootX;
                int y      = nRootY;

                // horizontal range check
                if (x < 0)
                {
                    width  = width + x;
                    x      = 0;
                }
                else
                if (x > aRootAttribute.width)
                {
                    width = 0;
                    x     = aRootAttribute.width;
                }
                else
                if (x + width > aRootAttribute.width)
                {
                    width = aRootAttribute.width - x;
                }

                // vertical range check
                if (y < 0)
                {
                    height = height + y;
                    y      = 0;
                }
                else
                if (y > aRootAttribute.height)
                {
                    height = 0;
                    y      = aRootAttribute.height;
                }
                else
                if (y + height > aRootAttribute.height)
                {
                    height = aRootAttribute.height - y;
                }

                if ((width > 0) && (height > 0))
                {
                    XImage* pImage = XGetImage( pDisplay, aAttribute.root,
                                                x, y, width, height, AllPlanes, ZPixmap );
                    bool bSnapShot = ImplCreateFromXImage( pDisplay,
                                                           aAttribute.root,
                                                           XScreenNumberOfScreen( aAttribute.screen ),
                                                           pImage );
                    XDestroyImage (pImage);

                    return bSnapShot;
                }
            }
        }
    }

    return False;
}

bool
X11SalBitmap::ImplCreateFromXImage (Display* pDisplay, XLIB_Window hWindow, int nScreen, XImage* pImage)
{
    Destroy();

    if (pImage != NULL && pImage->width != 0 && pImage->height != 0 && pImage->depth != 0)
    {
        mpDDB = new ImplSalDDB (pDisplay, hWindow, nScreen, pImage);
        return True;
    }
    return False;
}

ImplSalDDB* X11SalBitmap::ImplGetDDB( Drawable          aDrawable,
                                      int               nScreen,
                                      long              nDrawableDepth,
                                      const SalTwoRect& rTwoRect ) const
{
	if( !mpDDB || !mpDDB->ImplMatches( nScreen, nDrawableDepth, rTwoRect ) )
	{
		if( mpDDB )
		{
			// do we already have a DIB? if not, create aDIB from current DDB first
			if( !mpDIB )
			{
				const_cast<X11SalBitmap*>(this)->mpDIB = ImplCreateDIB( mpDDB->ImplGetPixmap(),
                                                                        mpDDB->ImplGetScreen(),
                                                                        mpDDB->ImplGetDepth(),
                                                                        0, 0,
                                                                        mpDDB->ImplGetWidth(),
                                                                        mpDDB->ImplGetHeight() );
			}

			delete mpDDB, const_cast<X11SalBitmap*>(this)->mpDDB = NULL;
		}

		if( mpCache )
			mpCache->ImplRemove( const_cast<X11SalBitmap*>(this) );

		SalTwoRect aTwoRect( rTwoRect );
        if( aTwoRect.mnSrcX < 0 )
        {
            aTwoRect.mnSrcWidth += aTwoRect.mnSrcX;
            aTwoRect.mnSrcX = 0;
        }
        if( aTwoRect.mnSrcY < 0 )
        {
            aTwoRect.mnSrcHeight += aTwoRect.mnSrcY;
            aTwoRect.mnSrcY = 0;
        }

		// create new DDB from DIB
        const Size aSize( GetSize() );
		if( aTwoRect.mnSrcWidth == aTwoRect.mnDestWidth &&
			aTwoRect.mnSrcHeight == aTwoRect.mnDestHeight )
		{
			aTwoRect.mnSrcX = aTwoRect.mnSrcY = aTwoRect.mnDestX = aTwoRect.mnDestY = 0;
			aTwoRect.mnSrcWidth = aTwoRect.mnDestWidth = aSize.Width();
			aTwoRect.mnSrcHeight = aTwoRect.mnDestHeight = aSize.Height();
		}
        else if( aTwoRect.mnSrcWidth+aTwoRect.mnSrcX > aSize.Width() ||
                 aTwoRect.mnSrcHeight+aTwoRect.mnSrcY > aSize.Height() )
        {
            // #i47823# this should not happen at all, but does nonetheless
            // because BitmapEx allows for mask bitmaps of different size
            // than image bitmap (broken)
            if( aTwoRect.mnSrcX >= aSize.Width() ||
                aTwoRect.mnSrcY >= aSize.Height() )
                return NULL; // this would be a really mad case

            if( aTwoRect.mnSrcWidth+aTwoRect.mnSrcX > aSize.Width() )
            {
                aTwoRect.mnSrcWidth = aSize.Width()-aTwoRect.mnSrcX;
                if( aTwoRect.mnSrcWidth < 1 )
                {
                    aTwoRect.mnSrcX = 0;
                    aTwoRect.mnSrcWidth = aSize.Width();
                }
            }
            if( aTwoRect.mnSrcHeight+aTwoRect.mnSrcY > aSize.Height() )
            {
                aTwoRect.mnSrcHeight = aSize.Height() - aTwoRect.mnSrcY;
                if( aTwoRect.mnSrcHeight < 1 )
                {
                    aTwoRect.mnSrcY = 0;
                    aTwoRect.mnSrcHeight = aSize.Height();
                }
            }
        }

		XImage*	pImage = ImplCreateXImage( GetX11SalData()->GetDisplay(), nScreen,
                                           nDrawableDepth, aTwoRect );

		if( pImage )
		{
			const_cast<X11SalBitmap*>(this)->mpDDB = new ImplSalDDB( pImage, aDrawable, nScreen, aTwoRect );
			delete[] pImage->data, pImage->data = NULL;
			XDestroyImage( pImage );

			if( mpCache )
				mpCache->ImplAdd( const_cast<X11SalBitmap*>(this), mpDDB->ImplGetMemSize() );
		}
	}

	return mpDDB;
}

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

void X11SalBitmap::ImplDraw( Drawable           aDrawable,
                             int                nScreen,
                             long               nDrawableDepth,
                             const SalTwoRect&  rTwoRect,
                             const GC&          rGC ) const
{
    ImplGetDDB( aDrawable, nScreen, nDrawableDepth, rTwoRect );
    if( mpDDB )
        mpDDB->ImplDraw( aDrawable, nDrawableDepth, rTwoRect, rGC );
}

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

bool X11SalBitmap::Create( const Size& rSize, sal_uInt16 nBitCount, const BitmapPalette& rPal )
{
	Destroy();
	mpDIB = ImplCreateDIB( rSize, nBitCount, rPal );

	return( mpDIB != NULL );
}

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

bool X11SalBitmap::Create( const SalBitmap& rSSalBmp )
{
	Destroy();

    const X11SalBitmap& rSalBmp = static_cast<const X11SalBitmap&>( rSSalBmp );

	if( rSalBmp.mpDIB )
	{
		// TODO: reference counting...
		mpDIB = new BitmapBuffer( *rSalBmp.mpDIB );
		// TODO: get rid of this when BitmapBuffer gets copy constructor
        try
        {
            mpDIB->mpBits = new sal_uInt8[ mpDIB->mnScanlineSize * mpDIB->mnHeight ];
        }
        catch( std::bad_alloc& )
        {
            delete mpDIB;
            mpDIB = NULL;
        }

		if( mpDIB )
			memcpy( mpDIB->mpBits, rSalBmp.mpDIB->mpBits, mpDIB->mnScanlineSize * mpDIB->mnHeight );
	}
	else if(  rSalBmp.mpDDB )
		ImplCreateFromDrawable( rSalBmp.mpDDB->ImplGetPixmap(),
                                rSalBmp.mpDDB->ImplGetScreen(),
                                rSalBmp.mpDDB->ImplGetDepth(),
								0, 0, rSalBmp.mpDDB->ImplGetWidth(), rSalBmp.mpDDB->ImplGetHeight() );

	return( ( !rSalBmp.mpDIB && !rSalBmp.mpDDB ) ||
			( rSalBmp.mpDIB && ( mpDIB != NULL ) ) ||
			( rSalBmp.mpDDB && ( mpDDB != NULL ) ) );
}

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

bool X11SalBitmap::Create( const SalBitmap&, SalGraphics* )
{
	return sal_False;
}

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

bool X11SalBitmap::Create( const SalBitmap&, sal_uInt16 )
{
	return sal_False;
}

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

void X11SalBitmap::Destroy()
{
	if( mpDIB )
	{
		delete[] mpDIB->mpBits;
		delete mpDIB, mpDIB = NULL;
	}

	if( mpDDB )
		delete mpDDB, mpDDB = NULL;

	if( mpCache )
		mpCache->ImplRemove( this );
}

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

Size X11SalBitmap::GetSize() const
{
	Size aSize;

	if( mpDIB )
		aSize.Width() = mpDIB->mnWidth, aSize.Height() = mpDIB->mnHeight;
	else if( mpDDB )
		aSize.Width() = mpDDB->ImplGetWidth(), aSize.Height() = mpDDB->ImplGetHeight();

	return aSize;
}

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

sal_uInt16 X11SalBitmap::GetBitCount() const
{
	sal_uInt16 nBitCount;

	if( mpDIB )
		nBitCount = mpDIB->mnBitCount;
	else if( mpDDB )
		nBitCount = mpDDB->ImplGetDepth();
	else
		nBitCount = 0;

	return nBitCount;
}

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

BitmapBuffer* X11SalBitmap::AcquireBuffer( bool )
{
	if( !mpDIB && mpDDB )
	{
		mpDIB = ImplCreateDIB( mpDDB->ImplGetPixmap(),
                               mpDDB->ImplGetScreen(),
                               mpDDB->ImplGetDepth(),
							   0, 0, mpDDB->ImplGetWidth(), mpDDB->ImplGetHeight() );
	}

	return mpDIB;
}

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

void X11SalBitmap::ReleaseBuffer( BitmapBuffer*, bool bReadOnly )
{
	if( !bReadOnly )
	{
		if( mpDDB )
			delete mpDDB, mpDDB = NULL;

		if( mpCache )
			mpCache->ImplRemove( this );
	}
}

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

bool X11SalBitmap::GetSystemData( BitmapSystemData& rData )
{
	if( mpDDB )
	{
        // Rename/retype pDummy to your likings (though X11 Pixmap is
        // prolly not a good idea, since it's accessed from
        // non-platform aware code in vcl/bitmap.hxx)
        rData.aPixmap = (void*)mpDDB->ImplGetPixmap();
        rData.mnWidth = mpDDB->ImplGetWidth ();
        rData.mnHeight = mpDDB->ImplGetHeight ();
        return true;
	}

    return false;
}

// --------------
// - ImplSalDDB -
// --------------

ImplSalDDB::ImplSalDDB( XImage* pImage, Drawable aDrawable, int nScreen, const SalTwoRect& rTwoRect ) :
	maPixmap	( 0 ),
	maTwoRect	( rTwoRect ),
	mnDepth		( pImage->depth ),
    mnScreen    ( nScreen )
{
	SalDisplay*	pSalDisp = GetX11SalData()->GetDisplay();
	Display*	pXDisp = pSalDisp->GetDisplay();

	if( (maPixmap = XCreatePixmap( pXDisp, aDrawable, ImplGetWidth(), ImplGetHeight(), ImplGetDepth() )) )
	{
		XGCValues	aValues;
		GC			aGC;
		int			nValues = GCFunction;

		aValues.function = GXcopy;

		if( 1 == mnDepth )
		{
			nValues |= ( GCForeground | GCBackground );
			aValues.foreground = 1, aValues.background = 0;
		}

		aGC = XCreateGC( pXDisp, maPixmap, nValues, &aValues );
		XPutImage( pXDisp, maPixmap, aGC, pImage, 0, 0, 0, 0, maTwoRect.mnDestWidth, maTwoRect.mnDestHeight );
		XFreeGC( pXDisp, aGC );
	}
}

// -----------------------------------------------------------------------------------------
// create from XImage

ImplSalDDB::ImplSalDDB (Display* pDisplay, XLIB_Window hWindow, int nScreen, XImage* pImage) :
    mnScreen( nScreen )
{
    maPixmap = XCreatePixmap (pDisplay, hWindow, pImage->width, pImage->height, pImage->depth);
    if (maPixmap != 0)
    {
		XGCValues	aValues;
		GC			aGC;
		int			nValues = GCFunction;

		aValues.function = GXcopy;

		if (pImage->depth == 1)
		{
			nValues |= ( GCForeground | GCBackground );
			aValues.foreground = 1;
            aValues.background = 0;
		}

		aGC = XCreateGC (pDisplay, maPixmap, nValues, &aValues);
		XPutImage (pDisplay, maPixmap, aGC, pImage, 0, 0, 0, 0, pImage->width, pImage->height);
		XFreeGC (pDisplay, aGC);

        maTwoRect.mnSrcX       = 0;
        maTwoRect.mnSrcY       = 0;
        maTwoRect.mnDestX      = 0;
        maTwoRect.mnDestY      = 0;
		maTwoRect.mnSrcWidth   = pImage->width;
        maTwoRect.mnDestWidth  = pImage->width;
		maTwoRect.mnSrcHeight  = pImage->height;
        maTwoRect.mnDestHeight = pImage->height;

        mnDepth = pImage->depth;
	}
}

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

ImplSalDDB::ImplSalDDB( Drawable aDrawable, int nScreen, long nDrawableDepth, long nX, long nY, long nWidth, long nHeight ) :
	mnDepth( nDrawableDepth ),
    mnScreen( nScreen )
{
	SalDisplay*	pSalDisp = GetX11SalData()->GetDisplay();
	Display*	pXDisp = pSalDisp->GetDisplay();

	if( (maPixmap = XCreatePixmap( pXDisp, aDrawable, nWidth, nHeight, nDrawableDepth )) )
	{
		XGCValues	aValues;
		GC			aGC;
		int			nValues = GCFunction;

		aValues.function = GXcopy;

		if( 1 == mnDepth )
		{
			nValues |= ( GCForeground | GCBackground );
			aValues.foreground = 1, aValues.background = 0;
		}

		aGC = XCreateGC( pXDisp, maPixmap, nValues, &aValues );
		ImplDraw( aDrawable, nDrawableDepth, maPixmap, mnDepth,
				  nX, nY, nWidth, nHeight, 0, 0, aGC );
		XFreeGC( pXDisp, aGC );

		maTwoRect.mnSrcX = maTwoRect.mnSrcY = maTwoRect.mnDestX = maTwoRect.mnDestY = 0;
		maTwoRect.mnSrcWidth = maTwoRect.mnDestWidth = nWidth;
		maTwoRect.mnSrcHeight = maTwoRect.mnDestHeight = nHeight;
	}
}

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

ImplSalDDB::~ImplSalDDB()
{
	if( maPixmap && ImplGetSVData() )
		XFreePixmap( GetX11SalData()->GetDisplay()->GetDisplay(), maPixmap );
}

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

bool ImplSalDDB::ImplMatches( int nScreen, long nDepth, const SalTwoRect& rTwoRect ) const
{
	bool bRet = sal_False;

	if( ( maPixmap != 0 ) && ( ( mnDepth == nDepth ) || ( 1 == mnDepth ) ) && nScreen == mnScreen)
	{
		if( rTwoRect.mnSrcX == maTwoRect.mnSrcX && rTwoRect.mnSrcY == maTwoRect.mnSrcY &&
			rTwoRect.mnSrcWidth == maTwoRect.mnSrcWidth && rTwoRect.mnSrcHeight == maTwoRect.mnSrcHeight &&
			rTwoRect.mnDestWidth == maTwoRect.mnDestWidth && rTwoRect.mnDestHeight == maTwoRect.mnDestHeight )
		{
			// absolutely indentically
			bRet = sal_True;
		}
		else if( rTwoRect.mnSrcWidth == rTwoRect.mnDestWidth && rTwoRect.mnSrcHeight == rTwoRect.mnDestHeight &&
				 maTwoRect.mnSrcWidth == maTwoRect.mnDestWidth && maTwoRect.mnSrcHeight == maTwoRect.mnDestHeight &&
				 rTwoRect.mnSrcX >= maTwoRect.mnSrcX && rTwoRect.mnSrcY >= maTwoRect.mnSrcY &&
				 ( rTwoRect.mnSrcX + rTwoRect.mnSrcWidth ) <= ( maTwoRect.mnSrcX + maTwoRect.mnSrcWidth ) &&
				 ( rTwoRect.mnSrcY + rTwoRect.mnSrcHeight ) <= ( maTwoRect.mnSrcY + maTwoRect.mnSrcHeight ) )
		{
			bRet = sal_True;
		}
	}

	return bRet;
}

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

void ImplSalDDB::ImplDraw( Drawable aDrawable, long nDrawableDepth, const SalTwoRect& rTwoRect, const GC& rGC ) const
{
	ImplDraw( maPixmap, mnDepth, aDrawable, nDrawableDepth,
			  rTwoRect.mnSrcX - maTwoRect.mnSrcX, rTwoRect.mnSrcY - maTwoRect.mnSrcY,
			  rTwoRect.mnDestWidth, rTwoRect.mnDestHeight,
			  rTwoRect.mnDestX, rTwoRect.mnDestY, rGC );
}

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

void ImplSalDDB::ImplDraw( Drawable aSrcDrawable, long nSrcDrawableDepth,
						   Drawable aDstDrawable, long,
						   long nSrcX, long nSrcY,
						   long nDestWidth, long nDestHeight,
						   long nDestX, long nDestY, const GC& rGC )
{
	SalDisplay*	pSalDisp = GetX11SalData()->GetDisplay();
	Display*	pXDisp = pSalDisp->GetDisplay();

	if( 1 == nSrcDrawableDepth )
	{
		XCopyPlane( pXDisp, aSrcDrawable, aDstDrawable, rGC,
					nSrcX, nSrcY, nDestWidth, nDestHeight, nDestX, nDestY, 1 );
	}
	else
	{
        XCopyArea( pXDisp, aSrcDrawable, aDstDrawable, rGC,
                   nSrcX, nSrcY, nDestWidth, nDestHeight, nDestX, nDestY );
	}
}

// ----------------------
// - ImplSalBitmapCache -
// ----------------------

struct ImplBmpObj
{
	X11SalBitmap*	mpBmp;
	sal_uLong		mnMemSize;
	sal_uLong		mnFlags;

				ImplBmpObj( X11SalBitmap* pBmp, sal_uLong nMemSize, sal_uLong nFlags ) :
					mpBmp( pBmp ), mnMemSize( nMemSize ), mnFlags( nFlags ) {}
};

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

ImplSalBitmapCache::ImplSalBitmapCache() :
	mnTotalSize( 0UL )
{
}

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

ImplSalBitmapCache::~ImplSalBitmapCache()
{
	ImplClear();
}

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

void ImplSalBitmapCache::ImplAdd( X11SalBitmap* pBmp, sal_uLong nMemSize, sal_uLong nFlags )
{
	ImplBmpObj* pObj;
	bool		bFound = sal_False;

	for( pObj = (ImplBmpObj*) maBmpList.Last(); pObj && !bFound; pObj = (ImplBmpObj*) maBmpList.Prev() )
		if( pObj->mpBmp == pBmp )
			bFound = sal_True;

	mnTotalSize += nMemSize;

	if( bFound )
	{
		mnTotalSize -= pObj->mnMemSize;
		pObj->mnMemSize = nMemSize, pObj->mnFlags = nFlags;
	}
	else
		maBmpList.Insert( new ImplBmpObj( pBmp, nMemSize, nFlags ), LIST_APPEND );
}

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

void ImplSalBitmapCache::ImplRemove( X11SalBitmap* pBmp )
{
	for( ImplBmpObj* pObj = (ImplBmpObj*) maBmpList.Last(); pObj; pObj = (ImplBmpObj*) maBmpList.Prev() )
	{
		if( pObj->mpBmp == pBmp )
		{
			maBmpList.Remove( pObj );
			pObj->mpBmp->ImplRemovedFromCache();
			mnTotalSize -= pObj->mnMemSize;
			delete pObj;
			break;
		}
	}
}

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

void ImplSalBitmapCache::ImplClear()
{
	for( ImplBmpObj* pObj = (ImplBmpObj*) maBmpList.First(); pObj; pObj = (ImplBmpObj*) maBmpList.Next() )
	{
		pObj->mpBmp->ImplRemovedFromCache();
		delete pObj;
	}

	maBmpList.Clear();
	mnTotalSize = 0;
}