xref: /aoo4110/main/vcl/win/source/gdi/salgdi.cxx (revision b1cdbd2c)

/**************************************************************
 *
 * 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 <stdio.h>
#include <string.h>
#include <rtl/strbuf.hxx>
#include <tools/svwin.h>
#include <tools/debug.hxx>
#include <tools/poly.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/polygon/b2dpolypolygontools.hxx>
#include <win/wincomp.hxx>
#include <win/saldata.hxx>
#include <win/salgdi.h>
#include <win/salframe.h>
#include <basegfx/matrix/b2dhommatrixtools.hxx>

using namespace rtl;

// =======================================================================

// comment out to prevent use of beziers on GDI functions
#define USE_GDI_BEZIERS

// =======================================================================

#define DITHER_PAL_DELTA				51
#define DITHER_PAL_STEPS				6
#define DITHER_PAL_COUNT				(DITHER_PAL_STEPS*DITHER_PAL_STEPS*DITHER_PAL_STEPS)
#define DITHER_MAX_SYSCOLOR 			16
#define DITHER_EXTRA_COLORS 			1
#define DMAP( _def_nVal, _def_nThres )	((pDitherDiff[_def_nVal]>(_def_nThres))?pDitherHigh[_def_nVal]:pDitherLow[_def_nVal])

// =======================================================================

struct SysColorEntry
{
	DWORD			nRGB;
	SysColorEntry*	pNext;
};

// =======================================================================

static SysColorEntry* pFirstSysColor = NULL;
static SysColorEntry* pActSysColor = NULL;

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

// Blue7
static PALETTEENTRY aImplExtraColor1 =
{
	0, 184, 255, 0
};

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

static PALETTEENTRY aImplSalSysPalEntryAry[ DITHER_MAX_SYSCOLOR ] =
{
{	 0,    0,	 0, 0 },
{	 0,    0, 0x80, 0 },
{	 0, 0x80,	 0, 0 },
{	 0, 0x80, 0x80, 0 },
{ 0x80,    0,	 0, 0 },
{ 0x80,    0, 0x80, 0 },
{ 0x80, 0x80,	 0, 0 },
{ 0x80, 0x80, 0x80, 0 },
{ 0xC0, 0xC0, 0xC0, 0 },
{	 0,    0, 0xFF, 0 },
{	 0, 0xFF,	 0, 0 },
{	 0, 0xFF, 0xFF, 0 },
{ 0xFF,    0,	 0, 0 },
{ 0xFF,    0, 0xFF, 0 },
{ 0xFF, 0xFF,	 0, 0 },
{ 0xFF, 0xFF, 0xFF, 0 }
};

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

static BYTE aOrdDither8Bit[8][8] =
{
	 0, 38,  9, 48,  2, 40, 12, 50,
	25, 12, 35, 22, 28, 15, 37, 24,
	 6, 44,  3, 41,  8, 47,  5, 44,
	32, 19, 28, 16, 34, 21, 31, 18,
	 1, 40, 11, 49,  0, 39, 10, 48,
	27, 14, 36, 24, 26, 13, 36, 23,
	 8, 46,  4, 43,  7, 45,  4, 42,
	33, 20, 30, 17, 32, 20, 29, 16
};

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

static BYTE aOrdDither16Bit[8][8] =
{
	0, 6, 1, 7, 0, 6, 1, 7,
	4, 2, 5, 3, 4, 2, 5, 3,
	1, 7, 0, 6, 1, 7, 0, 6,
	5, 3, 4, 2, 5, 3, 4, 2,
	0, 6, 1, 7, 0, 6, 1, 7,
	4, 2, 5, 3, 4, 2, 5, 3,
	1, 7, 0, 6, 1, 7, 0, 6,
	5, 3, 4, 2, 5, 3, 4, 2
};

// =======================================================================

// Pens muessen wir mit 1 Pixel-Breite erzeugen, da ansonsten die S3-Karte
// viele Paintprobleme hat, wenn Polygone/PolyLines gezeichnet werden und
// eine komplexe ClipRegion gesetzt ist
#define GSL_PEN_WIDTH					1

// =======================================================================

#define SAL_POLYPOLYCOUNT_STACKBUF			8
#define SAL_POLYPOLYPOINTS_STACKBUF 		64

// =======================================================================

void ImplInitSalGDI()
{
	SalData* pSalData = GetSalData();

	// init stock brushes
	pSalData->maStockPenColorAry[0] 	= PALETTERGB( 0, 0, 0 );
	pSalData->maStockPenColorAry[1] 	= PALETTERGB( 0xFF, 0xFF, 0xFF );
	pSalData->maStockPenColorAry[2] 	= PALETTERGB( 0xC0, 0xC0, 0xC0 );
	pSalData->maStockPenColorAry[3] 	= PALETTERGB( 0x80, 0x80, 0x80 );
	pSalData->mhStockPenAry[0]			= CreatePen( PS_SOLID, GSL_PEN_WIDTH, pSalData->maStockPenColorAry[0] );
	pSalData->mhStockPenAry[1]			= CreatePen( PS_SOLID, GSL_PEN_WIDTH, pSalData->maStockPenColorAry[1] );
	pSalData->mhStockPenAry[2]			= CreatePen( PS_SOLID, GSL_PEN_WIDTH, pSalData->maStockPenColorAry[2] );
	pSalData->mhStockPenAry[3]			= CreatePen( PS_SOLID, GSL_PEN_WIDTH, pSalData->maStockPenColorAry[3] );
	pSalData->mnStockPenCount = 4;

	pSalData->maStockBrushColorAry[0]	= PALETTERGB( 0, 0, 0 );
	pSalData->maStockBrushColorAry[1]	= PALETTERGB( 0xFF, 0xFF, 0xFF );
	pSalData->maStockBrushColorAry[2]	= PALETTERGB( 0xC0, 0xC0, 0xC0 );
	pSalData->maStockBrushColorAry[3]	= PALETTERGB( 0x80, 0x80, 0x80 );
	pSalData->mhStockBrushAry[0]		= CreateSolidBrush( pSalData->maStockBrushColorAry[0] );
	pSalData->mhStockBrushAry[1]		= CreateSolidBrush( pSalData->maStockBrushColorAry[1] );
	pSalData->mhStockBrushAry[2]		= CreateSolidBrush( pSalData->maStockBrushColorAry[2] );
	pSalData->mhStockBrushAry[3]		= CreateSolidBrush( pSalData->maStockBrushColorAry[3] );
	pSalData->mnStockBrushCount = 4;

	// initialize cache of device contexts
	pSalData->mpHDCCache = new HDCCache[ CACHESIZE_HDC ];
	memset( pSalData->mpHDCCache, 0, CACHESIZE_HDC * sizeof( HDCCache ) );

    // initialize temporary font list
    pSalData->mpTempFontItem = NULL;

	// support palettes for 256 color displays
	HDC hDC = GetDC( 0 );
	int nBitsPixel = GetDeviceCaps( hDC, BITSPIXEL );
	int nPlanes = GetDeviceCaps( hDC, PLANES );
	int nRasterCaps = GetDeviceCaps( hDC, RASTERCAPS );
	int nBitCount = nBitsPixel * nPlanes;

	if ( (nBitCount > 8) && (nBitCount < 24) )
	{
		// test, if we have to dither
		HDC 		hMemDC = ::CreateCompatibleDC( hDC );
		HBITMAP 	hMemBmp = ::CreateCompatibleBitmap( hDC, 8, 8 );
		HBITMAP 	hBmpOld = (HBITMAP) ::SelectObject( hMemDC, hMemBmp );
		HBRUSH		hMemBrush = ::CreateSolidBrush( PALETTERGB( 175, 171, 169 ) );
		HBRUSH		hBrushOld = (HBRUSH) ::SelectObject( hMemDC, hMemBrush );
		sal_Bool		bDither16 = TRUE;

		::PatBlt( hMemDC, 0, 0, 8, 8, PATCOPY );
		const COLORREF aCol( ::GetPixel( hMemDC, 0, 0 ) );

		for( int nY = 0; ( nY < 8 ) && bDither16; nY++ )
			for( int nX = 0; ( nX < 8 ) && bDither16; nX++ )
				if( ::GetPixel( hMemDC, nX, nY ) != aCol )
					bDither16 = FALSE;

		::SelectObject( hMemDC, hBrushOld ), ::DeleteObject( hMemBrush );
		::SelectObject( hMemDC, hBmpOld ), ::DeleteObject( hMemBmp );
		::DeleteDC( hMemDC );

		if( bDither16 )
		{
			// create DIBPattern for 16Bit dithering
			long n;

			pSalData->mhDitherDIB = GlobalAlloc( GMEM_FIXED, sizeof( BITMAPINFOHEADER ) + 192 );
			pSalData->mpDitherDIB = (BYTE*) GlobalLock( pSalData->mhDitherDIB );
			pSalData->mpDitherDiff = new long[ 256 ];
			pSalData->mpDitherLow = new BYTE[ 256 ];
			pSalData->mpDitherHigh = new BYTE[ 256 ];
			pSalData->mpDitherDIBData = pSalData->mpDitherDIB + sizeof( BITMAPINFOHEADER );
			memset( pSalData->mpDitherDIB, 0, sizeof( BITMAPINFOHEADER ) );

			BITMAPINFOHEADER* pBIH = (BITMAPINFOHEADER*) pSalData->mpDitherDIB;

			pBIH->biSize = sizeof( BITMAPINFOHEADER );
			pBIH->biWidth = 8;
			pBIH->biHeight = 8;
			pBIH->biPlanes = 1;
			pBIH->biBitCount = 24;

			for( n = 0; n < 256L; n++ )
				pSalData->mpDitherDiff[ n ] = n - ( n & 248L );

			for( n = 0; n < 256L; n++ )
				pSalData->mpDitherLow[ n ] = (BYTE) ( n & 248 );

			for( n = 0; n < 256L; n++ )
				pSalData->mpDitherHigh[ n ] = (BYTE) Min( pSalData->mpDitherLow[ n ] + 8L, 255L );
		}
	}
	else if ( (nRasterCaps & RC_PALETTE) && (nBitCount == 8) )
	{
		BYTE			nRed, nGreen, nBlue;
		BYTE			nR, nG, nB;
		PALETTEENTRY*	pPalEntry;
		LOGPALETTE* 	pLogPal;
		const sal_uInt16	nDitherPalCount = DITHER_PAL_COUNT;
		sal_uLong			nTotalCount = DITHER_MAX_SYSCOLOR + nDitherPalCount + DITHER_EXTRA_COLORS;

		// create logical palette
		pLogPal = (LOGPALETTE*) new char[ sizeof( LOGPALETTE ) + ( nTotalCount * sizeof( PALETTEENTRY ) ) ];
		pLogPal->palVersion = 0x0300;
		pLogPal->palNumEntries = (sal_uInt16) nTotalCount;
		pPalEntry = pLogPal->palPalEntry;

		// Standard colors
		memcpy( pPalEntry, aImplSalSysPalEntryAry, DITHER_MAX_SYSCOLOR * sizeof( PALETTEENTRY ) );
		pPalEntry += DITHER_MAX_SYSCOLOR;

		// own palette (6/6/6)
		for( nB=0, nBlue=0; nB < DITHER_PAL_STEPS; nB++, nBlue += DITHER_PAL_DELTA )
		{
			for( nG=0, nGreen=0; nG < DITHER_PAL_STEPS; nG++, nGreen += DITHER_PAL_DELTA )
			{
				for( nR=0, nRed=0; nR < DITHER_PAL_STEPS; nR++, nRed += DITHER_PAL_DELTA )
				{
					pPalEntry->peRed   = nRed;
					pPalEntry->peGreen = nGreen;
					pPalEntry->peBlue  = nBlue;
					pPalEntry->peFlags = 0;
					pPalEntry++;
				}
			}
		}

		// insert special 'Blue' as standard drawing color
		*pPalEntry++ = aImplExtraColor1;

		// create palette
		pSalData->mhDitherPal = CreatePalette( pLogPal );
		delete[] (char*) pLogPal;

		if( pSalData->mhDitherPal )
		{
			// create DIBPattern for 8Bit dithering
			long nSize = sizeof( BITMAPINFOHEADER ) + ( 256 * sizeof( short ) ) + 64;
			long n;

			pSalData->mhDitherDIB = GlobalAlloc( GMEM_FIXED, nSize );
			pSalData->mpDitherDIB = (BYTE*) GlobalLock( pSalData->mhDitherDIB );
			pSalData->mpDitherDiff = new long[ 256 ];
			pSalData->mpDitherLow = new BYTE[ 256 ];
			pSalData->mpDitherHigh = new BYTE[ 256 ];
			pSalData->mpDitherDIBData = pSalData->mpDitherDIB + sizeof( BITMAPINFOHEADER ) + ( 256 * sizeof( short ) );
			memset( pSalData->mpDitherDIB, 0, sizeof( BITMAPINFOHEADER ) );

			BITMAPINFOHEADER*	pBIH = (BITMAPINFOHEADER*) pSalData->mpDitherDIB;
			short*				pColors = (short*) ( pSalData->mpDitherDIB + sizeof( BITMAPINFOHEADER ) );

			pBIH->biSize = sizeof( BITMAPINFOHEADER );
			pBIH->biWidth = 8;
			pBIH->biHeight = 8;
			pBIH->biPlanes = 1;
			pBIH->biBitCount = 8;

			for( n = 0; n < nDitherPalCount; n++ )
				pColors[ n ] = (short)( n + DITHER_MAX_SYSCOLOR );

			for( n = 0; n < 256L; n++ )
				pSalData->mpDitherDiff[ n ] = n % 51L;

			for( n = 0; n < 256L; n++ )
				pSalData->mpDitherLow[ n ] = (BYTE) ( n / 51L );

			for( n = 0; n < 256L; n++ )
				pSalData->mpDitherHigh[ n ] = (BYTE)Min( pSalData->mpDitherLow[ n ] + 1, 5 );
		}

		// get system color entries
		ImplUpdateSysColorEntries();
	}

	ReleaseDC( 0, hDC );
}

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

void ImplFreeSalGDI()
{
	SalData*	pSalData = GetSalData();

	// destroy stock objects
	int	i;
	for ( i = 0; i < pSalData->mnStockPenCount; i++ )
		DeletePen( pSalData->mhStockPenAry[i] );
	for ( i = 0; i < pSalData->mnStockBrushCount; i++ )
		DeleteBrush( pSalData->mhStockBrushAry[i] );

	// 50% Brush loeschen
	if ( pSalData->mh50Brush )
	{
		DeleteBrush( pSalData->mh50Brush );
		pSalData->mh50Brush = 0;
	}

	// 50% Bitmap loeschen
	if ( pSalData->mh50Bmp )
	{
		DeleteBitmap( pSalData->mh50Bmp );
		pSalData->mh50Bmp = 0;
	}

	ImplClearHDCCache( pSalData );
	delete[] pSalData->mpHDCCache;

	// Ditherpalette loeschen, wenn vorhanden
	if ( pSalData->mhDitherPal )
	{
		DeleteObject( pSalData->mhDitherPal );
		pSalData->mhDitherPal = 0;
	}

	// delete buffers for dithering DIB patterns, if neccessary
	if ( pSalData->mhDitherDIB )
	{
		GlobalUnlock( pSalData->mhDitherDIB );
		GlobalFree( pSalData->mhDitherDIB );
		pSalData->mhDitherDIB = 0;
		delete[] pSalData->mpDitherDiff;
		delete[] pSalData->mpDitherLow;
		delete[] pSalData->mpDitherHigh;
	}

	// delete SysColorList
	SysColorEntry* pEntry = pFirstSysColor;
	while( pEntry )
	{
		SysColorEntry* pTmp = pEntry->pNext;
		delete pEntry;
		pEntry = pTmp;
	}
	pFirstSysColor = NULL;

    // delete icon cache
    SalIcon* pIcon = pSalData->mpFirstIcon;
    pSalData->mpFirstIcon = NULL;
    while( pIcon )
    {
        SalIcon* pTmp = pIcon->pNext;
        DestroyIcon( pIcon->hIcon );
        DestroyIcon( pIcon->hSmallIcon );
        delete pIcon;
        pIcon = pTmp;
    }

    // delete temporary font list
    ImplReleaseTempFonts( *pSalData );
}

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

static int ImplIsPaletteEntry( BYTE nRed, BYTE nGreen, BYTE nBlue )
{
	// dither color?
	if ( !(nRed % DITHER_PAL_DELTA) && !(nGreen % DITHER_PAL_DELTA) && !(nBlue % DITHER_PAL_DELTA) )
		return TRUE;

	PALETTEENTRY* pPalEntry = aImplSalSysPalEntryAry;

	// standard palette color?
	for ( sal_uInt16 i = 0; i < DITHER_MAX_SYSCOLOR; i++, pPalEntry++ )
	{
		if( pPalEntry->peRed == nRed && pPalEntry->peGreen == nGreen && pPalEntry->peBlue == nBlue )
			return TRUE;
	}

	// extra color?
	if ( aImplExtraColor1.peRed == nRed &&
		 aImplExtraColor1.peGreen == nGreen &&
		 aImplExtraColor1.peBlue == nBlue )
	{
		return TRUE;
	}

	return FALSE;
}

// =======================================================================

int ImplIsSysColorEntry( SalColor nSalColor )
{
	SysColorEntry*	pEntry = pFirstSysColor;
	const DWORD 	nTestRGB = (DWORD)RGB( SALCOLOR_RED( nSalColor ),
										   SALCOLOR_GREEN( nSalColor ),
										   SALCOLOR_BLUE( nSalColor ) );

	while ( pEntry )
	{
		if ( pEntry->nRGB == nTestRGB )
			return TRUE;
		pEntry = pEntry->pNext;
	}

	return FALSE;
}

// =======================================================================

static void ImplInsertSysColorEntry( int nSysIndex )
{
	const DWORD nRGB = GetSysColor( nSysIndex );

	if ( !ImplIsPaletteEntry( GetRValue( nRGB ), GetGValue( nRGB ), GetBValue( nRGB ) ) )
	{
		if ( !pFirstSysColor )
		{
			pActSysColor = pFirstSysColor = new SysColorEntry;
			pFirstSysColor->nRGB = nRGB;
			pFirstSysColor->pNext = NULL;
		}
		else
		{
			pActSysColor = pActSysColor->pNext = new SysColorEntry;
			pActSysColor->nRGB = nRGB;
			pActSysColor->pNext = NULL;
		}
	}
}

// =======================================================================

void ImplUpdateSysColorEntries()
{
	// delete old SysColorList
	SysColorEntry* pEntry = pFirstSysColor;
	while( pEntry )
	{
		SysColorEntry* pTmp = pEntry->pNext;
		delete pEntry;
		pEntry = pTmp;
	}
	pActSysColor = pFirstSysColor = NULL;

	// create new sys color list
	ImplInsertSysColorEntry( COLOR_ACTIVEBORDER );
	ImplInsertSysColorEntry( COLOR_INACTIVEBORDER );
	if( aSalShlData.mnVersion >= 410 )
	{
		ImplInsertSysColorEntry( COLOR_GRADIENTACTIVECAPTION );
		ImplInsertSysColorEntry( COLOR_GRADIENTINACTIVECAPTION );
	}
	ImplInsertSysColorEntry( COLOR_3DFACE );
	ImplInsertSysColorEntry( COLOR_3DHILIGHT );
	ImplInsertSysColorEntry( COLOR_3DLIGHT );
	ImplInsertSysColorEntry( COLOR_3DSHADOW );
	ImplInsertSysColorEntry( COLOR_3DDKSHADOW );
	ImplInsertSysColorEntry( COLOR_INFOBK );
	ImplInsertSysColorEntry( COLOR_INFOTEXT );
	ImplInsertSysColorEntry( COLOR_BTNTEXT );
	ImplInsertSysColorEntry( COLOR_WINDOW );
	ImplInsertSysColorEntry( COLOR_WINDOWTEXT );
	ImplInsertSysColorEntry( COLOR_HIGHLIGHT );
	ImplInsertSysColorEntry( COLOR_HIGHLIGHTTEXT );
	ImplInsertSysColorEntry( COLOR_MENU );
	ImplInsertSysColorEntry( COLOR_MENUTEXT );
	ImplInsertSysColorEntry( COLOR_ACTIVECAPTION );
	ImplInsertSysColorEntry( COLOR_CAPTIONTEXT );
	ImplInsertSysColorEntry( COLOR_INACTIVECAPTION );
	ImplInsertSysColorEntry( COLOR_INACTIVECAPTIONTEXT );
}

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

static SalColor ImplGetROPSalColor( SalROPColor nROPColor )
{
	SalColor nSalColor;
	if ( nROPColor == SAL_ROP_0 )
		nSalColor = MAKE_SALCOLOR( 0, 0, 0 );
	else
		nSalColor = MAKE_SALCOLOR( 255, 255, 255 );
	return nSalColor;
}

// =======================================================================

void ImplSalInitGraphics( WinSalGraphics* pData )
{
	// Beim Printer berechnen wir die minimale Linienstaerke
	if ( pData->mbPrinter )
	{
		int nDPIX = GetDeviceCaps( pData->getHDC(), LOGPIXELSX );
		if ( nDPIX <= 300 )
			pData->mnPenWidth = 0;
		else
			pData->mnPenWidth = nDPIX/300;
	}

	::SetTextAlign( pData->getHDC(), TA_BASELINE | TA_LEFT | TA_NOUPDATECP );
	::SetBkMode( pData->getHDC(), TRANSPARENT );
	::SetROP2( pData->getHDC(), R2_COPYPEN );
}

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

void ImplSalDeInitGraphics( WinSalGraphics* pData )
{
    // clear clip region
	SelectClipRgn( pData->getHDC(), 0 );
	// select default objects
	if ( pData->mhDefPen )
		SelectPen( pData->getHDC(), pData->mhDefPen );
	if ( pData->mhDefBrush )
		SelectBrush( pData->getHDC(), pData->mhDefBrush );
	if ( pData->mhDefFont )
		SelectFont( pData->getHDC(), pData->mhDefFont );
}

// =======================================================================

HDC ImplGetCachedDC( sal_uLong nID, HBITMAP hBmp )
{
	SalData*	pSalData = GetSalData();
	HDCCache*	pC = &pSalData->mpHDCCache[ nID ];

	if( !pC->mhDC )
	{
		HDC hDC = GetDC( 0 );

		// neuen DC mit DefaultBitmap anlegen
		pC->mhDC = CreateCompatibleDC( hDC );

		if( pSalData->mhDitherPal )
		{
			pC->mhDefPal = SelectPalette( pC->mhDC, pSalData->mhDitherPal, TRUE );
			RealizePalette( pC->mhDC );
		}

		pC->mhSelBmp = CreateCompatibleBitmap( hDC, CACHED_HDC_DEFEXT, CACHED_HDC_DEFEXT );
		pC->mhDefBmp = (HBITMAP) SelectObject( pC->mhDC, pC->mhSelBmp );

		ReleaseDC( 0, hDC );
	}

	if ( hBmp )
		SelectObject( pC->mhDC, pC->mhActBmp = hBmp );
	else
		pC->mhActBmp = 0;

	return pC->mhDC;
}

// =======================================================================

void ImplReleaseCachedDC( sal_uLong nID )
{
	SalData*	pSalData = GetSalData();
	HDCCache*	pC = &pSalData->mpHDCCache[ nID ];

	if ( pC->mhActBmp )
		SelectObject( pC->mhDC, pC->mhSelBmp );
}

// =======================================================================

void ImplClearHDCCache( SalData* pData )
{
	for( sal_uLong i = 0; i < CACHESIZE_HDC; i++ )
	{
		HDCCache* pC = &pData->mpHDCCache[ i ];

		if( pC->mhDC )
		{
			SelectObject( pC->mhDC, pC->mhDefBmp );

			if( pC->mhDefPal )
				SelectPalette( pC->mhDC, pC->mhDefPal, TRUE );

			DeleteDC( pC->mhDC );
			DeleteObject( pC->mhSelBmp );
		}
	}
}

// =======================================================================

// #100127# Fill point and flag memory from array of points which
// might also contain bezier control points for the PolyDraw() GDI method
// Make sure pWinPointAry and pWinFlagAry are big enough
void ImplPreparePolyDraw( bool						bCloseFigures,
                          sal_uLong 					nPoly,
                          const sal_uLong* 				pPoints,
                          const SalPoint* const* 	pPtAry,
                          const BYTE* const* 		pFlgAry,
                          POINT* 					pWinPointAry,
                          BYTE* 					pWinFlagAry		)
{
    sal_uLong nCurrPoly;
    for( nCurrPoly=0; nCurrPoly<nPoly; ++nCurrPoly )
    {
        const POINT* pCurrPoint = reinterpret_cast<const POINT*>( *pPtAry++ );
        const BYTE* pCurrFlag = *pFlgAry++;
        const sal_uLong nCurrPoints = *pPoints++;
        const bool bHaveFlagArray( pCurrFlag );
        sal_uLong nCurrPoint;

        if( nCurrPoints )
        {
            // start figure
            *pWinPointAry++ = *pCurrPoint++;
            *pWinFlagAry++  = PT_MOVETO;
            ++pCurrFlag;

            for( nCurrPoint=1; nCurrPoint<nCurrPoints; )
            {
                // #102067# Check existence of flag array
                if( bHaveFlagArray &&
                    ( nCurrPoint + 2 ) < nCurrPoints )
                {
                    BYTE P4( pCurrFlag[ 2 ] );

                    if( ( POLY_CONTROL == pCurrFlag[ 0 ] ) &&
                        ( POLY_CONTROL == pCurrFlag[ 1 ] ) &&
                        ( POLY_NORMAL == P4 || POLY_SMOOTH == P4 || POLY_SYMMTR == P4 ) )
                    {
                        // control point one
                        *pWinPointAry++ = *pCurrPoint++;
                        *pWinFlagAry++  = PT_BEZIERTO;

                        // control point two
                        *pWinPointAry++ = *pCurrPoint++;
                        *pWinFlagAry++  = PT_BEZIERTO;

                        // end point
                        *pWinPointAry++ = *pCurrPoint++;
                        *pWinFlagAry++  = PT_BEZIERTO;

                        nCurrPoint += 3;
                        pCurrFlag += 3;
                        continue;
                    }
                }

                // regular line point
                *pWinPointAry++ = *pCurrPoint++;
                *pWinFlagAry++  = PT_LINETO;
                ++pCurrFlag;
                ++nCurrPoint;
            }

            // end figure?
            if( bCloseFigures )
                pWinFlagAry[-1] |= PT_CLOSEFIGURE;
        }
    }
}

// =======================================================================

// #100127# draw an array of points which might also contain bezier control points
void ImplRenderPath( HDC hdc, sal_uLong nPoints, const SalPoint* pPtAry, const BYTE* pFlgAry )
{
    if( nPoints )
    {
        sal_uInt16 i;
        // TODO: profile whether the following options are faster:
        // a) look ahead and draw consecutive bezier or line segments by PolyBezierTo/PolyLineTo resp.
        // b) convert our flag array to window's and use PolyDraw

        MoveToEx( hdc, pPtAry->mnX, pPtAry->mnY, NULL );
        ++pPtAry; ++pFlgAry;

        for( i=1; i<nPoints; ++i, ++pPtAry, ++pFlgAry )
        {
            if( *pFlgAry != POLY_CONTROL )
            {
                LineTo( hdc, pPtAry->mnX, pPtAry->mnY );
            }
            else if( nPoints - i > 2 )
            {
                PolyBezierTo( hdc, reinterpret_cast<const POINT*>(pPtAry), 3 );
                i += 2; pPtAry += 2; pFlgAry += 2;
            }
        }
    }
}

// =======================================================================

WinSalGraphics::WinSalGraphics()
{
    for( int i = 0; i < MAX_FALLBACK; ++i )
    {
        mhFonts[ i ] = 0;
        mpWinFontData[ i ]  = NULL;
        mpWinFontEntry[ i ] = NULL;
    }

    mfFontScale = 1.0;

	mhLocalDC			= 0;
	mhPen				= 0;
	mhBrush				= 0;
	mhRegion 			= 0;
	mhDefPen 			= 0;
	mhDefBrush			= 0;
	mhDefFont			= 0;
	mhDefPal 			= 0;
	mpStdClipRgnData 	= NULL;
	mpLogFont			= NULL;
	mpFontCharSets		= NULL;
	mpFontAttrCache		= NULL;
	mnFontCharSetCount	= 0;
	mpFontKernPairs		= NULL;
	mnFontKernPairCount	= 0;
	mbFontKernInit		= FALSE;
	mbXORMode			= FALSE;
	mnPenWidth			= GSL_PEN_WIDTH;
}

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

WinSalGraphics::~WinSalGraphics()
{
	// free obsolete GDI objekts
        ReleaseFonts();

	if ( mhPen )
	{
		if ( !mbStockPen )
			DeletePen( mhPen );
	}
	if ( mhBrush )
	{
		if ( !mbStockBrush )
			DeleteBrush( mhBrush );
	}

	if ( mhRegion )
	{
		DeleteRegion( mhRegion );
		mhRegion = 0;
	}

	// Cache-Daten zerstoeren
	if ( mpStdClipRgnData )
		delete [] mpStdClipRgnData;

	if ( mpLogFont )
		delete mpLogFont;

	if ( mpFontCharSets )
		delete mpFontCharSets;

	if ( mpFontKernPairs )
		delete mpFontKernPairs;
}

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

void WinSalGraphics::GetResolution( sal_Int32& rDPIX, sal_Int32& rDPIY )
{
	rDPIX = GetDeviceCaps( getHDC(), LOGPIXELSX );
	rDPIY = GetDeviceCaps( getHDC(), LOGPIXELSY );

    // #111139# this fixes the symptom of div by zero on startup
    // however, printing will fail most likely as communication with
    // the printer seems not to work in this case
    if( !rDPIX || !rDPIY )
        rDPIX = rDPIY = 600;
}

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

sal_uInt16 WinSalGraphics::GetBitCount()
{
	return (sal_uInt16)GetDeviceCaps( getHDC(), BITSPIXEL );
}

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

long WinSalGraphics::GetGraphicsWidth() const
{
    if( mhWnd && IsWindow( mhWnd ) )
    {
        WinSalFrame* pFrame = GetWindowPtr( mhWnd );
        if( pFrame )
        {
            if( pFrame->maGeometry.nWidth )
                return pFrame->maGeometry.nWidth;
            else
            {
                // TODO: perhaps not needed, maGeometry should always be up-to-date
                RECT aRect;
                GetClientRect( mhWnd, &aRect );
                return aRect.right;
            }
        }
    }

    return 0;
}

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

void WinSalGraphics::ResetClipRegion()
{
	if ( mhRegion )
	{
		DeleteRegion( mhRegion );
		mhRegion = 0;
	}

	SelectClipRgn( getHDC(), 0 );
}

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

bool WinSalGraphics::setClipRegion( const Region& i_rClip )
{
    if ( mhRegion )
    {
        DeleteRegion( mhRegion );
        mhRegion = 0;
    }

    bool bUsePolygon(i_rClip.HasPolyPolygonOrB2DPolyPolygon());
    static bool bTryToAvoidPolygon(true);

    // #122149# try to avoid usage of PolyPolygon ClipRegions when PolyPolygon is no curve
    // and only contains horizontal/vertical edges. In that case, use the fallback
    // in GetRegionRectangles which will use Region::GetAsRegionBand() which will do
    // the correct polygon-to-RegionBand transformation.
    // Background is that when using the same Rectangle as rectangle or as Polygon
    // clip region will lead to different results; the polygon-based one will be
    // one pixel less to the right and down (see GDI docu for CreatePolygonRgn). This
    // again is because of the polygon-nature and it's classic handling when filling.
    // This also means that all cases which use a 'true' polygon-based incarnation of
    // a Region should know what they do - it may lead to repaint errors.
    if(bUsePolygon && bTryToAvoidPolygon)
    {
        const basegfx::B2DPolyPolygon aPolyPolygon( i_rClip.GetAsB2DPolyPolygon() );

        if(!aPolyPolygon.areControlPointsUsed())
        {
            if(basegfx::tools::containsOnlyHorizontalAndVerticalEdges(aPolyPolygon))
            {
                bUsePolygon = false;
            }
        }
    }

    if(bUsePolygon)
    {
        // #122149# check the comment above to know that this may lead to potentioal repaint
        // problems. It may be solved (if needed) by scaling the polygon by one in X
        // and Y. Currently the workaround to only use it if really unavoidable will
        // solve most cases. When someone is really using polygon-based Regions he
        // should know what he is doing.
        // Added code to do that scaling to check if it works, testing it.
        const basegfx::B2DPolyPolygon aPolyPolygon( i_rClip.GetAsB2DPolyPolygon() );
        const sal_uInt32 nCount(aPolyPolygon.count());

        if( nCount )
        {
            std::vector< POINT > aPolyPoints;
            aPolyPoints.reserve( 1024 );
            std::vector< INT > aPolyCounts( nCount, 0 );
            basegfx::B2DHomMatrix aExpand;
            static bool bExpandByOneInXandY(true);

            if(bExpandByOneInXandY)
            {
                const basegfx::B2DRange aRangeS(aPolyPolygon.getB2DRange());
                const basegfx::B2DRange aRangeT(aRangeS.getMinimum(), aRangeS.getMaximum() + basegfx::B2DTuple(1.0, 1.0));
                aExpand = basegfx::B2DHomMatrix(basegfx::tools::createSourceRangeTargetRangeTransform(aRangeS, aRangeT));
            }

            for(sal_uInt32 a(0); a < nCount; a++)
            {
                const basegfx::B2DPolygon aPoly(
                    basegfx::tools::adaptiveSubdivideByDistance(
                        aPolyPolygon.getB2DPolygon(a),
                        1));
                const sal_uInt32 nPoints(aPoly.count());
                aPolyCounts[a] = nPoints;

                for( sal_uInt32 b = 0; b < nPoints; b++ )
                {
                    basegfx::B2DPoint aPt(aPoly.getB2DPoint(b));

                    if(bExpandByOneInXandY)
                    {
                        aPt = aExpand * aPt;
                    }

                    POINT aPOINT;
                    // #122149# do correct rounding
                    aPOINT.x = basegfx::fround(aPt.getX());
                    aPOINT.y = basegfx::fround(aPt.getY());
                    aPolyPoints.push_back( aPOINT );
                }
            }

            mhRegion = CreatePolyPolygonRgn( &aPolyPoints[0], &aPolyCounts[0], nCount, ALTERNATE );
        }
	}
	else
	{
        RectangleVector aRectangles;
        i_rClip.GetRegionRectangles(aRectangles);

        //ULONG nRectCount = i_rClip.GetRectCount();
	    ULONG nRectBufSize = sizeof(RECT)*aRectangles.size();
        if ( aRectangles.size() < SAL_CLIPRECT_COUNT )
        {
            if ( !mpStdClipRgnData )
                mpStdClipRgnData = (RGNDATA*)new BYTE[sizeof(RGNDATA)-1+(SAL_CLIPRECT_COUNT*sizeof(RECT))];
            mpClipRgnData = mpStdClipRgnData;
        }
        else
            mpClipRgnData = (RGNDATA*)new BYTE[sizeof(RGNDATA)-1+nRectBufSize];
        mpClipRgnData->rdh.dwSize	= sizeof( RGNDATAHEADER );
        mpClipRgnData->rdh.iType 	= RDH_RECTANGLES;
        mpClipRgnData->rdh.nCount	= aRectangles.size();
        mpClipRgnData->rdh.nRgnSize	= nRectBufSize;
        RECT*		pBoundRect = &(mpClipRgnData->rdh.rcBound);
        SetRectEmpty( pBoundRect );
        RECT* pNextClipRect         = (RECT*)(&(mpClipRgnData->Buffer));
        bool bFirstClipRect         = true;

        for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); aRectIter++)
        {
            const long nW(aRectIter->GetWidth());
            const long nH(aRectIter->GetHeight());

            if(nW && nH)
            {
                const long nRight(aRectIter->Left() + nW);
                const long nBottom(aRectIter->Top() + nH);

                if(bFirstClipRect)
                {
                    pBoundRect->left = aRectIter->Left();
                    pBoundRect->top = aRectIter->Top();
                    pBoundRect->right = nRight;
                    pBoundRect->bottom = nBottom;
                    bFirstClipRect = false;
                }
                else
                {
                    if(aRectIter->Left() < pBoundRect->left)
                    {
                        pBoundRect->left = (int)aRectIter->Left();
                    }

                    if(aRectIter->Top() < pBoundRect->top)
                    {
                        pBoundRect->top = (int)aRectIter->Top();
                    }

                    if(nRight > pBoundRect->right)
                    {
                        pBoundRect->right = (int)nRight;
                    }

                    if(nBottom > pBoundRect->bottom)
                    {
                        pBoundRect->bottom = (int)nBottom;
                    }
                }

                pNextClipRect->left = (int)aRectIter->Left();
                pNextClipRect->top = (int)aRectIter->Top();
                pNextClipRect->right = (int)nRight;
                pNextClipRect->bottom = (int)nBottom;
                pNextClipRect++;
            }
            else
            {
                mpClipRgnData->rdh.nCount--;
                mpClipRgnData->rdh.nRgnSize -= sizeof( RECT );
            }
        }

        // create clip region from ClipRgnData
        if(0 == mpClipRgnData->rdh.nCount)
        {
            // #123585# region is empty; this may happen when e.g. a PolyPolygon is given
            // that contains no polygons or only empty ones (no width/height). This is
            // perfectly fine and we are done, except setting it (see end of method)
        }
        else if(1 == mpClipRgnData->rdh.nCount)
        {
            RECT* pRect = &(mpClipRgnData->rdh.rcBound);
            mhRegion = CreateRectRgn( pRect->left, pRect->top,
                                                     pRect->right, pRect->bottom );
        }
        else if(mpClipRgnData->rdh.nCount > 1)
        {
            ULONG nSize = mpClipRgnData->rdh.nRgnSize+sizeof(RGNDATAHEADER);
            mhRegion = ExtCreateRegion( NULL, nSize, mpClipRgnData );

            // if ExtCreateRegion(...) is not supported
            if( !mhRegion )
            {
                RGNDATAHEADER* pHeader = (RGNDATAHEADER*) mpClipRgnData;

                if( pHeader->nCount )
                {
                    RECT* pRect = (RECT*) mpClipRgnData->Buffer;
                    mhRegion = CreateRectRgn( pRect->left, pRect->top, pRect->right, pRect->bottom );
                    pRect++;

                    for( ULONG n = 1; n < pHeader->nCount; n++, pRect++ )
                    {
                        HRGN hRgn = CreateRectRgn( pRect->left, pRect->top, pRect->right, pRect->bottom );
                        CombineRgn( mhRegion, mhRegion, hRgn, RGN_OR );
                        DeleteRegion( hRgn );
                    }
                }
            }

            if ( mpClipRgnData != mpStdClipRgnData )
                delete [] mpClipRgnData;
        }
	}

	if( mhRegion )
    {
        SelectClipRgn( getHDC(), mhRegion );

        // debug code if you weant to check range of the newly applied ClipRegion
        //RECT aBound;
        //const int aRegionType = GetRgnBox(mhRegion, &aBound);
        //
        //bool bBla = true;
    }
    else
    {
        // #123585# See above, this is a valid case, execute it
        SelectClipRgn( getHDC(), 0 );
    }

    // #123585# retval no longer dependent of mhRegion, see TaskId comments above
    return true;
}

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

void WinSalGraphics::SetLineColor()
{
	// create and select new pen
	HPEN hNewPen = GetStockPen( NULL_PEN );
	HPEN hOldPen = SelectPen( getHDC(), hNewPen );

	// destory or save old pen
	if ( mhPen )
	{
		if ( !mbStockPen )
			DeletePen( mhPen );
	}
	else
		mhDefPen = hOldPen;

	// set new data
	mhPen		= hNewPen;
	mbPen		= FALSE;
	mbStockPen	= TRUE;
}

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

void WinSalGraphics::SetLineColor( SalColor nSalColor )
{
    maLineColor = nSalColor;
	COLORREF	nPenColor = PALETTERGB( SALCOLOR_RED( nSalColor ),
										SALCOLOR_GREEN( nSalColor ),
										SALCOLOR_BLUE( nSalColor ) );
	HPEN		hNewPen = 0;
	sal_Bool		bStockPen = FALSE;

	// search for stock pen (only screen, because printer have problems,
	// when we use stock objects)
	if ( !mbPrinter )
	{
		SalData* pSalData = GetSalData();
		for ( sal_uInt16 i = 0; i < pSalData->mnStockPenCount; i++ )
		{
			if ( nPenColor == pSalData->maStockPenColorAry[i] )
			{
				hNewPen = pSalData->mhStockPenAry[i];
				bStockPen = TRUE;
				break;
			}
		}
	}

	// create new pen
	if ( !hNewPen )
	{
		if ( !mbPrinter )
		{
			if ( GetSalData()->mhDitherPal && ImplIsSysColorEntry( nSalColor ) )
				nPenColor = PALRGB_TO_RGB( nPenColor );
		}

		hNewPen = CreatePen( PS_SOLID, mnPenWidth, nPenColor );
		bStockPen = FALSE;
	}

	// select new pen
	HPEN hOldPen = SelectPen( getHDC(), hNewPen );

	// destory or save old pen
	if ( mhPen )
	{
		if ( !mbStockPen )
			DeletePen( mhPen );
	}
	else
		mhDefPen = hOldPen;

	// set new data
	mnPenColor	= nPenColor;
	mhPen		= hNewPen;
	mbPen		= TRUE;
	mbStockPen	= bStockPen;
}

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

void WinSalGraphics::SetFillColor()
{
	// create and select new brush
	HBRUSH hNewBrush = GetStockBrush( NULL_BRUSH );
	HBRUSH hOldBrush = SelectBrush( getHDC(), hNewBrush );

	// destory or save old brush
	if ( mhBrush )
	{
		if ( !mbStockBrush )
			DeleteBrush( mhBrush );
	}
	else
		mhDefBrush = hOldBrush;

	// set new data
	mhBrush		= hNewBrush;
	mbBrush		= FALSE;
	mbStockBrush = TRUE;
}

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

void WinSalGraphics::SetFillColor( SalColor nSalColor )
{
    maFillColor = nSalColor;
	SalData*	pSalData	= GetSalData();
	BYTE		nRed		= SALCOLOR_RED( nSalColor );
	BYTE		nGreen		= SALCOLOR_GREEN( nSalColor );
	BYTE		nBlue		= SALCOLOR_BLUE( nSalColor );
	COLORREF	nBrushColor = PALETTERGB( nRed, nGreen, nBlue );
	HBRUSH		hNewBrush	= 0;
	sal_Bool		bStockBrush = FALSE;

	// search for stock brush (only screen, because printer have problems,
	// when we use stock objects)
	if ( !mbPrinter )
	{
		for ( sal_uInt16 i = 0; i < pSalData->mnStockBrushCount; i++ )
		{
			if ( nBrushColor == pSalData->maStockBrushColorAry[ i ] )
			{
				hNewBrush = pSalData->mhStockBrushAry[i];
				bStockBrush = TRUE;
				break;
			}
		}
	}

	// create new brush
	if ( !hNewBrush )
	{
		if ( mbPrinter || !pSalData->mhDitherDIB )
			hNewBrush = CreateSolidBrush( nBrushColor );
		else
		{
			if ( 24 == ((BITMAPINFOHEADER*)pSalData->mpDitherDIB)->biBitCount )
			{
				BYTE* pTmp = pSalData->mpDitherDIBData;
				long* pDitherDiff = pSalData->mpDitherDiff;
				BYTE* pDitherLow = pSalData->mpDitherLow;
				BYTE* pDitherHigh = pSalData->mpDitherHigh;

				for( long nY = 0L; nY < 8L; nY++ )
				{
					for( long nX = 0L; nX < 8L; nX++ )
					{
						const long nThres = aOrdDither16Bit[ nY ][ nX ];
						*pTmp++ = DMAP( nBlue, nThres );
						*pTmp++ = DMAP( nGreen, nThres );
						*pTmp++ = DMAP( nRed, nThres );
					}
				}

				hNewBrush = CreateDIBPatternBrush( pSalData->mhDitherDIB, DIB_RGB_COLORS );
			}
			else if ( ImplIsSysColorEntry( nSalColor ) )
			{
				nBrushColor = PALRGB_TO_RGB( nBrushColor );
				hNewBrush = CreateSolidBrush( nBrushColor );
			}
			else if ( ImplIsPaletteEntry( nRed, nGreen, nBlue ) )
				hNewBrush = CreateSolidBrush( nBrushColor );
			else
			{
				BYTE* pTmp = pSalData->mpDitherDIBData;
				long* pDitherDiff = pSalData->mpDitherDiff;
				BYTE* pDitherLow = pSalData->mpDitherLow;
				BYTE* pDitherHigh = pSalData->mpDitherHigh;

				for ( long nY = 0L; nY < 8L; nY++ )
				{
					for ( long nX = 0L; nX < 8L; nX++ )
					{
						const long nThres = aOrdDither8Bit[ nY ][ nX ];
						*pTmp = DMAP( nRed, nThres ) + DMAP( nGreen, nThres ) * 6 + DMAP( nBlue, nThres ) * 36;
						pTmp++;
					}
				}

				hNewBrush = CreateDIBPatternBrush( pSalData->mhDitherDIB, DIB_PAL_COLORS );
			}
		}

		bStockBrush = FALSE;
	}

	// select new brush
	HBRUSH hOldBrush = SelectBrush( getHDC(), hNewBrush );

	// destory or save old brush
	if ( mhBrush )
	{
		if ( !mbStockBrush )
			DeleteBrush( mhBrush );
	}
	else
		mhDefBrush = hOldBrush;

	// set new data
	mnBrushColor = nBrushColor;
	mhBrush		= hNewBrush;
	mbBrush		= TRUE;
	mbStockBrush = bStockBrush;
}

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

void WinSalGraphics::SetXORMode( bool bSet, bool )
{
	mbXORMode = bSet;
	::SetROP2( getHDC(), bSet ? R2_XORPEN : R2_COPYPEN );
}

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

void WinSalGraphics::SetROPLineColor( SalROPColor nROPColor )
{
	SetLineColor( ImplGetROPSalColor( nROPColor ) );
}

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

void WinSalGraphics::SetROPFillColor( SalROPColor nROPColor )
{
	SetFillColor( ImplGetROPSalColor( nROPColor ) );
}

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

void WinSalGraphics::drawPixel( long nX, long nY )
{
	if ( mbXORMode )
	{
		HBRUSH	hBrush = CreateSolidBrush( mnPenColor );
		HBRUSH	hOldBrush = SelectBrush( getHDC(), hBrush );
		PatBlt( getHDC(), (int)nX, (int)nY, (int)1, (int)1, PATINVERT );
		SelectBrush( getHDC(), hOldBrush );
		DeleteBrush( hBrush );
	}
	else
		SetPixel( getHDC(), (int)nX, (int)nY, mnPenColor );
}

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

void WinSalGraphics::drawPixel( long nX, long nY, SalColor nSalColor )
{
	COLORREF nCol = PALETTERGB( SALCOLOR_RED( nSalColor ),
								SALCOLOR_GREEN( nSalColor ),
								SALCOLOR_BLUE( nSalColor ) );

	if ( !mbPrinter &&
		 GetSalData()->mhDitherPal &&
		 ImplIsSysColorEntry( nSalColor ) )
		nCol = PALRGB_TO_RGB( nCol );

	if ( mbXORMode )
	{
		HBRUSH	hBrush = CreateSolidBrush( nCol );
		HBRUSH	hOldBrush = SelectBrush( getHDC(), hBrush );
		PatBlt( getHDC(), (int)nX, (int)nY, (int)1, (int)1, PATINVERT );
		SelectBrush( getHDC(), hOldBrush );
		DeleteBrush( hBrush );
	}
	else
		::SetPixel( getHDC(), (int)nX, (int)nY, nCol );
}

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

void WinSalGraphics::drawLine( long nX1, long nY1, long nX2, long nY2 )
{
	MoveToEx( getHDC(), (int)nX1, (int)nY1, NULL );

	// we must paint the endpoint
	int bPaintEnd = TRUE;
	if ( nX1 == nX2 )
	{
		bPaintEnd = FALSE;
		if ( nY1 <= nY2 )
			nY2++;
		else
			nY2--;
	}
	if ( nY1 == nY2 )
	{
		bPaintEnd = FALSE;
		if ( nX1 <= nX2 )
			nX2++;
		else
			nX2--;
	}

	LineTo( getHDC(), (int)nX2, (int)nY2 );

	if ( bPaintEnd && !mbPrinter )
	{
		if ( mbXORMode )
		{
			HBRUSH	hBrush = CreateSolidBrush( mnPenColor );
			HBRUSH	hOldBrush = SelectBrush( getHDC(), hBrush );
			PatBlt( getHDC(), (int)nX2, (int)nY2, (int)1, (int)1, PATINVERT );
			SelectBrush( getHDC(), hOldBrush );
			DeleteBrush( hBrush );
		}
		else
			SetPixel( getHDC(), (int)nX2, (int)nY2, mnPenColor );
	}
}

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

void WinSalGraphics::drawRect( long nX, long nY, long nWidth, long nHeight )
{
	if ( !mbPen )
	{
		if ( !mbPrinter )
		{
			PatBlt( getHDC(), (int)nX, (int)nY, (int)nWidth, (int)nHeight,
					mbXORMode ? PATINVERT : PATCOPY );
		}
		else
		{
			RECT aWinRect;
			aWinRect.left	= nX;
			aWinRect.top	= nY;
			aWinRect.right	= nX+nWidth;
			aWinRect.bottom = nY+nHeight;
			::FillRect( getHDC(), &aWinRect, mhBrush );
		}
	}
	else
		WIN_Rectangle( getHDC(), (int)nX, (int)nY, (int)(nX+nWidth), (int)(nY+nHeight) );
}

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

void WinSalGraphics::drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry )
{
	// Unter NT koennen wir das Array direkt weiterreichen
	DBG_ASSERT( sizeof( POINT ) == sizeof( SalPoint ),
				"WinSalGraphics::DrawPolyLine(): POINT != SalPoint" );

	POINT* pWinPtAry = (POINT*)pPtAry;
	// Wegen Windows 95 und der Beschraenkung auf eine maximale Anzahl
	// von Punkten
	if ( !Polyline( getHDC(), pWinPtAry, (int)nPoints ) && (nPoints > MAX_64KSALPOINTS) )
		Polyline( getHDC(), pWinPtAry, MAX_64KSALPOINTS );
}

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

void WinSalGraphics::drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry )
{
	// Unter NT koennen wir das Array direkt weiterreichen
	DBG_ASSERT( sizeof( POINT ) == sizeof( SalPoint ),
				"WinSalGraphics::DrawPolygon(): POINT != SalPoint" );

	POINT* pWinPtAry = (POINT*)pPtAry;
	// Wegen Windows 95 und der Beschraenkung auf eine maximale Anzahl
	// von Punkten
	if ( !WIN_Polygon( getHDC(), pWinPtAry, (int)nPoints ) && (nPoints > MAX_64KSALPOINTS) )
		WIN_Polygon( getHDC(), pWinPtAry, MAX_64KSALPOINTS );
}

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

void WinSalGraphics::drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints,
								   PCONSTSALPOINT* pPtAry )
{
	UINT	aWinPointAry[SAL_POLYPOLYCOUNT_STACKBUF];
	UINT*	pWinPointAry;
	UINT	nPolyPolyPoints = 0;
	UINT	nPoints;
	UINT	i;

	if ( nPoly <= SAL_POLYPOLYCOUNT_STACKBUF )
		pWinPointAry = aWinPointAry;
	else
		pWinPointAry = new UINT[nPoly];

	for ( i = 0; i < (UINT)nPoly; i++ )
	{
		nPoints = (UINT)pPoints[i]+1;
		pWinPointAry[i] = nPoints;
		nPolyPolyPoints += nPoints;
	}

	POINT  aWinPointAryAry[SAL_POLYPOLYPOINTS_STACKBUF];
	POINT* pWinPointAryAry;
	if ( nPolyPolyPoints <= SAL_POLYPOLYPOINTS_STACKBUF )
		pWinPointAryAry = aWinPointAryAry;
	else
		pWinPointAryAry = new POINT[nPolyPolyPoints];
	// Unter NT koennen wir das Array direkt weiterreichen
	DBG_ASSERT( sizeof( POINT ) == sizeof( SalPoint ),
				"WinSalGraphics::DrawPolyPolygon(): POINT != SalPoint" );
	const SalPoint* pPolyAry;
	UINT			n = 0;
	for ( i = 0; i < (UINT)nPoly; i++ )
	{
		nPoints = pWinPointAry[i];
		pPolyAry = pPtAry[i];
		memcpy( pWinPointAryAry+n, pPolyAry, (nPoints-1)*sizeof(POINT) );
		pWinPointAryAry[n+nPoints-1] = pWinPointAryAry[n];
		n += nPoints;
	}

	if ( !WIN_PolyPolygon( getHDC(), pWinPointAryAry, (int*)pWinPointAry, (UINT)nPoly ) &&
		 (nPolyPolyPoints > MAX_64KSALPOINTS) )
	{
		nPolyPolyPoints  = 0;
		nPoly = 0;
		do
		{
			nPolyPolyPoints += pWinPointAry[(UINT)nPoly];
			nPoly++;
		}
		while ( nPolyPolyPoints < MAX_64KSALPOINTS );
		nPoly--;
		if ( pWinPointAry[(UINT)nPoly] > MAX_64KSALPOINTS )
			pWinPointAry[(UINT)nPoly] = MAX_64KSALPOINTS;
		if ( nPoly == 1 )
			WIN_Polygon( getHDC(), pWinPointAryAry, *pWinPointAry );
		else
			WIN_PolyPolygon( getHDC(), pWinPointAryAry, (int*)pWinPointAry, nPoly );
	}

	if ( pWinPointAry != aWinPointAry )
		delete [] pWinPointAry;
	if ( pWinPointAryAry != aWinPointAryAry )
		delete [] pWinPointAryAry;
}

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

#define SAL_POLY_STACKBUF		32

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

sal_Bool WinSalGraphics::drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const BYTE* pFlgAry )
{
#ifdef USE_GDI_BEZIERS
	// Unter NT koennen wir das Array direkt weiterreichen
	DBG_ASSERT( sizeof( POINT ) == sizeof( SalPoint ),
				"WinSalGraphics::DrawPolyLineBezier(): POINT != SalPoint" );

    ImplRenderPath( getHDC(), nPoints, pPtAry, pFlgAry );

    return sal_True;
#else
    return sal_False;
#endif
}

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

sal_Bool WinSalGraphics::drawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const BYTE* pFlgAry )
{
#ifdef USE_GDI_BEZIERS
	// Unter NT koennen wir das Array direkt weiterreichen
	DBG_ASSERT( sizeof( POINT ) == sizeof( SalPoint ),
				"WinSalGraphics::DrawPolygonBezier(): POINT != SalPoint" );

    POINT	aStackAry1[SAL_POLY_STACKBUF];
    BYTE	aStackAry2[SAL_POLY_STACKBUF];
    POINT* 	pWinPointAry;
    BYTE* 	pWinFlagAry;
    if( nPoints > SAL_POLY_STACKBUF )
    {
        pWinPointAry = new POINT[ nPoints ];
        pWinFlagAry = new BYTE[ nPoints ];
    }
    else
    {
        pWinPointAry = aStackAry1;
        pWinFlagAry = aStackAry2;
    }

    ImplPreparePolyDraw(true, 1, &nPoints, &pPtAry, &pFlgAry, pWinPointAry, pWinFlagAry);

    sal_Bool bRet( sal_False );

    if( BeginPath( getHDC() ) )
    {
        PolyDraw(getHDC(), pWinPointAry, pWinFlagAry, nPoints);

        if( EndPath( getHDC() ) )
        {
            if( StrokeAndFillPath( getHDC() ) )
                bRet = sal_True;
        }
    }

    if( pWinPointAry != aStackAry1 )
    {
        delete [] pWinPointAry;
        delete [] pWinFlagAry;
    }

    return bRet;
#else
    return sal_False;
#endif
}

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

sal_Bool WinSalGraphics::drawPolyPolygonBezier( sal_uInt32 nPoly, const sal_uInt32* pPoints,
                                             const SalPoint* const* pPtAry, const BYTE* const* pFlgAry )
{
#ifdef USE_GDI_BEZIERS
	// Unter NT koennen wir das Array direkt weiterreichen
	DBG_ASSERT( sizeof( POINT ) == sizeof( SalPoint ),
				"WinSalGraphics::DrawPolyPolygonBezier(): POINT != SalPoint" );

    sal_uLong nCurrPoly, nTotalPoints;
    const sal_uLong* pCurrPoints = pPoints;
    for( nCurrPoly=0, nTotalPoints=0; nCurrPoly<nPoly; ++nCurrPoly )
        nTotalPoints += *pCurrPoints++;

    POINT	aStackAry1[SAL_POLY_STACKBUF];
    BYTE	aStackAry2[SAL_POLY_STACKBUF];
    POINT* 	pWinPointAry;
    BYTE* 	pWinFlagAry;
    if( nTotalPoints > SAL_POLY_STACKBUF )
    {
        pWinPointAry = new POINT[ nTotalPoints ];
        pWinFlagAry = new BYTE[ nTotalPoints ];
    }
    else
    {
        pWinPointAry = aStackAry1;
        pWinFlagAry = aStackAry2;
    }

    ImplPreparePolyDraw(true, nPoly, pPoints, pPtAry, pFlgAry, pWinPointAry, pWinFlagAry);

    sal_Bool bRet( sal_False );

    if( BeginPath( getHDC() ) )
    {
        PolyDraw(getHDC(), pWinPointAry, pWinFlagAry, nTotalPoints);

        if( EndPath( getHDC() ) )
        {
            if( StrokeAndFillPath( getHDC() ) )
                bRet = sal_True;
        }
    }

    if( pWinPointAry != aStackAry1 )
    {
        delete [] pWinPointAry;
        delete [] pWinFlagAry;
    }

    return bRet;
#else
    return sal_False;
#endif
}

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

#define POSTSCRIPT_BUFSIZE 0x4000			// MAXIMUM BUFSIZE EQ 0xFFFF
#define POSTSCRIPT_BOUNDINGSEARCH 0x1000	// we only try to get the BoundingBox
											// in the first 4096 bytes

static BYTE* ImplSearchEntry( BYTE* pSource, BYTE* pDest, sal_uLong nComp, sal_uLong nSize )
{
	while ( nComp-- >= nSize )
	{
		sal_uLong i;
		for ( i = 0; i < nSize; i++ )
		{
			if ( ( pSource[i]&~0x20 ) != ( pDest[i]&~0x20 ) )
				break;
		}
		if ( i == nSize )
			return pSource;
		pSource++;
	}
	return NULL;
}

static sal_Bool ImplGetBoundingBox( double* nNumb, BYTE* pSource, sal_uLong nSize )
{
	sal_Bool	bRetValue = FALSE;
	BYTE* pDest = ImplSearchEntry( pSource, (BYTE*)"%%BoundingBox:", nSize, 14 );
	if ( pDest )
	{
		nNumb[0] = nNumb[1] = nNumb[2] = nNumb[3] = 0;
		pDest += 14;

		int nSizeLeft = nSize - ( pDest - pSource );
		if ( nSizeLeft > 100 )
			nSizeLeft = 100;	// only 100 bytes following the bounding box will be checked

		int i;
		for ( i = 0; ( i < 4 ) && nSizeLeft; i++ )
		{
			int 	nDivision = 1;
			sal_Bool	bDivision = FALSE;
			sal_Bool	bNegative = FALSE;
			sal_Bool	bValid = TRUE;

			while ( ( --nSizeLeft ) && ( *pDest == ' ' ) || ( *pDest == 0x9 ) ) pDest++;
			BYTE nByte = *pDest;
			while ( nSizeLeft && ( nByte != ' ' ) && ( nByte != 0x9 ) && ( nByte != 0xd ) && ( nByte != 0xa ) )
			{
				switch ( nByte )
				{
					case '.' :
						if ( bDivision )
							bValid = FALSE;
						else
							bDivision = TRUE;
						break;
					case '-' :
						bNegative = TRUE;
						break;
					default :
						if ( ( nByte < '0' ) || ( nByte > '9' ) )
							nSizeLeft = 1; 	// error parsing the bounding box values
						else if ( bValid )
						{
							if ( bDivision )
								nDivision*=10;
							nNumb[i] *= 10;
							nNumb[i] += nByte - '0';
						}
						break;
				}
				nSizeLeft--;
				nByte = *(++pDest);
			}
			if ( bNegative )
				nNumb[i] = -nNumb[i];
			if ( bDivision && ( nDivision != 1 ) )
				nNumb[i] /= nDivision;
		}
		if ( i == 4 )
			bRetValue = TRUE;
	}
	return bRetValue;
}

sal_Bool WinSalGraphics::drawEPS( long nX, long nY, long nWidth, long nHeight, void* pPtr, sal_uLong nSize )
{
	sal_Bool bRetValue = FALSE;

	if ( mbPrinter )
	{
		int nEscape = POSTSCRIPT_PASSTHROUGH;

		if ( Escape( getHDC(), QUERYESCSUPPORT, sizeof( int ), ( LPSTR )&nEscape, 0 ) )
		{
			double	nBoundingBox[4];

			if ( ImplGetBoundingBox( nBoundingBox, (BYTE*)pPtr, nSize ) )
			{
                OStringBuffer aBuf( POSTSCRIPT_BUFSIZE );

                // reserve place for a sal_uInt16
                aBuf.append( "aa" );

                // #107797# Write out EPS encapsulation header
                // ----------------------------------------------------------------------------------

                // directly taken from the PLRM 3.0, p. 726. Note:
                // this will definitely cause problems when
                // recursively creating and embedding PostScript files
                // in OOo, since we use statically-named variables
                // here (namely, b4_Inc_state_salWin, dict_count_salWin and
                // op_count_salWin). Currently, I have no idea on how to
                // work around that, except from scanning and
                // interpreting the EPS for unused identifiers.

                // append the real text
                aBuf.append( "\n\n/b4_Inc_state_salWin save def\n"
                             "/dict_count_salWin countdictstack def\n"
                             "/op_count_salWin count 1 sub def\n"
                             "userdict begin\n"
                             "/showpage {} def\n"
                             "0 setgray 0 setlinecap\n"
                             "1 setlinewidth 0 setlinejoin\n"
                             "10 setmiterlimit [] 0 setdash newpath\n"
                             "/languagelevel where\n"
                             "{\n"
                             "  pop languagelevel\n"
                             "  1 ne\n"
                             "  {\n"
                             "    false setstrokeadjust false setoverprint\n"
                             "  } if\n"
                             "} if\n\n" );


                // #i10737# Apply clipping manually
                // ----------------------------------------------------------------------------------

                // Windows seems to ignore any clipping at the HDC,
                // when followed by a POSTSCRIPT_PASSTHROUGH

                // Check whether we've got a clipping, consisting of
                // exactly one rect (other cases should be, but aren't
                // handled currently)

                // TODO: Handle more than one rectangle here (take
                // care, the buffer can handle only POSTSCRIPT_BUFSIZE
                // characters!)
                if ( mhRegion != 0 &&
                     mpStdClipRgnData != NULL &&
                     mpClipRgnData == mpStdClipRgnData &&
                     mpClipRgnData->rdh.nCount == 1 )
                {
                    RECT* pRect = &(mpClipRgnData->rdh.rcBound);

                    aBuf.append( "\nnewpath\n" );
                    aBuf.append( pRect->left );
                    aBuf.append( " " );
                    aBuf.append( pRect->top );
                    aBuf.append( " moveto\n" );
                    aBuf.append( pRect->right );
                    aBuf.append( " " );
                    aBuf.append( pRect->top );
                    aBuf.append( " lineto\n" );
                    aBuf.append( pRect->right );
                    aBuf.append( " " );
                    aBuf.append( pRect->bottom );
                    aBuf.append( " lineto\n" );
                    aBuf.append( pRect->left );
                    aBuf.append( " " );
                    aBuf.append( pRect->bottom );
                    aBuf.append( " lineto\n"
                                 "closepath\n"
                                 "clip\n"
                                 "newpath\n" );
                }

                // #107797# Write out buffer
                // ----------------------------------------------------------------------------------
				*((sal_uInt16*)aBuf.getStr()) = (sal_uInt16)( aBuf.getLength() - 2 );
				Escape ( getHDC(), nEscape, aBuf.getLength(), (LPTSTR)aBuf.getStr(), 0 );


                // #107797# Write out EPS transformation code
                // ----------------------------------------------------------------------------------
				double	dM11 = nWidth / ( nBoundingBox[2] - nBoundingBox[0] );
				double	dM22 = nHeight / (nBoundingBox[1] - nBoundingBox[3] );
                // reserve a sal_uInt16 again
                aBuf.setLength( 2 );
                aBuf.append( "\n\n[" );
                aBuf.append( dM11 );
                aBuf.append( " 0 0 " );
                aBuf.append( dM22 );
                aBuf.append( ' ' );
                aBuf.append( nX - ( dM11 * nBoundingBox[0] ) );
                aBuf.append( ' ' );
                aBuf.append( nY - ( dM22 * nBoundingBox[3] ) );
                aBuf.append( "] concat\n"
                             "%%BeginDocument:\n" );
				*((sal_uInt16*)aBuf.getStr()) = (sal_uInt16)( aBuf.getLength() - 2 );
				Escape ( getHDC(), nEscape, aBuf.getLength(), (LPTSTR)aBuf.getStr(), 0 );


                // #107797# Write out actual EPS content
                // ----------------------------------------------------------------------------------
				sal_uLong	nToDo = nSize;
				sal_uLong	nDoNow;
				while ( nToDo )
				{
					nDoNow = nToDo;
					if ( nToDo > POSTSCRIPT_BUFSIZE - 2 )
						nDoNow = POSTSCRIPT_BUFSIZE - 2;
                    // the following is based on the string buffer allocation
                    // of size POSTSCRIPT_BUFSIZE at construction time of aBuf
					*((sal_uInt16*)aBuf.getStr()) = (sal_uInt16)nDoNow;
					memcpy( (void*)(aBuf.getStr() + 2), (BYTE*)pPtr + nSize - nToDo, nDoNow );
					sal_uLong nResult = Escape ( getHDC(), nEscape, nDoNow + 2, (LPTSTR)aBuf.getStr(), 0 );
					if (!nResult )
						break;
					nToDo -= nResult;
				}


                // #107797# Write out EPS encapsulation footer
                // ----------------------------------------------------------------------------------
                // reserve a sal_uInt16 again
                aBuf.setLength( 2 );
                aBuf.append( "%%EndDocument\n"
                             "count op_count_salWin sub {pop} repeat\n"
                             "countdictstack dict_count_salWin sub {end} repeat\n"
                             "b4_Inc_state_salWin restore\n\n" );
				*((sal_uInt16*)aBuf.getStr()) = (sal_uInt16)( aBuf.getLength() - 2 );
				Escape ( getHDC(), nEscape, aBuf.getLength(), (LPTSTR)aBuf.getStr(), 0 );
				bRetValue = TRUE;
			}
		}
	}

	return bRetValue;
}

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

SystemGraphicsData WinSalGraphics::GetGraphicsData() const
{
    SystemGraphicsData aRes;
    aRes.nSize = sizeof(aRes);
    aRes.hDC = const_cast< WinSalGraphics* >(this)->getHDC();
    return aRes;
}

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