Merge branch '4.5' of git@scm.dev.nokia.troll.no:qt/qt into 4.5

22 files changed, 1543 insertions, 1464 deletions

diff --git a/src/3rdparty/powervr/pvr2d.h b/src/3rdparty/powervr/pvr2d.h
index 14823e0..07f28c7 100644
--- a/src/3rdparty/powervr/pvr2d.h
+++ b/src/3rdparty/powervr/pvr2d.h
@@ -1,502 +1,502 @@
-/*!****************************************************************************

-@File          pvr2d.h

-@Title         PVR2D external header file

-@Author        Imagination Technologies

-@Copyright     Copyright (c) by Imagination Technologies Limited.

-				This specification is protected by copyright laws and contains

-				material proprietary to Imagination Technologies Limited.

-				You may use and distribute this specification free of charge for implementing 

-				the functionality therein, without altering or removing any trademark, copyright, 

-				or other notice from the specification.

-@Platform      Generic

-@Description   PVR2D definitions for PVR2D clients

-******************************************************************************/

-

-

-/******************************************************************************

-Modifications :-

-$Log: pvr2d.h $

-******************************************************************************/

-

-#ifndef _PVR2D_H_

-#define _PVR2D_H_

-

-#ifdef __cplusplus

-extern "C" {

-#endif 

-

-/* PVR2D Platform-specific definitions */

-#define PVR2D_EXPORT

-#define PVR2D_IMPORT

-

-

-#define PVR2D_REV_MAJOR		2

-#define PVR2D_REV_MINOR		1

-

-typedef enum

-{

-	PVR2D_FALSE = 0,

-	PVR2D_TRUE

-} PVR2D_BOOL;

-

-

-/* error codes */

-typedef enum

-{

-	PVR2D_OK = 0,

-	PVR2DERROR_INVALID_PARAMETER = -1,

-	PVR2DERROR_DEVICE_UNAVAILABLE = -2,

-	PVR2DERROR_INVALID_CONTEXT = -3,

-	PVR2DERROR_MEMORY_UNAVAILABLE = -4,

-	PVR2DERROR_DEVICE_NOT_PRESENT = -5,

-	PVR2DERROR_IOCTL_ERROR = -6,

-	PVR2DERROR_GENERIC_ERROR = -7,

-	PVR2DERROR_BLT_NOTCOMPLETE = -8,

-	PVR2DERROR_HW_FEATURE_NOT_SUPPORTED = -9,

-	PVR2DERROR_NOT_YET_IMPLEMENTED = -10,

-	PVR2DERROR_MAPPING_FAILED = -11

-}PVR2DERROR;

-

-

-/* pixel formats */

-typedef enum

-{

-	PVR2D_1BPP = 0,

-	PVR2D_RGB565,

-	PVR2D_ARGB4444,

-	PVR2D_RGB888,

-	PVR2D_ARGB8888,

-	PVR2D_ARGB1555,

-	PVR2D_ALPHA8,

-	PVR2D_ALPHA4,

-	PVR2D_PAL2,

-	PVR2D_PAL4,

-	PVR2D_PAL8,

-	PVR2D_VGAEMU

-

-}PVR2DFORMAT;

-

-

-/* wrap surface type */

-typedef enum

-{

-	PVR2D_WRAPFLAG_NONCONTIGUOUS = 0,

-	PVR2D_WRAPFLAG_CONTIGUOUS = 1,

-

-}PVR2DWRAPFLAGS;

-

-/* flags for control information of additional blits */

-typedef enum

-{

-	PVR2D_BLIT_DISABLE_ALL					= 0x0000,	/* disable all additional controls */

-	PVR2D_BLIT_CK_ENABLE					= 0x0001,	/* enable colour key */

-	PVR2D_BLIT_GLOBAL_ALPHA_ENABLE			= 0x0002,	/* enable standard global alpha */

-	PVR2D_BLIT_PERPIXEL_ALPHABLEND_ENABLE	= 0x0004,	/* enable per-pixel alpha bleding */

-	PVR2D_BLIT_PAT_SURFACE_ENABLE			= 0x0008,	/* enable pattern surf (disable fill) */

-	PVR2D_BLIT_FULLY_SPECIFIED_ALPHA_ENABLE	= 0x0010,	/* enable fully specified alpha */

-	PVR2D_BLIT_ROT_90						= 0x0020,	/* apply 90 degree rotation to the blt */

-	PVR2D_BLIT_ROT_180						= 0x0040,	/* apply 180 degree rotation to the blt */

-	PVR2D_BLIT_ROT_270						= 0x0080,	/* apply 270 degree rotation to the blt */

-	PVR2D_BLIT_COPYORDER_TL2BR				= 0x0100,	/* copy order overrides */

-	PVR2D_BLIT_COPYORDER_BR2TL				= 0x0200,

-	PVR2D_BLIT_COPYORDER_TR2BL				= 0x0400,

-	PVR2D_BLIT_COPYORDER_BL2TR				= 0x0800,

-	PVR2D_BLIT_COLKEY_SOURCE				= 0x1000,	/* Key colour is on the source surface */

-	PVR2D_BLIT_COLKEY_DEST					= 0x2000	/* Key colour is on the destination surface */

-

-} PVR2DBLITFLAGS;

-

-/* standard alpha-blending functions, AlphaBlendingFunc field of PVR2DBLTINFO */

-typedef enum

-{

-	PVR2D_ALPHA_OP_SRC_DSTINV = 1,	/* source alpha : Cdst = Csrc*Asrc + Cdst*(1-Asrc) */

-	PVR2D_ALPHA_OP_SRCP_DSTINV = 2	/* premultiplied source alpha : Cdst = Csrc + Cdst*(1-Asrc) */

-} PVR2D_ALPHABLENDFUNC;

-

-/* blend ops for fully specified alpha */

-typedef enum

-{

-	PVR2D_BLEND_OP_ZERO = 0,

-	PVR2D_BLEND_OP_ONE = 1,

-	PVR2D_BLEND_OP_SRC = 2,

-	PVR2D_BLEND_OP_DST = 3,

-	PVR2D_BLEND_OP_GLOBAL = 4,

-	PVR2D_BLEND_OP_SRC_PLUS_GLOBAL = 5,

-	PVR2D_BLEND_OP_DST_PLUS_GLOBAL = 6

-}PVR2D_BLEND_OP;

-

-

-typedef void* PVR2D_HANDLE;

-

-

-/* Fully specified alpha blend :	pAlpha field of PVR2DBLTINFO structure					*/

-/* a fully specified Alpha Blend operation is defined as									*/

-/* DST (ALPHA) = (ALPHA_1 * SRC (ALPHA)) + (ALPHA_3 * DST (ALPHA))							*/

-/* DST (RGB)   = (ALPHA_2 * SRC (RGB)) + (ALPHA_4 * DST (RGB))								*/

-/* if the pre-multiplication stage is enabled then the equations become the following:		*/

-/* PRE_MUL     = ((SRC(A)) * (Global Alpha Value))											*/

-/* DST (ALPHA) = (ALPHA_1 * SRC (ALPHA)) + (PRE_MUL * DST (ALPHA))							*/

-/* DST (RGB)   = (ALPHA_2 * SRC (RGB)) + (PRE_MUL * DST (RGB))								*/

-/* if the transparent source alpha stage is enabled then a source alpha of zero forces the	*/

-/* source to be transparent for that pixel regardless of the blend equation being used.		*/

-typedef struct _PVR2D_ALPHABLT

-{

-	PVR2D_BLEND_OP	eAlpha1;

-	PVR2D_BOOL		bAlpha1Invert;

-	PVR2D_BLEND_OP	eAlpha2;

-	PVR2D_BOOL		bAlpha2Invert;

-	PVR2D_BLEND_OP	eAlpha3;

-	PVR2D_BOOL		bAlpha3Invert;

-	PVR2D_BLEND_OP	eAlpha4;

-	PVR2D_BOOL		bAlpha4Invert;

-	PVR2D_BOOL		bPremulAlpha;			/* enable pre-multiplication stage */

-	PVR2D_BOOL		bTransAlpha;			/* enable transparent source alpha stage */

-	PVR2D_BOOL		bUpdateAlphaLookup;		/* enable and update the 1555-Lookup alpha table */

-	unsigned char	uAlphaLookup0;			/* 8 bit alpha when A=0 in a 1555-Lookup surface */

-	unsigned char	uAlphaLookup1;			/* 8 bit alpha when A=1 in a 1555-Lookup surface */

-	unsigned char	uGlobalRGB;				/* Global Alpha Value for RGB, 0=transparent 255=opaque */

-	unsigned char	uGlobalA;				/* Global Alpha Value for Alpha */

-

-} PVR2D_ALPHABLT, *PPVR2D_ALPHABLT;

-

-

-/* surface memory info structure */

-typedef struct _PVR2DMEMINFO

-{

-	void				*pBase;

-	unsigned long		ui32MemSize;

-	unsigned long		ui32DevAddr;

-	unsigned long		ulFlags;

-	void				*hPrivateData;

-	void				*hPrivateMapData;

-

-}PVR2DMEMINFO, *PPVR2DMEMINFO;

-

-

-#define PVR2D_MAX_DEVICE_NAME 20

-

-typedef struct _PVR2DDEVICEINFO

-{

-	unsigned long	ulDevID;

-	char			szDeviceName[PVR2D_MAX_DEVICE_NAME];

-}PVR2DDEVICEINFO;

-

-

-typedef struct _PVR2DISPLAYINFO

-{

-	unsigned long	ulMaxFlipChains;

-	unsigned long	ulMaxBuffersInChain;

-	PVR2DFORMAT		eFormat;

-	unsigned long	ulWidth;

-	unsigned long	ulHeight;

-	long			lStride;

-	unsigned long	ulMinFlipInterval;

-	unsigned long	ulMaxFlipInterval;

-

-}PVR2DDISPLAYINFO;

-

-

-typedef struct _PVR2DBLTINFO

-{

-	unsigned long	CopyCode;			/* rop code  */

-	unsigned long	Colour;				/* fill colour */

-	unsigned long	ColourKey;			/* colour key */

-	unsigned char	GlobalAlphaValue;	/* global alpha blending */

-	unsigned char	AlphaBlendingFunc;	/* per-pixel alpha-blending function */

-

-	PVR2DBLITFLAGS	BlitFlags;			/* additional blit control information */

-

-	PVR2DMEMINFO	*pDstMemInfo;		/* destination memory */

-	unsigned long	DstOffset;			/* byte offset from start of allocation to destination surface pixel 0,0 */

-	long			DstStride;			/* signed stride, the number of bytes from pixel 0,0 to 0,1 */

-	long			DstX, DstY;			/* pixel offset from start of dest surface to start of blt rectangle */

-	long			DSizeX,DSizeY;		/* blt size */

-	PVR2DFORMAT		DstFormat;			/* dest format */

-	unsigned long	DstSurfWidth;		/* size of dest surface in pixels */

-	unsigned long	DstSurfHeight;		/* size of dest surface in pixels */

-

-	PVR2DMEMINFO	*pSrcMemInfo;		/* source mem, (source fields are also used for patterns) */

-	unsigned long	SrcOffset;			/* byte offset from start of allocation to src/pat surface pixel 0,0 */

-	long			SrcStride;			/* signed stride, the number of bytes from pixel 0,0 to 0,1 */

-	long			SrcX, SrcY;			/* pixel offset from start of surface to start of source rectangle */

-										/* for patterns this is the start offset within the pattern */

-	long			SizeX,SizeY;		/* source rectangle size or pattern size in pixels */

-	PVR2DFORMAT		SrcFormat;			/* source/pattern format */

-	PVR2DMEMINFO	*pPalMemInfo;		/* source/pattern palette memory containing argb8888 colour table */

-	unsigned long	PalOffset;			/* byte offset from start of allocation to start of palette */

-	unsigned long	SrcSurfWidth;		/* size of source surface in pixels */

-	unsigned long	SrcSurfHeight;		/* size of source surface in pixels */

-

-	PVR2DMEMINFO	*pMaskMemInfo;		/* mask memory, 1bpp format implied */

-	unsigned long	MaskOffset;			/* byte offset from start of allocation to mask surface pixel 0,0 */

-	long			MaskStride;			/* signed stride, the number of bytes from pixel 0,0 to 0,1 */

-	long			MaskX, MaskY;		/* mask rect top left (mask size = blt size) */

-	unsigned long	MaskSurfWidth;		/* size of mask surface in pixels */

-	unsigned long	MaskSurfHeight;		/* size of mask surface in pixels */

-	

-	PPVR2D_ALPHABLT pAlpha;				/* fully specified alpha blend */

-

-}PVR2DBLTINFO, *PPVR2DBLTINFO;

-

-typedef struct _PVR2DRECT

-{

-	long left, top;

-	long right, bottom;

-} PVR2DRECT;

-

-typedef struct

-{

-	PVR2DMEMINFO	*pSurfMemInfo;		/* surface memory */

-	unsigned long	SurfOffset;			/* byte offset from start of allocation to destination surface pixel 0,0 */

-	long			Stride;				/* signed stride */

-	PVR2DFORMAT		Format;

-	unsigned long	SurfWidth;			/* surface size in pixels */

-	unsigned long	SurfHeight;

-

-} PVR2D_SURFACE, *PPVR2D_SURFACE;

-

-typedef struct

-{

-	unsigned long	*pUseCode;					/* USSE code */

-	unsigned long	UseCodeSize;				/* usse code size in bytes */

-

-} PVR2D_USECODE, *PPVR2D_USECODE;

-

-typedef struct

-{

-	PVR2D_SURFACE			sDst;				/* destination surface */

-	PVR2D_SURFACE			sSrc;				/* source surface */

-	PVR2DRECT				rcDest;				/* destination rectangle */

-	PVR2DRECT				rcSource;			/* source rectangle */

-	PVR2D_HANDLE			hUseCode;			/* custom USE code (NULL implies source copy) */

-	unsigned long			UseParams[2];		/* per-blt params for use code */

-

-} PVR2D_3DBLT, *PPVR2D_3DBLT;

-

-

-#define MAKE_COPY_BLIT(src,soff,dest,doff,sx,sy,dx,dy,sz)

-

-typedef void* PVR2DCONTEXTHANDLE;

-typedef void* PVR2DFLIPCHAINHANDLE;

-

-

-// CopyCode field of PVR2DBLTINFO structure:

-// the CopyCode field of the PVR2DBLTINFO structure should contain a rop3 or rop4 code.

-// a rop3 is an 8 bit code that describes a blt with three inputs : source dest and pattern

-// rop4 is a 16 bit code that describes a blt with four inputs : source dest pattern and mask

-// common rop3 codes are defined below

-// a colour fill blt is processed in the pattern channel as a constant colour with a rop code of 0xF0

-// PVR2D_BLIT_PAT_SURFACE_ENABLE defines whether the pattern channel is a surface or a fill colour.

-// a rop4 is defined by two rop3 codes, and the 1 bit-per-pixel mask surface defines which is used.

-// a common rop4 is 0xAAF0 which is the mask copy blt used for text glyphs.

-// CopyCode is taken to be a rop4 when pMaskMemInfo is non zero, otherwise it is assumed to be a rop3

-// use the PVR2DMASKROP4 macro below to construct a rop4 from two rop3's

-// rop3a is the rop used when mask pixel = 1, and rop3b when mask = 0

-#define PVR2DROP4(rop3b, rop3a)			((rop3b<<8)|rop3a)

-

-/* common rop codes */

-#define PVR2DROPclear				0x00       /* 0 (whiteness) */

-#define PVR2DROPset					0xFF       /* 1 (blackness) */

-#define PVR2DROPnoop				0xAA       /* dst (used for masked blts) */

-

-/* source and  dest rop codes */

-#define PVR2DROPand					0x88       /* src AND dst */

-#define PVR2DROPandReverse			0x44       /* src AND NOT dst */

-#define PVR2DROPcopy				0xCC       /* src (used for source copy and alpha blts) */

-#define PVR2DROPandInverted			0x22       /* NOT src AND dst */

-#define PVR2DROPxor					0x66       /* src XOR dst */

-#define PVR2DROPor					0xEE       /* src OR dst */

-#define PVR2DROPnor					0x11       /* NOT src AND NOT dst */

-#define PVR2DROPequiv				0x99       /* NOT src XOR dst */

-#define PVR2DROPinvert				0x55       /* NOT dst */

-#define PVR2DROPorReverse			0xDD       /* src OR NOT dst */

-#define PVR2DROPcopyInverted		0x33       /* NOT src */

-#define PVR2DROPorInverted			0xBB       /* NOT src OR dst */

-#define PVR2DROPnand				0x77       /* NOT src OR NOT dst */

-

-/* pattern rop codes */

-#define PVR2DPATROPand				0xA0       /* pat AND dst */

-#define PVR2DPATROPandReverse		0x50       /* pat AND NOT dst */

-#define PVR2DPATROPcopy				0xF0       /* pat (used for solid color fills and pattern blts) */

-#define PVR2DPATROPandInverted		0x0A       /* NOT pat AND dst */

-#define PVR2DPATROPxor				0x5A       /* pat XOR dst */

-#define PVR2DPATROPor				0xFA       /* pat OR dst */

-#define PVR2DPATROPnor				0x05       /* NOT pat AND NOT dst */

-#define PVR2DPATROPequiv			0xA5       /* NOT pat XOR dst */

-#define PVR2DPATROPinvert			0x55       /* NOT dst */

-#define PVR2DPATROPorReverse		0xF5       /* pat OR NOT dst */

-#define PVR2DPATROPcopyInverted		0x0F       /* NOT pat */

-#define PVR2DPATROPorInverted		0xAF       /* NOT pat OR dst */

-#define PVR2DPATROPnand				0x5F       /* NOT pat OR NOT dst */

-

-/* common rop4 codes */

-#define PVR2DROP4MaskedCopy              PVR2DROP4(PVR2DROPnoop,PVR2DROPcopy)		/* masked source copy blt (used for rounded window corners etc) */

-#define PVR2DROP4MaskedFill              PVR2DROP4(PVR2DROPnoop,PVR2DPATROPcopy)	/* masked colour fill blt (used for text) */

-

-/* Legacy support */

-#define PVR2DROP3_PATMASK			PVR2DPATROPcopy

-#define PVR2DROP3_SRCMASK			PVR2DROPcopy

-

-/* pixmap memory alignment */

-#define PVR2D_ALIGNMENT_4			4			/* DWORD alignment */

-#define PVR2D_ALIGNMENT_ANY			0			/* no alignment    */

-#define PVR2D_ALIGNMENT_PALETTE		16			/* 16 byte alignment is required for palettes */

-

-/* Heap number for PVR2DGetFrameBuffer */

-#define PVR2D_FB_PRIMARY_SURFACE 0

-

-#define PVR2D_PRESENT_PROPERTY_SRCSTRIDE	(1 << 0)

-#define PVR2D_PRESENT_PROPERTY_DSTSIZE		(1 << 1)

-#define PVR2D_PRESENT_PROPERTY_DSTPOS		(1 << 2)

-#define PVR2D_PRESENT_PROPERTY_CLIPRECTS	(1 << 3)

-#define PVR2D_PRESENT_PROPERTY_INTERVAL		(1 << 4)

-

-

-#define PVR2D_CREATE_FLIPCHAIN_SHARED		(1 << 0)

-#define PVR2D_CREATE_FLIPCHAIN_QUERY		(1 << 1)

-

-/* Functions that the library exports */

-

-PVR2D_IMPORT

-int PVR2DEnumerateDevices(PVR2DDEVICEINFO *pDevInfo);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DCreateDeviceContext(unsigned long ulDevID,

-									PVR2DCONTEXTHANDLE* phContext,

-									unsigned long ulFlags);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DDestroyDeviceContext(PVR2DCONTEXTHANDLE hContext);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DGetDeviceInfo(PVR2DCONTEXTHANDLE hContext,

-							  PVR2DDISPLAYINFO *pDisplayInfo);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DGetScreenMode(PVR2DCONTEXTHANDLE hContext,

-							  PVR2DFORMAT *pFormat,

-							  long *plWidth,

-							  long *plHeight,

-							  long *plStride,

-							  int *piRefreshRate);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DGetFrameBuffer(PVR2DCONTEXTHANDLE hContext,

-							   int nHeap,

-							   PVR2DMEMINFO **ppsMemInfo);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DMemAlloc(PVR2DCONTEXTHANDLE hContext,

-						 unsigned long ulBytes,

-						 unsigned long ulAlign,

-						 unsigned long ulFlags,

-						 PVR2DMEMINFO **ppsMemInfo);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DMemWrap(PVR2DCONTEXTHANDLE hContext,

-						void *pMem,

-						unsigned long ulFlags,

-						unsigned long ulBytes,

-						unsigned long alPageAddress[],

-						PVR2DMEMINFO **ppsMemInfo);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DMemMap(PVR2DCONTEXTHANDLE hContext,

-						unsigned long ulFlags,

-						void *hPrivateMapData,

-						PVR2DMEMINFO **ppsDstMem);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DMemFree(PVR2DCONTEXTHANDLE hContext,

-						PVR2DMEMINFO *psMemInfo);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DBlt(PVR2DCONTEXTHANDLE hContext,

-					PVR2DBLTINFO *pBltInfo);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DBltClipped(PVR2DCONTEXTHANDLE hContext,

-						   PVR2DBLTINFO *pBltInfo,

-						   unsigned long ulNumClipRects,

-						   PVR2DRECT *pClipRects);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DQueryBlitsComplete(PVR2DCONTEXTHANDLE hContext,

-								   PVR2DMEMINFO *pMemInfo,

-								   unsigned int uiWaitForComplete);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DSetPresentBltProperties(PVR2DCONTEXTHANDLE hContext,

-										unsigned long ulPropertyMask,

-										long lSrcStride,

-										unsigned long ulDstWidth,

-										unsigned long ulDstHeight,

-										long lDstXPos,

-										long lDstYPos,

-										unsigned long ulNumClipRects,

-										PVR2DRECT *pClipRects,

-										unsigned long ulSwapInterval);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DPresentBlt(PVR2DCONTEXTHANDLE hContext,

-						   PVR2DMEMINFO *pMemInfo,

-						   long lRenderID);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DCreateFlipChain(PVR2DCONTEXTHANDLE hContext,

-								unsigned long ulFlags,

-								unsigned long ulNumBuffers,

-								unsigned long ulWidth,

-								unsigned long ulHeight,

-								PVR2DFORMAT eFormat,

-								long *plStride,

-								unsigned long *pulFlipChainID,

-								PVR2DFLIPCHAINHANDLE *phFlipChain);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DDestroyFlipChain(PVR2DCONTEXTHANDLE hContext,

-								 PVR2DFLIPCHAINHANDLE hFlipChain);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DGetFlipChainBuffers(PVR2DCONTEXTHANDLE hContext,

-									PVR2DFLIPCHAINHANDLE hFlipChain,

-									unsigned long *pulNumBuffers,

-									PVR2DMEMINFO *psMemInfo[]);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DSetPresentFlipProperties(PVR2DCONTEXTHANDLE hContext,

-										 PVR2DFLIPCHAINHANDLE hFlipChain,

-										 unsigned long ulPropertyMask,

-										 long lDstXPos,

-										 long lDstYPos,

-										 unsigned long ulNumClipRects, 

-										 PVR2DRECT *pClipRects,

-										 unsigned long ulSwapInterval);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DPresentFlip(PVR2DCONTEXTHANDLE hContext,

-							PVR2DFLIPCHAINHANDLE hFlipChain,

-							PVR2DMEMINFO *psMemInfo,

-							long lRenderID);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DGetAPIRev(long *lRevMajor, long *lRevMinor);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DLoadUseCode (const PVR2DCONTEXTHANDLE hContext, const unsigned char	*pUseCode,

-									const unsigned long UseCodeSize, PVR2D_HANDLE *pUseCodeHandle);

-PVR2D_IMPORT

-PVR2DERROR PVR2DFreeUseCode (const PVR2DCONTEXTHANDLE hContext, const PVR2D_HANDLE hUseCodeHandle);

-

-PVR2D_IMPORT

-PVR2DERROR PVR2DBlt3D (const PVR2DCONTEXTHANDLE hContext, const PPVR2D_3DBLT pBlt3D);

-

-#ifdef __cplusplus

-}

-#endif 

-

-#endif /* _PVR2D_H_ */

-

-/******************************************************************************

- End of file (pvr2d.h)

-******************************************************************************/

+/*!****************************************************************************
+@File          pvr2d.h
+@Title         PVR2D external header file
+@Author        Imagination Technologies
+@Copyright     Copyright (c) by Imagination Technologies Limited.
+				This specification is protected by copyright laws and contains
+				material proprietary to Imagination Technologies Limited.
+				You may use and distribute this specification free of charge for implementing
+				the functionality therein, without altering or removing any trademark, copyright,
+				or other notice from the specification.
+@Platform      Generic
+@Description   PVR2D definitions for PVR2D clients
+******************************************************************************/
+
+
+/******************************************************************************
+Modifications :-
+$Log: pvr2d.h $
+******************************************************************************/
+
+#ifndef _PVR2D_H_
+#define _PVR2D_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* PVR2D Platform-specific definitions */
+#define PVR2D_EXPORT
+#define PVR2D_IMPORT
+
+
+#define PVR2D_REV_MAJOR		2
+#define PVR2D_REV_MINOR		1
+
+typedef enum
+{
+	PVR2D_FALSE = 0,
+	PVR2D_TRUE
+} PVR2D_BOOL;
+
+
+/* error codes */
+typedef enum
+{
+	PVR2D_OK = 0,
+	PVR2DERROR_INVALID_PARAMETER = -1,
+	PVR2DERROR_DEVICE_UNAVAILABLE = -2,
+	PVR2DERROR_INVALID_CONTEXT = -3,
+	PVR2DERROR_MEMORY_UNAVAILABLE = -4,
+	PVR2DERROR_DEVICE_NOT_PRESENT = -5,
+	PVR2DERROR_IOCTL_ERROR = -6,
+	PVR2DERROR_GENERIC_ERROR = -7,
+	PVR2DERROR_BLT_NOTCOMPLETE = -8,
+	PVR2DERROR_HW_FEATURE_NOT_SUPPORTED = -9,
+	PVR2DERROR_NOT_YET_IMPLEMENTED = -10,
+	PVR2DERROR_MAPPING_FAILED = -11
+}PVR2DERROR;
+
+
+/* pixel formats */
+typedef enum
+{
+	PVR2D_1BPP = 0,
+	PVR2D_RGB565,
+	PVR2D_ARGB4444,
+	PVR2D_RGB888,
+	PVR2D_ARGB8888,
+	PVR2D_ARGB1555,
+	PVR2D_ALPHA8,
+	PVR2D_ALPHA4,
+	PVR2D_PAL2,
+	PVR2D_PAL4,
+	PVR2D_PAL8,
+	PVR2D_VGAEMU
+
+}PVR2DFORMAT;
+
+
+/* wrap surface type */
+typedef enum
+{
+	PVR2D_WRAPFLAG_NONCONTIGUOUS = 0,
+	PVR2D_WRAPFLAG_CONTIGUOUS = 1,
+
+}PVR2DWRAPFLAGS;
+
+/* flags for control information of additional blits */
+typedef enum
+{
+	PVR2D_BLIT_DISABLE_ALL					= 0x0000,	/* disable all additional controls */
+	PVR2D_BLIT_CK_ENABLE					= 0x0001,	/* enable colour key */
+	PVR2D_BLIT_GLOBAL_ALPHA_ENABLE			= 0x0002,	/* enable standard global alpha */
+	PVR2D_BLIT_PERPIXEL_ALPHABLEND_ENABLE	= 0x0004,	/* enable per-pixel alpha bleding */
+	PVR2D_BLIT_PAT_SURFACE_ENABLE			= 0x0008,	/* enable pattern surf (disable fill) */
+	PVR2D_BLIT_FULLY_SPECIFIED_ALPHA_ENABLE	= 0x0010,	/* enable fully specified alpha */
+	PVR2D_BLIT_ROT_90						= 0x0020,	/* apply 90 degree rotation to the blt */
+	PVR2D_BLIT_ROT_180						= 0x0040,	/* apply 180 degree rotation to the blt */
+	PVR2D_BLIT_ROT_270						= 0x0080,	/* apply 270 degree rotation to the blt */
+	PVR2D_BLIT_COPYORDER_TL2BR				= 0x0100,	/* copy order overrides */
+	PVR2D_BLIT_COPYORDER_BR2TL				= 0x0200,
+	PVR2D_BLIT_COPYORDER_TR2BL				= 0x0400,
+	PVR2D_BLIT_COPYORDER_BL2TR				= 0x0800,
+	PVR2D_BLIT_COLKEY_SOURCE				= 0x1000,	/* Key colour is on the source surface */
+	PVR2D_BLIT_COLKEY_DEST					= 0x2000	/* Key colour is on the destination surface */
+
+} PVR2DBLITFLAGS;
+
+/* standard alpha-blending functions, AlphaBlendingFunc field of PVR2DBLTINFO */
+typedef enum
+{
+	PVR2D_ALPHA_OP_SRC_DSTINV = 1,	/* source alpha : Cdst = Csrc*Asrc + Cdst*(1-Asrc) */
+	PVR2D_ALPHA_OP_SRCP_DSTINV = 2	/* premultiplied source alpha : Cdst = Csrc + Cdst*(1-Asrc) */
+} PVR2D_ALPHABLENDFUNC;
+
+/* blend ops for fully specified alpha */
+typedef enum
+{
+	PVR2D_BLEND_OP_ZERO = 0,
+	PVR2D_BLEND_OP_ONE = 1,
+	PVR2D_BLEND_OP_SRC = 2,
+	PVR2D_BLEND_OP_DST = 3,
+	PVR2D_BLEND_OP_GLOBAL = 4,
+	PVR2D_BLEND_OP_SRC_PLUS_GLOBAL = 5,
+	PVR2D_BLEND_OP_DST_PLUS_GLOBAL = 6
+}PVR2D_BLEND_OP;
+
+
+typedef void* PVR2D_HANDLE;
+
+
+/* Fully specified alpha blend :	pAlpha field of PVR2DBLTINFO structure					*/
+/* a fully specified Alpha Blend operation is defined as									*/
+/* DST (ALPHA) = (ALPHA_1 * SRC (ALPHA)) + (ALPHA_3 * DST (ALPHA))							*/
+/* DST (RGB)   = (ALPHA_2 * SRC (RGB)) + (ALPHA_4 * DST (RGB))								*/
+/* if the pre-multiplication stage is enabled then the equations become the following:		*/
+/* PRE_MUL     = ((SRC(A)) * (Global Alpha Value))											*/
+/* DST (ALPHA) = (ALPHA_1 * SRC (ALPHA)) + (PRE_MUL * DST (ALPHA))							*/
+/* DST (RGB)   = (ALPHA_2 * SRC (RGB)) + (PRE_MUL * DST (RGB))								*/
+/* if the transparent source alpha stage is enabled then a source alpha of zero forces the	*/
+/* source to be transparent for that pixel regardless of the blend equation being used.		*/
+typedef struct _PVR2D_ALPHABLT
+{
+	PVR2D_BLEND_OP	eAlpha1;
+	PVR2D_BOOL		bAlpha1Invert;
+	PVR2D_BLEND_OP	eAlpha2;
+	PVR2D_BOOL		bAlpha2Invert;
+	PVR2D_BLEND_OP	eAlpha3;
+	PVR2D_BOOL		bAlpha3Invert;
+	PVR2D_BLEND_OP	eAlpha4;
+	PVR2D_BOOL		bAlpha4Invert;
+	PVR2D_BOOL		bPremulAlpha;			/* enable pre-multiplication stage */
+	PVR2D_BOOL		bTransAlpha;			/* enable transparent source alpha stage */
+	PVR2D_BOOL		bUpdateAlphaLookup;		/* enable and update the 1555-Lookup alpha table */
+	unsigned char	uAlphaLookup0;			/* 8 bit alpha when A=0 in a 1555-Lookup surface */
+	unsigned char	uAlphaLookup1;			/* 8 bit alpha when A=1 in a 1555-Lookup surface */
+	unsigned char	uGlobalRGB;				/* Global Alpha Value for RGB, 0=transparent 255=opaque */
+	unsigned char	uGlobalA;				/* Global Alpha Value for Alpha */
+
+} PVR2D_ALPHABLT, *PPVR2D_ALPHABLT;
+
+
+/* surface memory info structure */
+typedef struct _PVR2DMEMINFO
+{
+	void				*pBase;
+	unsigned long		ui32MemSize;
+	unsigned long		ui32DevAddr;
+	unsigned long		ulFlags;
+	void				*hPrivateData;
+	void				*hPrivateMapData;
+
+}PVR2DMEMINFO, *PPVR2DMEMINFO;
+
+
+#define PVR2D_MAX_DEVICE_NAME 20
+
+typedef struct _PVR2DDEVICEINFO
+{
+	unsigned long	ulDevID;
+	char			szDeviceName[PVR2D_MAX_DEVICE_NAME];
+}PVR2DDEVICEINFO;
+
+
+typedef struct _PVR2DISPLAYINFO
+{
+	unsigned long	ulMaxFlipChains;
+	unsigned long	ulMaxBuffersInChain;
+	PVR2DFORMAT		eFormat;
+	unsigned long	ulWidth;
+	unsigned long	ulHeight;
+	long			lStride;
+	unsigned long	ulMinFlipInterval;
+	unsigned long	ulMaxFlipInterval;
+
+}PVR2DDISPLAYINFO;
+
+
+typedef struct _PVR2DBLTINFO
+{
+	unsigned long	CopyCode;			/* rop code  */
+	unsigned long	Colour;				/* fill colour */
+	unsigned long	ColourKey;			/* colour key */
+	unsigned char	GlobalAlphaValue;	/* global alpha blending */
+	unsigned char	AlphaBlendingFunc;	/* per-pixel alpha-blending function */
+
+	PVR2DBLITFLAGS	BlitFlags;			/* additional blit control information */
+
+	PVR2DMEMINFO	*pDstMemInfo;		/* destination memory */
+	unsigned long	DstOffset;			/* byte offset from start of allocation to destination surface pixel 0,0 */
+	long			DstStride;			/* signed stride, the number of bytes from pixel 0,0 to 0,1 */
+	long			DstX, DstY;			/* pixel offset from start of dest surface to start of blt rectangle */
+	long			DSizeX,DSizeY;		/* blt size */
+	PVR2DFORMAT		DstFormat;			/* dest format */
+	unsigned long	DstSurfWidth;		/* size of dest surface in pixels */
+	unsigned long	DstSurfHeight;		/* size of dest surface in pixels */
+
+	PVR2DMEMINFO	*pSrcMemInfo;		/* source mem, (source fields are also used for patterns) */
+	unsigned long	SrcOffset;			/* byte offset from start of allocation to src/pat surface pixel 0,0 */
+	long			SrcStride;			/* signed stride, the number of bytes from pixel 0,0 to 0,1 */
+	long			SrcX, SrcY;			/* pixel offset from start of surface to start of source rectangle */
+										/* for patterns this is the start offset within the pattern */
+	long			SizeX,SizeY;		/* source rectangle size or pattern size in pixels */
+	PVR2DFORMAT		SrcFormat;			/* source/pattern format */
+	PVR2DMEMINFO	*pPalMemInfo;		/* source/pattern palette memory containing argb8888 colour table */
+	unsigned long	PalOffset;			/* byte offset from start of allocation to start of palette */
+	unsigned long	SrcSurfWidth;		/* size of source surface in pixels */
+	unsigned long	SrcSurfHeight;		/* size of source surface in pixels */
+
+	PVR2DMEMINFO	*pMaskMemInfo;		/* mask memory, 1bpp format implied */
+	unsigned long	MaskOffset;			/* byte offset from start of allocation to mask surface pixel 0,0 */
+	long			MaskStride;			/* signed stride, the number of bytes from pixel 0,0 to 0,1 */
+	long			MaskX, MaskY;		/* mask rect top left (mask size = blt size) */
+	unsigned long	MaskSurfWidth;		/* size of mask surface in pixels */
+	unsigned long	MaskSurfHeight;		/* size of mask surface in pixels */
+	
+	PPVR2D_ALPHABLT pAlpha;				/* fully specified alpha blend */
+
+}PVR2DBLTINFO, *PPVR2DBLTINFO;
+
+typedef struct _PVR2DRECT
+{
+	long left, top;
+	long right, bottom;
+} PVR2DRECT;
+
+typedef struct
+{
+	PVR2DMEMINFO	*pSurfMemInfo;		/* surface memory */
+	unsigned long	SurfOffset;			/* byte offset from start of allocation to destination surface pixel 0,0 */
+	long			Stride;				/* signed stride */
+	PVR2DFORMAT		Format;
+	unsigned long	SurfWidth;			/* surface size in pixels */
+	unsigned long	SurfHeight;
+
+} PVR2D_SURFACE, *PPVR2D_SURFACE;
+
+typedef struct
+{
+	unsigned long	*pUseCode;					/* USSE code */
+	unsigned long	UseCodeSize;				/* usse code size in bytes */
+
+} PVR2D_USECODE, *PPVR2D_USECODE;
+
+typedef struct
+{
+	PVR2D_SURFACE			sDst;				/* destination surface */
+	PVR2D_SURFACE			sSrc;				/* source surface */
+	PVR2DRECT				rcDest;				/* destination rectangle */
+	PVR2DRECT				rcSource;			/* source rectangle */
+	PVR2D_HANDLE			hUseCode;			/* custom USE code (NULL implies source copy) */
+	unsigned long			UseParams[2];		/* per-blt params for use code */
+
+} PVR2D_3DBLT, *PPVR2D_3DBLT;
+
+
+#define MAKE_COPY_BLIT(src,soff,dest,doff,sx,sy,dx,dy,sz)
+
+typedef void* PVR2DCONTEXTHANDLE;
+typedef void* PVR2DFLIPCHAINHANDLE;
+
+
+// CopyCode field of PVR2DBLTINFO structure:
+// the CopyCode field of the PVR2DBLTINFO structure should contain a rop3 or rop4 code.
+// a rop3 is an 8 bit code that describes a blt with three inputs : source dest and pattern
+// rop4 is a 16 bit code that describes a blt with four inputs : source dest pattern and mask
+// common rop3 codes are defined below
+// a colour fill blt is processed in the pattern channel as a constant colour with a rop code of 0xF0
+// PVR2D_BLIT_PAT_SURFACE_ENABLE defines whether the pattern channel is a surface or a fill colour.
+// a rop4 is defined by two rop3 codes, and the 1 bit-per-pixel mask surface defines which is used.
+// a common rop4 is 0xAAF0 which is the mask copy blt used for text glyphs.
+// CopyCode is taken to be a rop4 when pMaskMemInfo is non zero, otherwise it is assumed to be a rop3
+// use the PVR2DMASKROP4 macro below to construct a rop4 from two rop3's
+// rop3a is the rop used when mask pixel = 1, and rop3b when mask = 0
+#define PVR2DROP4(rop3b, rop3a)			((rop3b<<8)|rop3a)
+
+/* common rop codes */
+#define PVR2DROPclear				0x00       /* 0 (whiteness) */
+#define PVR2DROPset					0xFF       /* 1 (blackness) */
+#define PVR2DROPnoop				0xAA       /* dst (used for masked blts) */
+
+/* source and  dest rop codes */
+#define PVR2DROPand					0x88       /* src AND dst */
+#define PVR2DROPandReverse			0x44       /* src AND NOT dst */
+#define PVR2DROPcopy				0xCC       /* src (used for source copy and alpha blts) */
+#define PVR2DROPandInverted			0x22       /* NOT src AND dst */
+#define PVR2DROPxor					0x66       /* src XOR dst */
+#define PVR2DROPor					0xEE       /* src OR dst */
+#define PVR2DROPnor					0x11       /* NOT src AND NOT dst */
+#define PVR2DROPequiv				0x99       /* NOT src XOR dst */
+#define PVR2DROPinvert				0x55       /* NOT dst */
+#define PVR2DROPorReverse			0xDD       /* src OR NOT dst */
+#define PVR2DROPcopyInverted		0x33       /* NOT src */
+#define PVR2DROPorInverted			0xBB       /* NOT src OR dst */
+#define PVR2DROPnand				0x77       /* NOT src OR NOT dst */
+
+/* pattern rop codes */
+#define PVR2DPATROPand				0xA0       /* pat AND dst */
+#define PVR2DPATROPandReverse		0x50       /* pat AND NOT dst */
+#define PVR2DPATROPcopy				0xF0       /* pat (used for solid color fills and pattern blts) */
+#define PVR2DPATROPandInverted		0x0A       /* NOT pat AND dst */
+#define PVR2DPATROPxor				0x5A       /* pat XOR dst */
+#define PVR2DPATROPor				0xFA       /* pat OR dst */
+#define PVR2DPATROPnor				0x05       /* NOT pat AND NOT dst */
+#define PVR2DPATROPequiv			0xA5       /* NOT pat XOR dst */
+#define PVR2DPATROPinvert			0x55       /* NOT dst */
+#define PVR2DPATROPorReverse		0xF5       /* pat OR NOT dst */
+#define PVR2DPATROPcopyInverted		0x0F       /* NOT pat */
+#define PVR2DPATROPorInverted		0xAF       /* NOT pat OR dst */
+#define PVR2DPATROPnand				0x5F       /* NOT pat OR NOT dst */
+
+/* common rop4 codes */
+#define PVR2DROP4MaskedCopy              PVR2DROP4(PVR2DROPnoop,PVR2DROPcopy)		/* masked source copy blt (used for rounded window corners etc) */
+#define PVR2DROP4MaskedFill              PVR2DROP4(PVR2DROPnoop,PVR2DPATROPcopy)	/* masked colour fill blt (used for text) */
+
+/* Legacy support */
+#define PVR2DROP3_PATMASK			PVR2DPATROPcopy
+#define PVR2DROP3_SRCMASK			PVR2DROPcopy
+
+/* pixmap memory alignment */
+#define PVR2D_ALIGNMENT_4			4			/* DWORD alignment */
+#define PVR2D_ALIGNMENT_ANY			0			/* no alignment    */
+#define PVR2D_ALIGNMENT_PALETTE		16			/* 16 byte alignment is required for palettes */
+
+/* Heap number for PVR2DGetFrameBuffer */
+#define PVR2D_FB_PRIMARY_SURFACE 0
+
+#define PVR2D_PRESENT_PROPERTY_SRCSTRIDE	(1 << 0)
+#define PVR2D_PRESENT_PROPERTY_DSTSIZE		(1 << 1)
+#define PVR2D_PRESENT_PROPERTY_DSTPOS		(1 << 2)
+#define PVR2D_PRESENT_PROPERTY_CLIPRECTS	(1 << 3)
+#define PVR2D_PRESENT_PROPERTY_INTERVAL		(1 << 4)
+
+
+#define PVR2D_CREATE_FLIPCHAIN_SHARED		(1 << 0)
+#define PVR2D_CREATE_FLIPCHAIN_QUERY		(1 << 1)
+
+/* Functions that the library exports */
+
+PVR2D_IMPORT
+int PVR2DEnumerateDevices(PVR2DDEVICEINFO *pDevInfo);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DCreateDeviceContext(unsigned long ulDevID,
+									PVR2DCONTEXTHANDLE* phContext,
+									unsigned long ulFlags);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DDestroyDeviceContext(PVR2DCONTEXTHANDLE hContext);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DGetDeviceInfo(PVR2DCONTEXTHANDLE hContext,
+							  PVR2DDISPLAYINFO *pDisplayInfo);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DGetScreenMode(PVR2DCONTEXTHANDLE hContext,
+							  PVR2DFORMAT *pFormat,
+							  long *plWidth,
+							  long *plHeight,
+							  long *plStride,
+							  int *piRefreshRate);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DGetFrameBuffer(PVR2DCONTEXTHANDLE hContext,
+							   int nHeap,
+							   PVR2DMEMINFO **ppsMemInfo);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DMemAlloc(PVR2DCONTEXTHANDLE hContext,
+						 unsigned long ulBytes,
+						 unsigned long ulAlign,
+						 unsigned long ulFlags,
+						 PVR2DMEMINFO **ppsMemInfo);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DMemWrap(PVR2DCONTEXTHANDLE hContext,
+						void *pMem,
+						unsigned long ulFlags,
+						unsigned long ulBytes,
+						unsigned long alPageAddress[],
+						PVR2DMEMINFO **ppsMemInfo);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DMemMap(PVR2DCONTEXTHANDLE hContext,
+						unsigned long ulFlags,
+						void *hPrivateMapData,
+						PVR2DMEMINFO **ppsDstMem);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DMemFree(PVR2DCONTEXTHANDLE hContext,
+						PVR2DMEMINFO *psMemInfo);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DBlt(PVR2DCONTEXTHANDLE hContext,
+					PVR2DBLTINFO *pBltInfo);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DBltClipped(PVR2DCONTEXTHANDLE hContext,
+						   PVR2DBLTINFO *pBltInfo,
+						   unsigned long ulNumClipRects,
+						   PVR2DRECT *pClipRects);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DQueryBlitsComplete(PVR2DCONTEXTHANDLE hContext,
+								   PVR2DMEMINFO *pMemInfo,
+								   unsigned int uiWaitForComplete);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DSetPresentBltProperties(PVR2DCONTEXTHANDLE hContext,
+										unsigned long ulPropertyMask,
+										long lSrcStride,
+										unsigned long ulDstWidth,
+										unsigned long ulDstHeight,
+										long lDstXPos,
+										long lDstYPos,
+										unsigned long ulNumClipRects,
+										PVR2DRECT *pClipRects,
+										unsigned long ulSwapInterval);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DPresentBlt(PVR2DCONTEXTHANDLE hContext,
+						   PVR2DMEMINFO *pMemInfo,
+						   long lRenderID);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DCreateFlipChain(PVR2DCONTEXTHANDLE hContext,
+								unsigned long ulFlags,
+								unsigned long ulNumBuffers,
+								unsigned long ulWidth,
+								unsigned long ulHeight,
+								PVR2DFORMAT eFormat,
+								long *plStride,
+								unsigned long *pulFlipChainID,
+								PVR2DFLIPCHAINHANDLE *phFlipChain);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DDestroyFlipChain(PVR2DCONTEXTHANDLE hContext,
+								 PVR2DFLIPCHAINHANDLE hFlipChain);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DGetFlipChainBuffers(PVR2DCONTEXTHANDLE hContext,
+									PVR2DFLIPCHAINHANDLE hFlipChain,
+									unsigned long *pulNumBuffers,
+									PVR2DMEMINFO *psMemInfo[]);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DSetPresentFlipProperties(PVR2DCONTEXTHANDLE hContext,
+										 PVR2DFLIPCHAINHANDLE hFlipChain,
+										 unsigned long ulPropertyMask,
+										 long lDstXPos,
+										 long lDstYPos,
+										 unsigned long ulNumClipRects,
+										 PVR2DRECT *pClipRects,
+										 unsigned long ulSwapInterval);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DPresentFlip(PVR2DCONTEXTHANDLE hContext,
+							PVR2DFLIPCHAINHANDLE hFlipChain,
+							PVR2DMEMINFO *psMemInfo,
+							long lRenderID);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DGetAPIRev(long *lRevMajor, long *lRevMinor);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DLoadUseCode (const PVR2DCONTEXTHANDLE hContext, const unsigned char	*pUseCode,
+									const unsigned long UseCodeSize, PVR2D_HANDLE *pUseCodeHandle);
+PVR2D_IMPORT
+PVR2DERROR PVR2DFreeUseCode (const PVR2DCONTEXTHANDLE hContext, const PVR2D_HANDLE hUseCodeHandle);
+
+PVR2D_IMPORT
+PVR2DERROR PVR2DBlt3D (const PVR2DCONTEXTHANDLE hContext, const PPVR2D_3DBLT pBlt3D);
+
+#ifdef __cplusplus
+}
+#endif 
+
+#endif /* _PVR2D_H_ */
+
+/******************************************************************************
+ End of file (pvr2d.h)
+******************************************************************************/
diff --git a/src/3rdparty/powervr/wsegl.h b/src/3rdparty/powervr/wsegl.h
index e82c968..0490607 100644
--- a/src/3rdparty/powervr/wsegl.h
+++ b/src/3rdparty/powervr/wsegl.h
@@ -1,240 +1,240 @@
-/******************************************************************************

- Name         : wsegl.h

- Copyright    :	Copyright (c) Imagination Technologies Limited.

-				This specification is protected by copyright laws and contains

-				material proprietary to Imagination Technologies Limited.

-				You may use and distribute this specification free of charge for implementing 

-				the functionality therein, without altering or removing any trademark, copyright, 

-				or other notice from the specification.

- Platform     : ANSI

-*****************************************************************************/

-

-

-#if !defined(__WSEGL_H__)

-#define __WSEGL_H__

-

-#ifdef __cplusplus

-extern "C" {

-#endif 

-

-/*

-// WSEGL Platform-specific definitions

-*/

-#define WSEGL_EXPORT

-#define WSEGL_IMPORT

-

-/*

-// WSEGL API Version Number

-*/

-

-#define WSEGL_VERSION 1

-#define WSEGL_DEFAULT_DISPLAY 0

-#define WSEGL_DEFAULT_NATIVE_ENGINE 0

-

-#define WSEGL_FALSE		0

-#define WSEGL_TRUE		1

-#define WSEGL_NULL		0

-

-#define	WSEGL_UNREFERENCED_PARAMETER(param) (param) = (param)

-

-/*

-// WSEGL handles

-*/

-typedef void *WSEGLDisplayHandle;

-typedef void *WSEGLDrawableHandle;

-

-/*

-// Display capability type

-*/

-typedef enum WSEGLCapsType_TAG

-{

-	WSEGL_NO_CAPS = 0,

-	WSEGL_CAP_MIN_SWAP_INTERVAL = 1, /* System default value = 1 */

-	WSEGL_CAP_MAX_SWAP_INTERVAL = 2, /* System default value = 1 */

-	WSEGL_CAP_WINDOWS_USE_HW_SYNC = 3, /* System default value = 0 (FALSE) */

-	WSEGL_CAP_PIXMAPS_USE_HW_SYNC = 4, /* System default value = 0 (FALSE) */

-

-} WSEGLCapsType;

-

-/*

-// Display capability

-*/

-typedef struct WSEGLCaps_TAG

-{

-	WSEGLCapsType eCapsType;

-	unsigned long ui32CapsValue;

-

-} WSEGLCaps;

-

-/*

-// Drawable type

-*/

-#define WSEGL_NO_DRAWABLE			0x0

-#define WSEGL_DRAWABLE_WINDOW		0x1

-#define WSEGL_DRAWABLE_PIXMAP		0x2

-

-

-/*

-// Pixel format of display/drawable

-*/

-typedef enum WSEGLPixelFormat_TAG

-{

-	WSEGL_PIXELFORMAT_565 = 0,

-	WSEGL_PIXELFORMAT_4444 = 1,

-	WSEGL_PIXELFORMAT_8888 = 2,

-	WSEGL_PIXELFORMAT_1555 = 3

-

-} WSEGLPixelFormat;

-

-/*

-// Transparent of display/drawable

-*/

-typedef enum WSEGLTransparentType_TAG

-{

-	WSEGL_OPAQUE = 0,

-	WSEGL_COLOR_KEY = 1,

-

-} WSEGLTransparentType;

-

-/*

-// Display/drawable configuration

-*/

-typedef struct WSEGLConfig_TAG

-{

-	/*

-	// Type of drawables this configuration applies to -

-	// OR'd values of drawable types. 

-	*/

-	unsigned long ui32DrawableType;

-

-	/* Pixel format */

-	WSEGLPixelFormat ePixelFormat;

-

-	/* Native Renderable  - set to WSEGL_TRUE if native renderable */

-	unsigned long ulNativeRenderable;

-

-	/* FrameBuffer Level Parameter */

-	unsigned long ulFrameBufferLevel;

-

-	/* Native Visual ID */

-	unsigned long ulNativeVisualID;

-

-	/* Native Visual */

-	void *hNativeVisual;

-

-	/* Transparent Type */

-	WSEGLTransparentType eTransparentType;

-

-	/* Transparent Color - only used if transparent type is COLOR_KEY */

-	unsigned long ulTransparentColor; /* packed as 0x00RRGGBB */

-

-

-} WSEGLConfig;

-

-/*

-// WSEGL errors

-*/

-typedef enum WSEGLError_TAG

-{

-	WSEGL_SUCCESS = 0,

-	WSEGL_CANNOT_INITIALISE = 1,

-	WSEGL_BAD_NATIVE_DISPLAY = 2,

-	WSEGL_BAD_NATIVE_WINDOW = 3,

-	WSEGL_BAD_NATIVE_PIXMAP = 4,

-	WSEGL_BAD_NATIVE_ENGINE = 5,

-	WSEGL_BAD_DRAWABLE = 6,

-	WSEGL_BAD_CONFIG = 7,

-	WSEGL_OUT_OF_MEMORY = 8

-

-} WSEGLError; 

-

-/*

-// Drawable orientation (in degrees anti-clockwise)

-*/

-typedef enum WSEGLRotationAngle_TAG

-{

-	WSEGL_ROTATE_0 = 0,

-	WSEGL_ROTATE_90 = 1,

-	WSEGL_ROTATE_180 = 2,

-	WSEGL_ROTATE_270 = 3

-

-} WSEGLRotationAngle; 

-

-/*

-// Drawable information required by OpenGL-ES driver

-*/

-typedef struct WSEGLDrawableParams_TAG

-{

-	/* Width in pixels of the drawable */

-	unsigned long	ui32Width;

-

-	/* Height in pixels of the drawable */

-	unsigned long	ui32Height;

-

-	/* Stride in pixels of the drawable */

-	unsigned long	ui32Stride;

-

-	/* Pixel format of the drawable */

-	WSEGLPixelFormat	ePixelFormat;

-

-	/* User space cpu virtual address of the drawable */

-	void   			*pvLinearAddress;

-

-	/* HW address of the drawable */

-	unsigned long	ui32HWAddress;

-

-	/* Private data for the drawable */

-	void			*hPrivateData;

-

-} WSEGLDrawableParams;

-

-

-/*

-// Table of function pointers that is returned by WSEGL_GetFunctionTablePointer()

-//

-// The first entry in the table is the version number of the wsegl.h header file that

-// the module has been written against, and should therefore be set to WSEGL_VERSION

-*/

-typedef struct WSEGL_FunctionTable_TAG

-{

-	unsigned long ui32WSEGLVersion;

-

-	WSEGLError (*pfnWSEGL_IsDisplayValid)(NativeDisplayType);

-

-	WSEGLError (*pfnWSEGL_InitialiseDisplay)(NativeDisplayType, WSEGLDisplayHandle *, const WSEGLCaps **, WSEGLConfig **);

-

-	WSEGLError (*pfnWSEGL_CloseDisplay)(WSEGLDisplayHandle);

-

-	WSEGLError (*pfnWSEGL_CreateWindowDrawable)(WSEGLDisplayHandle, WSEGLConfig *, WSEGLDrawableHandle *, NativeWindowType, WSEGLRotationAngle *);

-

-	WSEGLError (*pfnWSEGL_CreatePixmapDrawable)(WSEGLDisplayHandle, WSEGLConfig *, WSEGLDrawableHandle *, NativePixmapType, WSEGLRotationAngle *);

-

-	WSEGLError (*pfnWSEGL_DeleteDrawable)(WSEGLDrawableHandle);

-

-	WSEGLError (*pfnWSEGL_SwapDrawable)(WSEGLDrawableHandle, unsigned long);

-

-	WSEGLError (*pfnWSEGL_SwapControlInterval)(WSEGLDrawableHandle, unsigned long);

-

-	WSEGLError (*pfnWSEGL_WaitNative)(WSEGLDrawableHandle, unsigned long);

-

-	WSEGLError (*pfnWSEGL_CopyFromDrawable)(WSEGLDrawableHandle, NativePixmapType);

-

-	WSEGLError (*pfnWSEGL_CopyFromPBuffer)(void *, unsigned long, unsigned long, unsigned long, WSEGLPixelFormat, NativePixmapType);

-

-	WSEGLError (*pfnWSEGL_GetDrawableParameters)(WSEGLDrawableHandle, WSEGLDrawableParams *, WSEGLDrawableParams *);

-

-

-} WSEGL_FunctionTable;

-

-

-WSEGL_IMPORT const WSEGL_FunctionTable *WSEGL_GetFunctionTablePointer(void);

-

-#ifdef __cplusplus

-}

-#endif 

-

-#endif /* __WSEGL_H__ */

-

-/******************************************************************************

- End of file (wsegl.h)

-******************************************************************************/

+/******************************************************************************
+ Name         : wsegl.h
+ Copyright    :	Copyright (c) Imagination Technologies Limited.
+				This specification is protected by copyright laws and contains
+				material proprietary to Imagination Technologies Limited.
+				You may use and distribute this specification free of charge for implementing
+				the functionality therein, without altering or removing any trademark, copyright,
+				or other notice from the specification.
+ Platform     : ANSI
+*****************************************************************************/
+
+
+#if !defined(__WSEGL_H__)
+#define __WSEGL_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif 
+
+/*
+// WSEGL Platform-specific definitions
+*/
+#define WSEGL_EXPORT
+#define WSEGL_IMPORT
+
+/*
+// WSEGL API Version Number
+*/
+
+#define WSEGL_VERSION 1
+#define WSEGL_DEFAULT_DISPLAY 0
+#define WSEGL_DEFAULT_NATIVE_ENGINE 0
+
+#define WSEGL_FALSE		0
+#define WSEGL_TRUE		1
+#define WSEGL_NULL		0
+
+#define	WSEGL_UNREFERENCED_PARAMETER(param) (param) = (param)
+
+/*
+// WSEGL handles
+*/
+typedef void *WSEGLDisplayHandle;
+typedef void *WSEGLDrawableHandle;
+
+/*
+// Display capability type
+*/
+typedef enum WSEGLCapsType_TAG
+{
+	WSEGL_NO_CAPS = 0,
+	WSEGL_CAP_MIN_SWAP_INTERVAL = 1, /* System default value = 1 */
+	WSEGL_CAP_MAX_SWAP_INTERVAL = 2, /* System default value = 1 */
+	WSEGL_CAP_WINDOWS_USE_HW_SYNC = 3, /* System default value = 0 (FALSE) */
+	WSEGL_CAP_PIXMAPS_USE_HW_SYNC = 4, /* System default value = 0 (FALSE) */
+
+} WSEGLCapsType;
+
+/*
+// Display capability
+*/
+typedef struct WSEGLCaps_TAG
+{
+	WSEGLCapsType eCapsType;
+	unsigned long ui32CapsValue;
+
+} WSEGLCaps;
+
+/*
+// Drawable type
+*/
+#define WSEGL_NO_DRAWABLE			0x0
+#define WSEGL_DRAWABLE_WINDOW		0x1
+#define WSEGL_DRAWABLE_PIXMAP		0x2
+
+
+/*
+// Pixel format of display/drawable
+*/
+typedef enum WSEGLPixelFormat_TAG
+{
+	WSEGL_PIXELFORMAT_565 = 0,
+	WSEGL_PIXELFORMAT_4444 = 1,
+	WSEGL_PIXELFORMAT_8888 = 2,
+	WSEGL_PIXELFORMAT_1555 = 3
+
+} WSEGLPixelFormat;
+
+/*
+// Transparent of display/drawable
+*/
+typedef enum WSEGLTransparentType_TAG
+{
+	WSEGL_OPAQUE = 0,
+	WSEGL_COLOR_KEY = 1,
+
+} WSEGLTransparentType;
+
+/*
+// Display/drawable configuration
+*/
+typedef struct WSEGLConfig_TAG
+{
+	/*
+	// Type of drawables this configuration applies to -
+	// OR'd values of drawable types. 
+	*/
+	unsigned long ui32DrawableType;
+
+	/* Pixel format */
+	WSEGLPixelFormat ePixelFormat;
+
+	/* Native Renderable  - set to WSEGL_TRUE if native renderable */
+	unsigned long ulNativeRenderable;
+
+	/* FrameBuffer Level Parameter */
+	unsigned long ulFrameBufferLevel;
+
+	/* Native Visual ID */
+	unsigned long ulNativeVisualID;
+
+	/* Native Visual */
+	void *hNativeVisual;
+
+	/* Transparent Type */
+	WSEGLTransparentType eTransparentType;
+
+	/* Transparent Color - only used if transparent type is COLOR_KEY */
+	unsigned long ulTransparentColor; /* packed as 0x00RRGGBB */
+
+
+} WSEGLConfig;
+
+/*
+// WSEGL errors
+*/
+typedef enum WSEGLError_TAG
+{
+	WSEGL_SUCCESS = 0,
+	WSEGL_CANNOT_INITIALISE = 1,
+	WSEGL_BAD_NATIVE_DISPLAY = 2,
+	WSEGL_BAD_NATIVE_WINDOW = 3,
+	WSEGL_BAD_NATIVE_PIXMAP = 4,
+	WSEGL_BAD_NATIVE_ENGINE = 5,
+	WSEGL_BAD_DRAWABLE = 6,
+	WSEGL_BAD_CONFIG = 7,
+	WSEGL_OUT_OF_MEMORY = 8
+
+} WSEGLError; 
+
+/*
+// Drawable orientation (in degrees anti-clockwise)
+*/
+typedef enum WSEGLRotationAngle_TAG
+{
+	WSEGL_ROTATE_0 = 0,
+	WSEGL_ROTATE_90 = 1,
+	WSEGL_ROTATE_180 = 2,
+	WSEGL_ROTATE_270 = 3
+
+} WSEGLRotationAngle; 
+
+/*
+// Drawable information required by OpenGL-ES driver
+*/
+typedef struct WSEGLDrawableParams_TAG
+{
+	/* Width in pixels of the drawable */
+	unsigned long	ui32Width;
+
+	/* Height in pixels of the drawable */
+	unsigned long	ui32Height;
+
+	/* Stride in pixels of the drawable */
+	unsigned long	ui32Stride;
+
+	/* Pixel format of the drawable */
+	WSEGLPixelFormat	ePixelFormat;
+
+	/* User space cpu virtual address of the drawable */
+	void   			*pvLinearAddress;
+
+	/* HW address of the drawable */
+	unsigned long	ui32HWAddress;
+
+	/* Private data for the drawable */
+	void			*hPrivateData;
+
+} WSEGLDrawableParams;
+
+
+/*
+// Table of function pointers that is returned by WSEGL_GetFunctionTablePointer()
+//
+// The first entry in the table is the version number of the wsegl.h header file that
+// the module has been written against, and should therefore be set to WSEGL_VERSION
+*/
+typedef struct WSEGL_FunctionTable_TAG
+{
+	unsigned long ui32WSEGLVersion;
+
+	WSEGLError (*pfnWSEGL_IsDisplayValid)(NativeDisplayType);
+
+	WSEGLError (*pfnWSEGL_InitialiseDisplay)(NativeDisplayType, WSEGLDisplayHandle *, const WSEGLCaps **, WSEGLConfig **);
+
+	WSEGLError (*pfnWSEGL_CloseDisplay)(WSEGLDisplayHandle);
+
+	WSEGLError (*pfnWSEGL_CreateWindowDrawable)(WSEGLDisplayHandle, WSEGLConfig *, WSEGLDrawableHandle *, NativeWindowType, WSEGLRotationAngle *);
+
+	WSEGLError (*pfnWSEGL_CreatePixmapDrawable)(WSEGLDisplayHandle, WSEGLConfig *, WSEGLDrawableHandle *, NativePixmapType, WSEGLRotationAngle *);
+
+	WSEGLError (*pfnWSEGL_DeleteDrawable)(WSEGLDrawableHandle);
+
+	WSEGLError (*pfnWSEGL_SwapDrawable)(WSEGLDrawableHandle, unsigned long);
+
+	WSEGLError (*pfnWSEGL_SwapControlInterval)(WSEGLDrawableHandle, unsigned long);
+
+	WSEGLError (*pfnWSEGL_WaitNative)(WSEGLDrawableHandle, unsigned long);
+
+	WSEGLError (*pfnWSEGL_CopyFromDrawable)(WSEGLDrawableHandle, NativePixmapType);
+
+	WSEGLError (*pfnWSEGL_CopyFromPBuffer)(void *, unsigned long, unsigned long, unsigned long, WSEGLPixelFormat, NativePixmapType);
+
+	WSEGLError (*pfnWSEGL_GetDrawableParameters)(WSEGLDrawableHandle, WSEGLDrawableParams *, WSEGLDrawableParams *);
+
+
+} WSEGL_FunctionTable;
+
+
+WSEGL_IMPORT const WSEGL_FunctionTable *WSEGL_GetFunctionTablePointer(void);
+
+#ifdef __cplusplus
+}
+#endif 
+
+#endif /* __WSEGL_H__ */
+
+/******************************************************************************
+ End of file (wsegl.h)
+******************************************************************************/
diff --git a/src/gui/embedded/qwindowsystem_qws.cpp b/src/gui/embedded/qwindowsystem_qws.cpp
index dffebf2..fdcd193 100644
--- a/src/gui/embedded/qwindowsystem_qws.cpp
+++ b/src/gui/embedded/qwindowsystem_qws.cpp
@@ -4044,7 +4044,7 @@ void QWSServer::setDesktopBackground(const QImage &img)
 */
 void QWSServer::setDesktopBackground(const QColor &c)
 {
-    setDesktopBackground(QBrush(c));
+    setBackground(QBrush(c));
 }
 #endif //QT3_SUPPORT
 
diff --git a/src/gui/kernel/qcocoaapplicationdelegate_mac.mm b/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
index dad15d9..9a24645 100644
--- a/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
+++ b/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
@@ -183,21 +183,24 @@ static void cleanupCocoaApplicationDelegate()
 {
     Q_UNUSED(sender);
     // The reflection delegate gets precedence
-    NSApplicationTerminateReply reply = NSTerminateCancel;
     if (reflectionDelegate
         && [reflectionDelegate respondsToSelector:@selector(applicationShouldTerminate:)]) {
         return [reflectionDelegate applicationShouldTerminate:sender];
     }
 
     if (qtPrivate->canQuit()) {
-        reply = NSTerminateNow;
         if (!startedQuit) {
             startedQuit = true;
             qAppInstance()->quit();
             startedQuit = false;
         }
     }
-    return reply;
+
+    // Prevent Cocoa from terminating the application, since this simply
+    // exits the program whithout allowing QApplication::exec() to return.
+    // The call to QApplication::quit() above will instead quit the
+    // application from the Qt side.
+    return NSTerminateCancel;
 }
 
 - (void)applicationDidFinishLaunching:(NSNotification *)aNotification
diff --git a/src/gui/kernel/qt_cocoa_helpers_mac.mm b/src/gui/kernel/qt_cocoa_helpers_mac.mm
index f000292..9165836 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac.mm
+++ b/src/gui/kernel/qt_cocoa_helpers_mac.mm
@@ -826,13 +826,28 @@ bool qt_mac_handleMouseEvent(void * /* NSView * */view, void * /* NSEvent * */ev
     QWidget *qwidget = [theView qt_qwidget];
     QWidget *widgetToGetMouse = qwidget;
     QWidget *popup = qAppInstance()->activePopupWidget();
-    if (popup && popup != qwidget->window())
-        widgetToGetMouse = popup;
     NSView *tmpView = theView;
-    if (widgetToGetMouse != qwidget) {
-        tmpView = qt_mac_nativeview_for(widgetToGetMouse);
+
+    if (popup && popup != qwidget->window()) {
+        widgetToGetMouse = popup;
+        tmpView = qt_mac_nativeview_for(popup);
         windowPoint = [[tmpView window] convertScreenToBase:globalPoint];
+
+        QPoint qWindowPoint(windowPoint.x, windowPoint.y);
+        if (widgetToGetMouse->rect().contains(qWindowPoint)) {
+            // Keeping the mouse pressed on a combobox button will make
+            // the popup pop in front of the mouse. But all mouse events
+            // will be sendt to the button. Since we want mouse events
+            // to be sendt to widgets inside the popup, we search for the
+            // widget in front of the mouse:
+            tmpView = [tmpView hitTest:windowPoint];
+            if (!tmpView)
+                return false;
+            widgetToGetMouse =
+                [static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(tmpView) qt_qwidget];
+        }
     }
+
     NSPoint localPoint = [tmpView convertPoint:windowPoint fromView:nil];
     QPoint qlocalPoint(localPoint.x, localPoint.y);
 
diff --git a/src/gui/kernel/qwidget_mac.mm b/src/gui/kernel/qwidget_mac.mm
index 5abaaf8..3f89ff3 100644
--- a/src/gui/kernel/qwidget_mac.mm
+++ b/src/gui/kernel/qwidget_mac.mm
@@ -2162,6 +2162,7 @@ void QWidgetPrivate::finishCreateWindow_sys_Carbon(OSWindowRef windowRef)
     setWindowModified_sys(q->isWindowModified());
     updateFrameStrut();
     qt_mac_update_sizer(q);
+    applyMaxAndMinSizeOnWindow();
 }
 #else  // QT_MAC_USE_COCOA
 void QWidgetPrivate::finishCreateWindow_sys_Cocoa(void * /*NSWindow * */ voidWindowRef)
@@ -2247,6 +2248,7 @@ void QWidgetPrivate::finishCreateWindow_sys_Cocoa(void * /*NSWindow * */ voidWin
     syncCocoaMask();
     macUpdateIsOpaque();
     qt_mac_update_sizer(q);
+    applyMaxAndMinSizeOnWindow();
 }
 
 #endif // QT_MAC_USE_COCOA
@@ -4001,7 +4003,7 @@ void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
     }
 }
 
-void QWidgetPrivate::applyMaxAndMinSizeConstraints(int &w, int &h)
+void QWidgetPrivate::adjustWithinMaxAndMinSize(int &w, int &h)
 {
     if (QWExtra *extra = extraData()) {
         w = qMin(w, extra->maxw);
@@ -4028,6 +4030,26 @@ void QWidgetPrivate::applyMaxAndMinSizeConstraints(int &w, int &h)
     }
 }
 
+void QWidgetPrivate::applyMaxAndMinSizeOnWindow()
+{
+    Q_Q(QWidget);
+    const float max_f(20000);
+#ifndef QT_MAC_USE_COCOA
+#define SF(x) ((x > max_f) ? max_f : x)
+    HISize max = CGSizeMake(SF(extra->maxw), SF(extra->maxh));
+    HISize min = CGSizeMake(SF(extra->minw), SF(extra->minh));
+#undef SF
+    SetWindowResizeLimits(qt_mac_window_for(q), &min, &max);
+#else
+#define SF(x) ((x > max_f) ? max_f : x)
+    NSSize max = NSMakeSize(SF(extra->maxw), SF(extra->maxh));
+    NSSize min = NSMakeSize(SF(extra->minw), SF(extra->minh));
+#undef SF
+    [qt_mac_window_for(q) setMinSize:min];
+    [qt_mac_window_for(q) setMaxSize:max];
+#endif
+}
+
 void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
 {
     Q_Q(QWidget);
@@ -4039,17 +4061,18 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
     QMacCocoaAutoReleasePool pool;
     bool realWindow = isRealWindow();
 
-    if (realWindow && !q->testAttribute(Qt::WA_DontShowOnScreen)
+    if (realWindow && !q->testAttribute(Qt::WA_DontShowOnScreen)){
+        adjustWithinMaxAndMinSize(w, h);
 #ifndef QT_MAC_USE_COCOA
-            && !(w == 0 && h == 0)
-#endif
-       ){
-        applyMaxAndMinSizeConstraints(w, h);
-        topData()->isSetGeometry = 1;
-        topData()->isMove = isMove;
-#ifndef QT_MAC_USE_COCOA
-        Rect r; SetRect(&r, x, y, x + w, y + h);
-        SetWindowBounds(qt_mac_window_for(q), kWindowContentRgn, &r);
+        if (w != 0 && h != 0) {
+            topData()->isSetGeometry = 1;
+            topData()->isMove = isMove;
+            Rect r; SetRect(&r, x, y, x + w, y + h);
+            SetWindowBounds(qt_mac_window_for(q), kWindowContentRgn, &r);
+            topData()->isSetGeometry = 0;
+        } else {
+            setGeometry_sys_helper(x, y, w, h, isMove);
+        }
 #else
         NSWindow *window = qt_mac_window_for(q);
         const QRect &fStrut = frameStrut();
@@ -4077,7 +4100,6 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
             [window setFrameOrigin:cocoaFrameRect.origin];
         }
 #endif
-        topData()->isSetGeometry = 0;
     } else {
         setGeometry_sys_helper(x, y, w, h, isMove);
     }
@@ -4102,40 +4124,19 @@ void QWidgetPrivate::setGeometry_sys_helper(int x, int y, int w, int h, bool isM
     data.crect = QRect(x, y, w, h);
 
     if (realWindow) {
-        if (QWExtra *extra = extraData()) {
-            applyMaxAndMinSizeConstraints(w, h);
-            qt_mac_update_sizer(q);
+        adjustWithinMaxAndMinSize(w, h);
+        qt_mac_update_sizer(q);
 
-            if (q->windowFlags() & Qt::WindowMaximizeButtonHint) {
 #ifndef QT_MAC_USE_COCOA
-                OSWindowRef window = qt_mac_window_for(q);
-                if(extra->maxw && extra->maxh && extra->maxw == extra->minw
-                        && extra->maxh == extra->minh) {
-                    ChangeWindowAttributes(window, kWindowNoAttributes, kWindowFullZoomAttribute);
-                } else {
-                    ChangeWindowAttributes(window, kWindowFullZoomAttribute, kWindowNoAttributes);
-                }
-#endif
+        if (q->windowFlags() & Qt::WindowMaximizeButtonHint) {
+            OSWindowRef window = qt_mac_window_for(q);
+            if (extra->maxw && extra->maxh && extra->maxw == extra->minw
+                    && extra->maxh == extra->minh) {
+                ChangeWindowAttributes(window, kWindowNoAttributes, kWindowFullZoomAttribute);
+            } else {
+                ChangeWindowAttributes(window, kWindowFullZoomAttribute, kWindowNoAttributes);
             }
-
-            // Update max and min constraints:
-            const float max_f(20000);
-#ifndef QT_MAC_USE_COCOA
-#define SF(x) ((x > max_f) ? max_f : x)
-            HISize max = CGSizeMake(SF(extra->maxw), SF(extra->maxh));
-            HISize min = CGSizeMake(SF(extra->minw), SF(extra->minh));
-#undef SF
-            SetWindowResizeLimits(qt_mac_window_for(q), &min, &max);
-#else
-#define SF(x) ((x > max_f) ? max_f : x)
-            NSSize max = NSMakeSize(SF(extra->maxw), SF(extra->maxh));
-            NSSize min = NSMakeSize(SF(extra->minw), SF(extra->minh));
-#undef SF
-            [qt_mac_window_for(q) setMinSize:min];
-            [qt_mac_window_for(q) setMaxSize:max];
-#endif
         }
-#ifndef QT_MAC_USE_COCOA
         HIRect bounds = CGRectMake(0, 0, w, h);
         HIViewSetFrame(qt_mac_nativeview_for(q), &bounds);
 #else
@@ -4181,6 +4182,7 @@ void QWidgetPrivate::setGeometry_sys_helper(int x, int y, int w, int h, bool isM
 void QWidgetPrivate::setConstraints_sys()
 {
     updateMaximizeButton_sys();
+    applyMaxAndMinSizeOnWindow();
 }
 
 void QWidgetPrivate::updateMaximizeButton_sys()
diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h
index db78682..2461820 100644
--- a/src/gui/kernel/qwidget_p.h
+++ b/src/gui/kernel/qwidget_p.h
@@ -257,7 +257,8 @@ public:
     void macUpdateIsOpaque();
     void setEnabled_helper_sys(bool enable);
     bool isRealWindow() const;
-    void applyMaxAndMinSizeConstraints(int &w, int &h);
+    void adjustWithinMaxAndMinSize(int &w, int &h);
+    void applyMaxAndMinSizeOnWindow();
 #endif
 
     void raise_sys();
diff --git a/src/gui/painting/qblendfunctions.cpp b/src/gui/painting/qblendfunctions.cpp
index dd7b016..93f11e1 100644
--- a/src/gui/painting/qblendfunctions.cpp
+++ b/src/gui/painting/qblendfunctions.cpp
@@ -44,8 +44,6 @@
 
 QT_BEGIN_NAMESPACE
 
-static const qreal aliasedCoordinateDelta = 0.5 - 0.015625;
-
 struct SourceOnlyAlpha
 {
     inline uchar alpha(uchar src) const { return src; }
@@ -140,14 +138,11 @@ struct Blend_ARGB32_on_RGB16_SourceAndConstAlpha {
 template <typename SRC, typename T>
 void qt_scale_image_16bit(uchar *destPixels, int dbpl,
                           const uchar *srcPixels, int sbpl,
-                          const QRectF &target,
+                          const QRectF &targetRect,
                           const QRectF &srcRect,
                           const QRect &clip,
                           T blender)
 {
-    const QRectF targetRect = target.translated(aliasedCoordinateDelta,
-                                                aliasedCoordinateDelta);
-
     qreal sx = targetRect.width() / (qreal) srcRect.width();
     qreal sy = targetRect.height() / (qreal) srcRect.height();
 
@@ -618,14 +613,11 @@ struct Blend_ARGB32_on_ARGB32_SourceAndConstAlpha {
 
 template <typename T> void qt_scale_image_32bit(uchar *destPixels, int dbpl,
                                                 const uchar *srcPixels, int sbpl,
-                                                const QRectF &target,
+                                                const QRectF &targetRect,
                                                 const QRectF &srcRect,
                                                 const QRect &clip,
                                                 T blender)
 {
-    const QRectF targetRect = target.translated(aliasedCoordinateDelta,
-                                                aliasedCoordinateDelta);
-
     qreal sx = targetRect.width() / (qreal) srcRect.width();
     qreal sy = targetRect.height() / (qreal) srcRect.height();
 
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 788b722..cbfd5e3 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -2573,7 +2573,11 @@ void QRasterPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRe
     QRasterPaintEngineState *s = state();
     const bool aa = s->flags.antialiased || s->flags.bilinear;
     if (!aa && sr.size() == QSize(1, 1)) {
-        fillRect(r, QColor::fromRgba(img.pixel(sr.x(), sr.y())));
+        // as fillRect will apply the aliased coordinate delta we need to
+        // subtract it here as we don't use it for image drawing
+        const QRectF targetRect = r.translated(-aliasedCoordinateDelta,
+                                               -aliasedCoordinateDelta);
+        fillRect(targetRect, QColor::fromRgba(img.pixel(sr.x(), sr.y())));
         return;
     }
 
diff --git a/src/gui/text/qtextformat.h b/src/gui/text/qtextformat.h
index 0571d75..8eaeeb1 100644
--- a/src/gui/text/qtextformat.h
+++ b/src/gui/text/qtextformat.h
@@ -232,6 +232,12 @@ public:
         ImageWidth = 0x5010,
         ImageHeight = 0x5011,
 
+        // internal
+        /*
+           SuppressText = 0x5012,
+           SuppressBackground = 0x513
+        */
+
         // selection properties
         FullWidthSelection = 0x06000,
 
diff --git a/src/gui/text/qtextlayout.cpp b/src/gui/text/qtextlayout.cpp
index 434d1ca..fa624ef 100644
--- a/src/gui/text/qtextlayout.cpp
+++ b/src/gui/text/qtextlayout.cpp
@@ -61,6 +61,8 @@
 QT_BEGIN_NAMESPACE
 
 #define ObjectSelectionBrush (QTextFormat::ForegroundBrush + 1)
+#define SuppressText 0x5012
+#define SuppressBackground 0x513
 
 static inline QFixed leadingSpaceWidth(QTextEngine *eng, const QScriptLine &line)
 {
@@ -1143,6 +1145,7 @@ void QTextLayout::draw(QPainter *p, const QPointF &pos, const QVector<FormatRang
     }
 
     QPainterPath excludedRegion;
+    QPainterPath textDoneRegion;
     for (int i = 0; i < selections.size(); ++i) {
         FormatRange selection = selections.at(i);
         const QBrush bg = selection.format.background();
@@ -1202,23 +1205,55 @@ void QTextLayout::draw(QPainter *p, const QPointF &pos, const QVector<FormatRang
         }
 
 
+
+        bool hasText = (selection.format.foreground().style() != Qt::NoBrush);
+        bool hasBackground= (selection.format.background().style() != Qt::NoBrush);
+        
+        if (hasBackground) {
+            selection.format.setProperty(ObjectSelectionBrush, selection.format.property(QTextFormat::BackgroundBrush));
+            // don't just clear the property, set an empty brush that overrides a potential
+            // background brush specified in the text
+            selection.format.setProperty(QTextFormat::BackgroundBrush, QBrush());
+            selection.format.clearProperty(QTextFormat::OutlinePen);
+        }
+
+        selection.format.setProperty(SuppressText, !hasText);
+
+        if (hasText && !hasBackground && !(textDoneRegion & region).isEmpty())
+            continue;
+
         p->save();
         p->setClipPath(region, Qt::IntersectClip);
 
-        selection.format.setProperty(ObjectSelectionBrush, selection.format.property(QTextFormat::BackgroundBrush));
-        // don't just clear the property, set an empty brush that overrides a potential
-        // background brush specified in the text
-        selection.format.setProperty(QTextFormat::BackgroundBrush, QBrush());
-        selection.format.clearProperty(QTextFormat::OutlinePen);
-
         for (int line = firstLine; line < lastLine; ++line) {
             QTextLine l(line, d);
             l.draw(p, position, &selection);
         }
         p->restore();
 
-        if (selection.format.foreground().style() != Qt::NoBrush) // i.e. we have drawn text
-            excludedRegion += region;
+        if (hasText) {
+            textDoneRegion += region;
+        } else {
+            if (hasBackground)
+                textDoneRegion -= region;
+        }
+
+        excludedRegion += region;
+    }
+
+    QPainterPath needsTextButNoBackground = excludedRegion - textDoneRegion;
+    if (!needsTextButNoBackground.isEmpty()){
+        p->save();
+        p->setClipPath(needsTextButNoBackground, Qt::IntersectClip);
+        FormatRange selection;
+        selection.start = 0;
+        selection.length = INT_MAX;
+        selection.format.setProperty(SuppressBackground, true);
+        for (int line = firstLine; line < lastLine; ++line) {
+            QTextLine l(line, d);
+            l.draw(p, position, &selection);
+        }
+        p->restore();
     }
 
     if (!excludedRegion.isEmpty()) {
@@ -1912,14 +1947,17 @@ static void drawMenuText(QPainter *p, QFixed x, QFixed y, const QScriptItem &si,
 static void setPenAndDrawBackground(QPainter *p, const QPen &defaultPen, const QTextCharFormat &chf, const QRectF &r)
 {
     QBrush c = chf.foreground();
-    if (c.style() == Qt::NoBrush)
+    if (c.style() == Qt::NoBrush) {
         p->setPen(defaultPen);
+    }
 
     QBrush bg = chf.background();
-    if (bg.style() != Qt::NoBrush)
+    if (bg.style() != Qt::NoBrush && !chf.property(SuppressBackground).toBool())
         p->fillRect(r, bg);
-    if (c.style() != Qt::NoBrush)
+    if (c.style() != Qt::NoBrush) {
         p->setPen(QPen(c, 0));
+    }
+
 }
 
 /*!
@@ -1933,7 +1971,7 @@ void QTextLine::draw(QPainter *p, const QPointF &pos, const QTextLayout::FormatR
     const QScriptLine &line = eng->lines[i];
     QPen pen = p->pen();
 
-    bool noText = (selection && selection->format.foreground().style() == Qt::NoBrush);
+    bool noText = (selection && selection->format.property(SuppressText).toBool());
 
     if (!line.length) {
         if (selection
diff --git a/src/gui/widgets/qplaintextedit.cpp b/src/gui/widgets/qplaintextedit.cpp
index 2e9201d..e563fa1 100644
--- a/src/gui/widgets/qplaintextedit.cpp
+++ b/src/gui/widgets/qplaintextedit.cpp
@@ -624,7 +624,7 @@ void QPlainTextEditPrivate::setTopBlock(int blockNumber, int lineNumber, int dx)
 
     if (viewport->updatesEnabled() && viewport->isVisible()) {
         int dy = 0;
-        if (doc->findBlockByLineNumber(control->topBlock).isValid()) {
+        if (doc->findBlockByNumber(control->topBlock).isValid()) {
             dy = (int)(-q->blockBoundingGeometry(block).y())
                  + verticalOffset() - verticalOffset(blockNumber, lineNumber);
         }
diff --git a/src/plugins/gfxdrivers/directfb/directfb.pro b/src/plugins/gfxdrivers/directfb/directfb.pro
index abdb78f..5c60b2f 100644
--- a/src/plugins/gfxdrivers/directfb/directfb.pro
+++ b/src/plugins/gfxdrivers/directfb/directfb.pro
@@ -6,6 +6,7 @@ QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/gfxdrivers
 # These defines might be necessary if your DirectFB driver doesn't
 # support all of the DirectFB API.
 #
+#DEFINES += QT_DIRECTFB_IMAGECACHE
 #DEFINES += QT_NO_DIRECTFB_WM
 #DEFINES += QT_NO_DIRECTFB_LAYER
 #DEFINES += QT_NO_DIRECTFB_PALETTE
@@ -40,4 +41,4 @@ SOURCES = qdirectfbscreen.cpp \
 
 QMAKE_CXXFLAGS += $$QT_CFLAGS_DIRECTFB
 LIBS += $$QT_LIBS_DIRECTFB
-
+DEFINES += $$QT_DEFINES_DIRECTFB
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
index 9796280..72e0ce5 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
@@ -58,18 +58,18 @@ IDirectFBSurface *QDirectFBPaintDevice::directFBSurface() const
 
 void QDirectFBPaintDevice::lockDirectFB(uint flags)
 {
-    if (lockedImage) {
-        if (lockFlags & flags)
-            return;
-        unlockDirectFB();
-    }
-    if (uchar *mem = QDirectFBScreen::lockSurface(dfbSurface, flags, &bpl)) {
-        const QSize s = size();
-        lockedImage = new QImage(mem, s.width(), s.height(), bpl,
-                                 QDirectFBScreen::getImageFormat(dfbSurface));
-        lockFlags = flags;
-    } else {
-        lockFlags = 0;
+    if (!(lock & flags)) {
+        if (lock)
+            unlockDirectFB();
+        if ((mem = QDirectFBScreen::lockSurface(dfbSurface, flags, &bpl))) {
+            const QSize s = size();
+            lockedImage = new QImage(mem, s.width(), s.height(), bpl,
+                                     QDirectFBScreen::getImageFormat(dfbSurface));
+            lock = flags;
+            Q_ASSERT(mem);
+        } else {
+            lock = 0;
+        }
     }
 }
 
@@ -82,15 +82,19 @@ void QDirectFBPaintDevice::unlockDirectFB()
     dfbSurface->Unlock(dfbSurface);
     delete lockedImage;
     lockedImage = 0;
+    mem = 0;
+    lock = 0;
 }
 
 
 void *QDirectFBPaintDevice::memory() const
 {
-    QDirectFBPaintDevice* that = const_cast<QDirectFBPaintDevice*>(this);
-    that->lockDirectFB(DSLF_READ|DSLF_WRITE);
-    Q_ASSERT(that->lockedImage);
-    return that->lockedImage->bits();
+    if (lock != (DSLF_READ|DSLF_WRITE)) {
+        QDirectFBPaintDevice *that = const_cast<QDirectFBPaintDevice*>(this);
+        that->lockDirectFB(DSLF_READ|DSLF_WRITE);
+        Q_ASSERT(that->lockedImage);
+    }
+    return mem;
 }
 
 
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.h b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.h
index 1709d69..13f0a8f 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.h
@@ -69,6 +69,7 @@ public:
     int bytesPerLine() const;
     QSize size() const;
     int metric(QPaintDevice::PaintDeviceMetric metric) const;
+    uint lockFlags() const { return lock; }
 protected:
     // Shouldn't create QDirectFBPaintDevice by itself but only sub-class it:
     QDirectFBPaintDevice(QDirectFBScreen *scr = QDirectFBScreen::instance())
@@ -77,7 +78,8 @@ protected:
           lockedImage(0),
           screen(scr),
           forceRaster(false),
-          lockFlags(0)
+          lock(0),
+          mem(0)
     {}
 
     inline int dotsPerMeterX() const
@@ -94,7 +96,8 @@ protected:
     QDirectFBScreen *screen;
     int bpl;
     bool forceRaster;
-    uint lockFlags;
+    uint lock;
+    uchar *mem;
 private:
     Q_DISABLE_COPY(QDirectFBPaintDevice)
 };
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
index 92f717e..6d8f617 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
@@ -80,7 +80,7 @@ template <typename T> inline const T *ptr(const T &t) { return &t; }
 template <> inline const bool* ptr<bool>(const bool &) { return 0; }
 template <typename device, typename T1, typename T2, typename T3>
 static void rasterFallbackWarn(const char *msg, const char *func, const device *dev,
-                               bool matrixScale, bool matrixRotShear, bool simplePen,
+                               QDirectFBPaintEnginePrivate::Scale scale, bool matrixRotShear, bool simplePen,
                                bool dfbHandledClip, bool forceRasterPrimitives,
                                const char *nameOne, const T1 &one,
                                const char *nameTwo, const T2 &two,
@@ -95,7 +95,7 @@ static void rasterFallbackWarn(const char *msg, const char *func, const device *
         dbg << dev << "of type" << dev->devType();
     }
 
-    dbg << "matrixScale" << matrixScale
+    dbg << "scale" << scale
         << "matrixRotShear" << matrixRotShear
         << "simplePen" << simplePen
         << "dfbHandledClip" << dfbHandledClip
@@ -123,7 +123,7 @@ static void rasterFallbackWarn(const char *msg, const char *func, const device *
     if (op & (QT_DIRECTFB_WARN_ON_RASTERFALLBACKS))                     \
         rasterFallbackWarn("Disabled raster engine operation",          \
                            __FUNCTION__, state()->painter->device(),    \
-                           d_func()->matrixScale, d_func()->matrixRotShear, \
+                           d_func()->scale, d_func()->matrixRotShear, \
                            d_func()->simplePen, d_func()->dfbCanHandleClip(), \
                            d_func()->forceRasterPrimitives,             \
                            #one, one, #two, two, #three, three);        \
@@ -138,7 +138,7 @@ static void rasterFallbackWarn(const char *msg, const char *func, const device *
     if (op & (QT_DIRECTFB_WARN_ON_RASTERFALLBACKS))                     \
         rasterFallbackWarn("Falling back to raster engine for",         \
                            __FUNCTION__, state()->painter->device(),    \
-                           d_func()->matrixScale, d_func()->matrixRotShear, \
+                           d_func()->scale, d_func()->matrixRotShear, \
                            d_func()->simplePen, d_func()->dfbCanHandleClip(), \
                            d_func()->forceRasterPrimitives,             \
                            #one, one, #two, two, #three, three);
@@ -156,110 +156,57 @@ static inline uint ALPHA_MUL(uint x, uint a)
 class SurfaceCache
 {
 public:
-    SurfaceCache();
-    ~SurfaceCache();
+    SurfaceCache() : surface(0), buffer(0), bufsize(0) {}
+    ~SurfaceCache() { clear(); }
 
-    inline IDirectFBSurface *getSurface(const uint *buffer, int size);
-    inline void clear();
 
-private:
-    IDirectFBSurface *surface;
-    uint *buffer;
-    int bufsize;
-};
-
-SurfaceCache::SurfaceCache()
-    : surface(0), buffer(0), bufsize(0)
-{
-}
+    IDirectFBSurface *getSurface(const uint *buf, int size)
+    {
+        if (buffer == buf && bufsize == size)
+            return surface;
 
-class CachedImage
-{
-public:
-    CachedImage(const QImage &image);
-    ~CachedImage();
+        clear();
 
-    IDirectFBSurface *surface() { return s; }
+        const DFBSurfaceDescription description = QDirectFBScreen::getSurfaceDescription(buf, size);
+        surface = QDirectFBScreen::instance()->createDFBSurface(description, QDirectFBScreen::TrackSurface);
+        if (!surface)
+            qWarning("QDirectFBPaintEngine: SurfaceCache: Unable to create surface");
 
-private:
-    IDirectFBSurface *s;
-};
-
-CachedImage::CachedImage(const QImage &image)
-    : s(0)
-{
-    IDirectFBSurface *tmpSurface = 0;
-    DFBSurfaceDescription description = QDirectFBScreen::getSurfaceDescription(image);
-    QDirectFBScreen* screen = QDirectFBScreen::instance();
+        buffer = const_cast<uint*>(buf);
+        bufsize = size;
 
-    tmpSurface = screen->createDFBSurface(description, QDirectFBScreen::TrackSurface);
-    if (!tmpSurface) {
-        qWarning("CachedImage CreateSurface failed!");
-        return;
+        return surface;
     }
 
-#ifndef QT_NO_DIRECTFB_PALETTE
-    QDirectFBScreen::setSurfaceColorTable(tmpSurface, image);
-#endif
-
-    description.flags = DFBSurfaceDescriptionFlags(description.flags & ~DSDESC_PREALLOCATED);
-
-    s = screen->createDFBSurface(description, QDirectFBScreen::TrackSurface);
-    if (!s)
-        qWarning("QDirectFBPaintEngine failed caching image");
-
-#ifndef QT_NO_DIRECTFB_PALETTE
-    QDirectFBScreen::setSurfaceColorTable(s, image);
-#endif
-
-    if (s) {
-        s->SetBlittingFlags(s, DSBLIT_NOFX);
-        s->Blit(s, tmpSurface, 0, 0, 0);
-        s->ReleaseSource(s);
+    void clear()
+    {
+        if (surface && QDirectFBScreen::instance())
+            QDirectFBScreen::instance()->releaseDFBSurface(surface);
+        surface = 0;
+        buffer = 0;
+        bufsize = 0;
     }
-    if (tmpSurface)
-        screen->releaseDFBSurface(tmpSurface);
-}
-
-CachedImage::~CachedImage()
-{
-    if (s && QDirectFBScreen::instance())
-        QDirectFBScreen::instance()->releaseDFBSurface(s);
-}
-
-static QCache<qint64, CachedImage> imageCache(4*1024*1024); // 4 MB
-
-IDirectFBSurface* SurfaceCache::getSurface(const uint *buf, int size)
-{
-    if (buffer == buf && bufsize == size)
-        return surface;
-
-    clear();
-
-    const DFBSurfaceDescription description = QDirectFBScreen::getSurfaceDescription(buf, size);
-    surface = QDirectFBScreen::instance()->createDFBSurface(description, QDirectFBScreen::TrackSurface);
-    if (!surface)
-        qWarning("QDirectFBPaintEngine: SurfaceCache: Unable to create surface");
-
-    buffer = const_cast<uint*>(buf);
-    bufsize = size;
-
-    return surface;
-}
+private:
+    IDirectFBSurface *surface;
+    uint *buffer;
+    int bufsize;
+};
 
-void SurfaceCache::clear()
-{
-    if (surface)
-        QDirectFBScreen::instance()->releaseDFBSurface(surface);
-    surface = 0;
-    buffer = 0;
-    bufsize = 0;
-}
 
-SurfaceCache::~SurfaceCache()
+#ifdef QT_DIRECTFB_IMAGECACHE
+#include <private/qimage_p.h>
+struct CachedImage
 {
-    clear();
-}
+    IDirectFBSurface *surface;
+    ~CachedImage()
+    {
+        if (surface && QDirectFBScreen::instance()) {
+            QDirectFBScreen::instance()->releaseDFBSurface(surface);
+        }
+    }
+};
+static QCache<qint64, CachedImage> imageCache(4*1024*1024); // 4 MB
+#endif
 
 class QDirectFBPaintEnginePrivate : public QRasterPaintEnginePrivate
 {
@@ -267,18 +214,6 @@ public:
     QDirectFBPaintEnginePrivate(QDirectFBPaintEngine *p);
     ~QDirectFBPaintEnginePrivate();
 
-    IDirectFBSurface *surface;
-
-    QPen pen;
-
-    bool antialiased;
-    bool forceRasterPrimitives;
-
-    bool simplePen;
-
-    bool matrixRotShear;
-    bool matrixScale;
-
     void setTransform(const QTransform &m);
     void setPen(const QPen &pen);
     void setCompositionMode(QPainter::CompositionMode mode);
@@ -304,24 +239,39 @@ public:
     void fillRects(const QRectF *rects, int count);
     void drawRects(const QRectF *rects, int count);
 
-
-    void drawPixmap(const QRectF &dest,
-                    const QPixmap &pixmap, const QRectF &src);
     void drawTiledPixmap(const QRectF &dest, const QPixmap &pixmap);
-    void drawImage(const QRectF &dest, const QImage &image, const QRectF &src);
+    void blit(const QRectF &dest, IDirectFBSurface *surface, const QRectF &src);
 
     inline void updateClip();
-    inline void setClipDirty();
     void systemStateChanged();
 
     void begin(QPaintDevice *device);
     void end();
 
+    static IDirectFBSurface *getSurface(const QImage &img, bool *release);
+
+#ifdef QT_DIRECTFB_IMAGECACHE
+    static inline int cacheCost(const QImage &img) { return img.width() * img.height() * img.depth() / 8; }
+#endif
+
     void prepareForBlit(bool alpha);
+private:
+    IDirectFBSurface *surface;
+
+    QPen pen;
+
+    bool antialiased;
+    bool forceRasterPrimitives;
+
+    bool simplePen;
+
+    bool matrixRotShear;
+    enum Scale { NoScale, Scaled, NegativeScale } scale;
+
     SurfaceCache *surfaceCache;
     QTransform transform;
     int lastLockedHeight;
-private:
+
     IDirectFB *fb;
     DFBSurfaceDescription fbDescription;
     int fbWidth;
@@ -336,469 +286,12 @@ private:
     bool dfbHandledClip;
     bool ignoreSystemClip;
     QDirectFBPaintDevice *dfbDevice;
+    void *lockedMemory;
 
     QDirectFBPaintEngine *q;
+    friend class QDirectFBPaintEngine;
 };
 
-QDirectFBPaintEnginePrivate::QDirectFBPaintEnginePrivate(QDirectFBPaintEngine *p)
-    : surface(0), antialiased(false), forceRasterPrimitives(false), simplePen(false),
-      matrixRotShear(false), matrixScale(false), lastLockedHeight(-1),
-      fbWidth(-1), fbHeight(-1), opacity(255), drawFlagsFromCompositionMode(0),
-      blitFlagsFromCompositionMode(0), porterDuffRule(DSPD_SRC_OVER), dirtyClip(true),
-      dfbHandledClip(false), dfbDevice(0), q(p)
-{
-    fb = QDirectFBScreen::instance()->dfb();
-    ignoreSystemClip = QDirectFBScreen::instance()->directFBFlags() & QDirectFBScreen::IgnoreSystemClip;
-    surfaceCache = new SurfaceCache;
-    static int cacheLimit = qgetenv("QT_DIRECTFB_IMAGECACHE").toInt();
-    if (cacheLimit > 0)
-        imageCache.setMaxCost(cacheLimit * 1024);
-}
-
-QDirectFBPaintEnginePrivate::~QDirectFBPaintEnginePrivate()
-{
-    delete surfaceCache;
-}
-
-bool QDirectFBPaintEnginePrivate::dfbCanHandleClip(const QRect &rect) const
-{
-    // TODO: Check to see if DirectFB can handle the clip for the given rect
-    return dfbHandledClip;
-}
-
-bool QDirectFBPaintEnginePrivate::dfbCanHandleClip(const QRectF &rect) const
-{
-    // TODO: Check to see if DirectFB can handle the clip for the given rect
-    return dfbHandledClip;
-}
-
-bool QDirectFBPaintEnginePrivate::dfbCanHandleClip() const
-{
-    return dfbHandledClip;
-}
-
-bool QDirectFBPaintEnginePrivate::isSimpleBrush(const QBrush &brush) const
-{
-    return (brush.style() == Qt::NoBrush) || (brush.style() == Qt::SolidPattern && !antialiased);
-}
-
-void QDirectFBPaintEnginePrivate::setClipDirty()
-{
-    dirtyClip = true;
-}
-
-void QDirectFBPaintEnginePrivate::lock()
-{
-    // We will potentially get a new pointer to the buffer after a
-    // lock so we need to call the base implementation of prepare so
-    // it updates its rasterBuffer to point to the new buffer address.
-    lastLockedHeight = dfbDevice->height();
-
-    Q_ASSERT(dfbDevice);
-    prepare(dfbDevice);
-}
-
-void QDirectFBPaintEnginePrivate::unlock()
-{
-    Q_ASSERT(dfbDevice);
-    dfbDevice->unlockDirectFB();
-}
-
-void QDirectFBPaintEnginePrivate::setTransform(const QTransform &m)
-{
-    transform = m;
-    matrixRotShear = (transform.m12() != 0 || transform.m21() != 0);
-    matrixScale = (transform.m11() != 1 || transform.m22() != 1);
-}
-
-void QDirectFBPaintEnginePrivate::begin(QPaintDevice *device)
-{
-    lastLockedHeight = -1;
-    if (device->devType() == QInternal::CustomRaster)
-        dfbDevice = static_cast<QDirectFBPaintDevice*>(device);
-    else if (device->devType() == QInternal::Pixmap) {
-        QPixmapData *data = static_cast<QPixmap*>(device)->pixmapData();
-        Q_ASSERT(data->classId() == QPixmapData::DirectFBClass);
-        QDirectFBPixmapData* dfbPixmapData = static_cast<QDirectFBPixmapData*>(data);
-        dfbDevice = static_cast<QDirectFBPaintDevice*>(dfbPixmapData);
-    }
-
-    if (dfbDevice)
-        surface = dfbDevice->directFBSurface();
-
-    if (!surface) {
-        qFatal("QDirectFBPaintEngine used on an invalid device: 0x%x",
-               device->devType());
-    }
-    forceRasterPrimitives = dfbDevice->forceRasterPrimitives();
-
-    surface->GetSize(surface, &fbWidth, &fbHeight);
-
-    setTransform(QTransform());
-    antialiased = false;
-    opacity = 255;
-    setCompositionMode(q->state()->compositionMode());
-    dirtyClip = true;
-    setPen(q->state()->pen);
-    setDFBColor(pen.color());
-}
-
-void QDirectFBPaintEnginePrivate::end()
-{
-    dfbDevice = 0;
-    surface->ReleaseSource(surface);
-    surface->SetClip(surface, NULL);
-    surface = 0;
-}
-
-void QDirectFBPaintEnginePrivate::setPen(const QPen &p)
-{
-    pen = p;
-    simplePen = (pen.style() == Qt::NoPen) ||
-                (pen.style() == Qt::SolidLine
-                 && !antialiased
-                 && (pen.brush().style() == Qt::SolidPattern)
-                 && (pen.widthF() <= 1 && !matrixScale));
-}
-
-void QDirectFBPaintEnginePrivate::setCompositionMode(QPainter::CompositionMode mode)
-{
-    blitFlagsFromCompositionMode = DSBLIT_NOFX;
-    drawFlagsFromCompositionMode = DSDRAW_NOFX;
-
-    bool blend = true;
-    switch (mode) {
-    case QPainter::CompositionMode_SourceOver:
-        porterDuffRule = DSPD_SRC_OVER;
-        break;
-    case QPainter::CompositionMode_DestinationOver:
-        porterDuffRule = DSPD_DST_OVER;
-        break;
-    case QPainter::CompositionMode_Clear:
-        porterDuffRule = DSPD_CLEAR;
-        blend = false;
-        break;
-    case QPainter::CompositionMode_Source:
-        porterDuffRule = DSPD_SRC;
-        blend = false;
-        break;
-    case QPainter::CompositionMode_Destination:
-        porterDuffRule = DSPD_NONE; // ### need to double check this
-        blend = false;
-        return;
-    case QPainter::CompositionMode_SourceIn:
-        porterDuffRule = DSPD_SRC_IN;
-        break;
-    case QPainter::CompositionMode_DestinationIn:
-        porterDuffRule = DSPD_DST_IN;
-        break;
-    case QPainter::CompositionMode_SourceOut:
-        porterDuffRule = DSPD_SRC_OUT;
-        break;
-    case QPainter::CompositionMode_DestinationOut:
-        porterDuffRule = DSPD_DST_OUT;
-        break;
-    case QPainter::CompositionMode_Xor:
-        porterDuffRule = DSPD_XOR;
-        blitFlagsFromCompositionMode |= DSBLIT_XOR;
-        drawFlagsFromCompositionMode |= DSDRAW_XOR;
-        break;
-//     case QPainter::CompositionMode_Plus: // ???
-//         porterDuffRule = DSPD_ADD;
-//         break;
-    default:
-        qWarning("QDirectFBPaintEnginePrivate::setCompositionMode(): "
-                 "mode %d not implemented", mode);
-        return;
-    }
-    // intentially not comparing with current porterDuffRule. surface might have changed.
-    if (blend) {
-        blitFlagsFromCompositionMode |= DSBLIT_BLEND_ALPHACHANNEL;
-        drawFlagsFromCompositionMode |= DSDRAW_BLEND;
-    }
-    if (opacity != 255) {
-        setOpacity(opacity);
-    }
-}
-
-void QDirectFBPaintEnginePrivate::setOpacity(quint8 op)
-{
-    opacity = op;
-    if (opacity == 255) {
-        blitFlagsFromCompositionMode &= ~DSBLIT_BLEND_COLORALPHA;
-    } else {
-        blitFlagsFromCompositionMode |= DSBLIT_BLEND_COLORALPHA;
-    }
-}
-
-void QDirectFBPaintEnginePrivate::setRenderHints(QPainter::RenderHints hints)
-{
-    const bool old = antialiased;
-    antialiased = bool(hints & QPainter::Antialiasing);
-    if (old != antialiased) {
-        setPen(q->state()->pen);
-    }
-}
-
-void QDirectFBPaintEnginePrivate::prepareForBlit(bool alpha)
-{
-    quint32 blittingFlags = blitFlagsFromCompositionMode;
-    if (alpha) {
-        surface->SetPorterDuff(surface,
-                               (blittingFlags & DSBLIT_BLEND_COLORALPHA)
-                               ? DSPD_NONE
-                               : porterDuffRule);
-    } else {
-        blittingFlags &= ~DSBLIT_BLEND_ALPHACHANNEL;
-        surface->SetPorterDuff(surface, DSPD_NONE);
-    }
-    surface->SetColor(surface, 0xff, 0xff, 0xff, opacity);
-    surface->SetBlittingFlags(surface, DFBSurfaceBlittingFlags(blittingFlags));
-}
-
-void QDirectFBPaintEnginePrivate::setDFBColor(const QColor &color)
-{
-    Q_ASSERT(surface);
-    const quint8 alpha = (opacity == 255 ?
-                          color.alpha() : ALPHA_MUL(color.alpha(), opacity));
-    surface->SetColor(surface,
-                      color.red(), color.green(), color.blue(), alpha);
-    quint32 drawingFlags = drawFlagsFromCompositionMode;
-    if (alpha == 255) {
-        drawingFlags &= ~DSDRAW_BLEND;
-    }
-    surface->SetPorterDuff(surface, DSPD_NONE);
-    // PorterDuff messes up alpha values for primitives
-    surface->SetDrawingFlags(surface, DFBSurfaceDrawingFlags(drawingFlags));
-}
-
-void QDirectFBPaintEnginePrivate::drawLines(const QLine *lines, int n)
-{
-    for (int i = 0; i < n; ++i) {
-        const QLine l = transform.map(lines[i]);
-        surface->DrawLine(surface, l.x1(), l.y1(), l.x2(), l.y2());
-    }
-}
-
-void QDirectFBPaintEnginePrivate::drawLines(const QLineF *lines, int n)
-{
-    for (int i = 0; i < n; ++i) {
-        const QLine l = transform.map(lines[i]).toLine();
-        surface->DrawLine(surface, l.x1(), l.y1(), l.x2(), l.y2());
-    }
-}
-
-void QDirectFBPaintEnginePrivate::fillRegion(const QRegion &region)
-{
-    Q_ASSERT(isSimpleBrush(q->state()->brush));
-    setDFBColor(q->state()->brush.color());
-    const QVector<QRect> rects = region.rects();
-    const int n = rects.size();
-    fillRects(rects.constData(), n);
-}
-
-void QDirectFBPaintEnginePrivate::fillRects(const QRect *rects, int n)
-{
-    for (int i = 0; i < n; ++i) {
-        const QRect r = transform.mapRect(rects[i]);
-        surface->FillRectangle(surface, r.x(), r.y(),
-                               r.width(), r.height());
-    }
-}
-
-void QDirectFBPaintEnginePrivate::fillRects(const QRectF *rects, int n)
-{
-    for (int i = 0; i < n; ++i) {
-        const QRect r = transform.mapRect(rects[i]).toRect();
-        surface->FillRectangle(surface, r.x(), r.y(),
-                               r.width(), r.height());
-    }
-}
-
-void QDirectFBPaintEnginePrivate::drawRects(const QRect *rects, int n)
-{
-    for (int i = 0; i < n; ++i) {
-        const QRect r = transform.mapRect(rects[i]);
-        surface->DrawRectangle(surface, r.x(), r.y(),
-                               r.width() + 1, r.height() + 1);
-    }
-}
-
-void QDirectFBPaintEnginePrivate::drawRects(const QRectF *rects, int n)
-{
-    for (int i = 0; i < n; ++i) {
-        const QRect r = transform.mapRect(rects[i]).toRect();
-        surface->DrawRectangle(surface, r.x(), r.y(),
-                               r.width() + 1, r.height() + 1);
-    }
-}
-
-void QDirectFBPaintEnginePrivate::drawPixmap(const QRectF &dest,
-                                             const QPixmap &pixmap,
-                                             const QRectF &src)
-{
-    prepareForBlit(pixmap.hasAlphaChannel());
-    QPixmapData *data = pixmap.pixmapData();
-    Q_ASSERT(data->classId() == QPixmapData::DirectFBClass);
-    QDirectFBPixmapData *dfbData = static_cast<QDirectFBPixmapData*>(data);
-    IDirectFBSurface *s = dfbData->directFBSurface();
-    const QRect sr = src.toRect();
-    const QRect dr = transform.mapRect(dest).toRect();
-    const DFBRectangle sRect = { sr.x(), sr.y(), sr.width(), sr.height() };
-    DFBResult result;
-
-    if (dr.size() == sr.size()) {
-        result = surface->Blit(surface, s, &sRect, dr.x(), dr.y());
-    } else {
-        const DFBRectangle dRect = { dr.x(), dr.y(), dr.width(), dr.height() };
-        result = surface->StretchBlit(surface, s, &sRect, &dRect);
-    }
-    if (result != DFB_OK)
-        DirectFBError("QDirectFBPaintEngine::drawPixmap()", result);
-}
-
-void QDirectFBPaintEnginePrivate::drawTiledPixmap(const QRectF &dest,
-                                                  const QPixmap &pixmap)
-{
-    prepareForBlit(pixmap.hasAlphaChannel());
-    QPixmapData *data = pixmap.pixmapData();
-    Q_ASSERT(data->classId() == QPixmapData::DirectFBClass);
-    QDirectFBPixmapData *dfbData = static_cast<QDirectFBPixmapData*>(data);
-    IDirectFBSurface *s = dfbData->directFBSurface();
-    const QRect dr = transform.mapRect(dest).toRect();
-    DFBResult result = DFB_OK;
-
-    if (!matrixScale && dr == QRect(0, 0, fbWidth, fbHeight)) {
-        result = surface->TileBlit(surface, s, 0, 0, 0);
-    } else if (!matrixScale) {
-        const int dx = pixmap.width();
-        const int dy = pixmap.height();
-        const DFBRectangle rect = { 0, 0, dx, dy };
-        QVarLengthArray<DFBRectangle> rects;
-        QVarLengthArray<DFBPoint> points;
-
-        for (int y = dr.y(); y <= dr.bottom(); y += dy) {
-            for (int x = dr.x(); x <= dr.right(); x += dx) {
-                rects.append(rect);
-                const DFBPoint point = { x, y };
-                points.append(point);
-            }
-        }
-        result = surface->BatchBlit(surface, s, rects.constData(),
-                                    points.constData(), points.size());
-    } else {
-        const QRect sr = transform.mapRect(QRect(0, 0, pixmap.width(), pixmap.height()));
-        const int dx = sr.width();
-        const int dy = sr.height();
-        const DFBRectangle sRect = { 0, 0, dx, dy };
-
-        for (int y = dr.y(); y <= dr.bottom(); y += dy) {
-            for (int x = dr.x(); x <= dr.right(); x += dx) {
-                const DFBRectangle dRect = { x, y, dx, dy };
-                result = surface->StretchBlit(surface, s, &sRect, &dRect);
-                if (result != DFB_OK) {
-                    y = dr.bottom() + 1;
-                    break;
-                }
-            }
-        }
-    }
-
-    if (result != DFB_OK)
-        DirectFBError("QDirectFBPaintEngine::drawTiledPixmap()", result);
-}
-
-void QDirectFBPaintEnginePrivate::drawImage(const QRectF &dest,
-                                            const QImage &image,
-                                            const QRectF &src)
-{
-    Q_ASSERT(QDirectFBScreen::getSurfacePixelFormat(image.format()) != DSPF_UNKNOWN);
-    CachedImage *img = imageCache[image.cacheKey()];
-    IDirectFBSurface *imgSurface = 0;
-    bool doRelease = false;
-
-    if (img) {
-        imgSurface = img->surface();
-    } else {
-        const int cost = image.width() * image.height() * image.depth() / 8;
-        if (cost <= imageCache.maxCost()) {
-            img = new CachedImage(image);
-            imgSurface = img->surface();
-            if (imgSurface) {
-                imageCache.insert(image.cacheKey(), img, cost);
-            } else {
-                delete img;
-                img = 0;
-            }
-        }
-
-        if (!imgSurface) {
-            DFBSurfaceDescription description = QDirectFBScreen::getSurfaceDescription(image);
-            imgSurface = QDirectFBScreen::instance()->createDFBSurface(description,
-                                                                       QDirectFBScreen::DontTrackSurface);
-            if (!imgSurface) {
-                qWarning("QDirectFBPaintEnginePrivate::drawImage");
-                return;
-            }
-
-#ifndef QT_NO_DIRECTFB_PALETTE
-            QDirectFBScreen::setSurfaceColorTable(surface, image);
-#endif
-            doRelease = (imgSurface != 0);
-        }
-    }
-
-    const QRect sr = src.toRect();
-    const QRect dr = transform.mapRect(dest).toRect();
-    const DFBRectangle sRect = { sr.x(), sr.y(), sr.width(), sr.height() };
-
-    prepareForBlit(image.hasAlphaChannel());
-    if (dr.size() == sr.size()) {
-        surface->Blit(surface, imgSurface, &sRect, dr.x(), dr.y());
-    } else {
-        const DFBRectangle dRect = { dr.x(), dr.y(),
-                                     dr.width(), dr.height() };
-        surface->StretchBlit(surface, imgSurface, &sRect, &dRect);
-    }
-    if (doRelease) {
-        surface->ReleaseSource(surface);
-        imgSurface->Release(imgSurface);
-    }
-}
-
-void QDirectFBPaintEnginePrivate::updateClip()
-{
-    if (!dirtyClip)
-        return;
-
-    const QClipData *clipData = clip();
-    if (!clipData || !clipData->enabled) {
-        surface->SetClip(surface, NULL);
-        dfbHandledClip = true;
-    } else if (clipData->hasRectClip) {
-        const DFBRegion r = {
-            clipData->clipRect.x(),
-            clipData->clipRect.y(),
-            clipData->clipRect.x() + clipData->clipRect.width(),
-            clipData->clipRect.y() + clipData->clipRect.height()
-        };
-        surface->SetClip(surface, &r);
-        dfbHandledClip = true;
-    } else if (clipData->hasRegionClip && ignoreSystemClip && clipData->clipRegion == systemClip) {
-        dfbHandledClip = true;
-    } else {
-        dfbHandledClip = false;
-    }
-
-    dirtyClip = false;
-}
-
-void QDirectFBPaintEnginePrivate::systemStateChanged()
-{
-    setClipDirty();
-    QRasterPaintEnginePrivate::systemStateChanged();
-}
-
 QDirectFBPaintEngine::QDirectFBPaintEngine(QPaintDevice *device)
     : QRasterPaintEngine(*(new QDirectFBPaintEnginePrivate(this)), device)
 {
@@ -827,12 +320,10 @@ bool QDirectFBPaintEngine::end()
     return QRasterPaintEngine::end();
 }
 
-
-
 void QDirectFBPaintEngine::clipEnabledChanged()
 {
     Q_D(QDirectFBPaintEngine);
-    d->setClipDirty();
+    d->dirtyClip = true;
     QRasterPaintEngine::clipEnabledChanged();
 }
 
@@ -868,9 +359,9 @@ void QDirectFBPaintEngine::renderHintsChanged()
 void QDirectFBPaintEngine::transformChanged()
 {
     Q_D(QDirectFBPaintEngine);
-    const bool old = d->matrixScale;
+    const QDirectFBPaintEnginePrivate::Scale old = d->scale;
     d->setTransform(state()->transform());
-    if (d->matrixScale != old) {
+    if (d->scale != old) {
         d->setPen(state()->pen);
     }
     QRasterPaintEngine::transformChanged();
@@ -880,7 +371,7 @@ void QDirectFBPaintEngine::setState(QPainterState *s)
 {
     Q_D(QDirectFBPaintEngine);
     QRasterPaintEngine::setState(s);
-    d->setClipDirty();
+    d->dirtyClip = true;
     d->setPen(state()->pen);
     d->setOpacity(quint8(state()->opacity * 255));
     d->setCompositionMode(state()->compositionMode());
@@ -890,7 +381,7 @@ void QDirectFBPaintEngine::setState(QPainterState *s)
 void QDirectFBPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
 {
     Q_D(QDirectFBPaintEngine);
-    d->setClipDirty();
+    d->dirtyClip = true;
     const QPoint bottom = d->transform.map(QPoint(0, path.controlPointRect().y2));
     if (bottom.y() >= d->lastLockedHeight)
         d->lock();
@@ -900,7 +391,7 @@ void QDirectFBPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
 void QDirectFBPaintEngine::clip(const QRect &rect, Qt::ClipOperation op)
 {
     Q_D(QDirectFBPaintEngine);
-    d->setClipDirty();
+    d->dirtyClip = true;
     if (d->clip() && !d->clip()->hasRectClip && d->clip()->enabled) {
         const QPoint bottom = d->transform.map(QPoint(0, rect.bottom()));
         if (bottom.y() >= d->lastLockedHeight)
@@ -1003,12 +494,36 @@ void QDirectFBPaintEngine::drawImage(const QRectF &r, const QImage &image,
                                      Qt::ImageConversionFlags flags)
 {
     Q_D(QDirectFBPaintEngine);
-    Q_UNUSED(flags); // XXX
+    Q_UNUSED(flags);
+
+    /*  This is hard to read. The way it works is like this:
+
+    - If you do not have support for preallocated surfaces and do not use an
+    image cache we always fall back to raster engine.
+
+    - If it's rotated/sheared/mirrored (negative scale) or we can't
+    clip it we fall back to raster engine.
+
+    - If we don't cache the image, but we do have support for
+    preallocated surfaces we fall back to the raster engine if the
+    image is in a format DirectFB can't handle.
+
+    - If we do cache the image but don't have support for preallocated
+    images and the cost of caching the image (bytes used) is higher
+    than the max image cache size we fall back to raster engine.
+    */
 
-#ifndef QT_NO_DIRECTFB_PREALLOCATED
     d->updateClip();
-    if (!d->dfbCanHandleClip(r) || d->matrixRotShear
-        || QDirectFBScreen::getSurfacePixelFormat(image.format()) == DSPF_UNKNOWN)
+#if !defined QT_NO_DIRECTFB_PREALLOCATED || defined QT_DIRECTFB_IMAGECACHE
+    if (d->matrixRotShear
+        || d->scale == QDirectFBPaintEnginePrivate::NegativeScale
+        || !d->dfbCanHandleClip(r)
+#ifndef QT_DIRECTFB_IMAGECACHE
+        || QDirectFBScreen::getSurfacePixelFormat(image.format()) == DSPF_UNKNOWN
+#elif defined QT_NO_DIRECTFB_PREALLOCATED
+        || QDirectFBPaintEnginePrivate::cacheCost(image) > imageCache.maxCost()
+#endif
+        )
 #endif
     {
         RASTERFALLBACK(DRAW_IMAGE, r, image.size(), sr);
@@ -1016,10 +531,16 @@ void QDirectFBPaintEngine::drawImage(const QRectF &r, const QImage &image,
         QRasterPaintEngine::drawImage(r, image, sr, flags);
         return;
     }
-
-#ifndef QT_NO_DIRECTFB_PREALLOCATED
+#if !defined QT_NO_DIRECTFB_PREALLOCATED || defined QT_DIRECTFB_IMAGECACHE
     d->unlock();
-    d->drawImage(r, image, sr);
+    bool release;
+    IDirectFBSurface *imgSurface = d->getSurface(image, &release);
+    d->prepareForBlit(QDirectFBScreen::hasAlpha(imgSurface));
+    d->blit(r, imgSurface, sr);
+    if (release) {
+        imgSurface->ReleaseSource(imgSurface);
+        imgSurface->Release(imgSurface);
+    }
 #endif
 }
 
@@ -1038,14 +559,20 @@ void QDirectFBPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pixmap,
         RASTERFALLBACK(DRAW_PIXMAP, r, pixmap.size(), sr);
         d->lock();
         QRasterPaintEngine::drawPixmap(r, pixmap, sr);
-    } else if (!d->dfbCanHandleClip(r) || d->matrixRotShear) {
+    } else if (!d->dfbCanHandleClip(r) || d->matrixRotShear
+               || d->scale == QDirectFBPaintEnginePrivate::NegativeScale) {
         RASTERFALLBACK(DRAW_PIXMAP, r, pixmap.size(), sr);
         const QImage *img = static_cast<QDirectFBPixmapData*>(pixmap.pixmapData())->buffer(DSLF_READ);
         d->lock();
         QRasterPaintEngine::drawImage(r, *img, sr);
     } else {
         d->unlock();
-        d->drawPixmap(r, pixmap, sr);
+        d->prepareForBlit(pixmap.hasAlphaChannel());
+        QPixmapData *data = pixmap.pixmapData();
+        Q_ASSERT(data->classId() == QPixmapData::DirectFBClass);
+        QDirectFBPixmapData *dfbData = static_cast<QDirectFBPixmapData*>(data);
+        IDirectFBSurface *s = dfbData->directFBSurface();
+        d->blit(r, s, sr);
     }
 }
 
@@ -1064,7 +591,8 @@ void QDirectFBPaintEngine::drawTiledPixmap(const QRectF &r,
         RASTERFALLBACK(DRAW_TILED_PIXMAP, r, pixmap.size(), sp);
         d->lock();
         QRasterPaintEngine::drawTiledPixmap(r, pixmap, sp);
-    } else if (!d->dfbCanHandleClip(r) || d->matrixRotShear || !sp.isNull()) {
+    } else if (!d->dfbCanHandleClip(r) || d->matrixRotShear || !sp.isNull()
+               || d->scale == QDirectFBPaintEnginePrivate::NegativeScale) {
         RASTERFALLBACK(DRAW_TILED_PIXMAP, r, pixmap.size(), sp);
         const QImage *img = static_cast<QDirectFBPixmapData*>(pixmap.pixmapData())->buffer(DSLF_READ);
         d->lock();
@@ -1254,4 +782,457 @@ void QDirectFBPaintEngine::drawBufferSpan(const uint *buffer, int bufsize,
     d->surface->Blit(d->surface, src, &rect, x, y);
 }
 
+#ifdef QT_DIRECTFB_IMAGECACHE
+static void cachedImageCleanupHook(qint64 key)
+{
+    delete imageCache.take(key);
+}
+void QDirectFBPaintEngine::initImageCache(int size)
+{
+    Q_ASSERT(size >= 0);
+    imageCache.setMaxCost(size);
+    typedef void (*_qt_image_cleanup_hook_64)(qint64);
+    extern Q_GUI_EXPORT _qt_image_cleanup_hook_64 qt_image_cleanup_hook_64;
+    qt_image_cleanup_hook_64 = ::cachedImageCleanupHook;
+}
+
+#endif // QT_DIRECTFB_IMAGECACHE
+
+// ---- QDirectFBPaintEnginePrivate ----
+
+
+QDirectFBPaintEnginePrivate::QDirectFBPaintEnginePrivate(QDirectFBPaintEngine *p)
+    : surface(0), antialiased(false), forceRasterPrimitives(false), simplePen(false),
+      matrixRotShear(false), scale(NoScale), lastLockedHeight(-1),
+      fbWidth(-1), fbHeight(-1), opacity(255), drawFlagsFromCompositionMode(0),
+      blitFlagsFromCompositionMode(0), porterDuffRule(DSPD_SRC_OVER), dirtyClip(true),
+      dfbHandledClip(false), dfbDevice(0), lockedMemory(0), q(p)
+{
+    fb = QDirectFBScreen::instance()->dfb();
+    ignoreSystemClip = QDirectFBScreen::instance()->directFBFlags() & QDirectFBScreen::IgnoreSystemClip;
+    surfaceCache = new SurfaceCache;
+}
+
+QDirectFBPaintEnginePrivate::~QDirectFBPaintEnginePrivate()
+{
+    delete surfaceCache;
+}
+
+bool QDirectFBPaintEnginePrivate::dfbCanHandleClip(const QRect &rect) const
+{
+    // TODO: Check to see if DirectFB can handle the clip for the given rect
+    return dfbHandledClip;
+}
+
+bool QDirectFBPaintEnginePrivate::dfbCanHandleClip(const QRectF &rect) const
+{
+    // TODO: Check to see if DirectFB can handle the clip for the given rect
+    return dfbHandledClip;
+}
+
+bool QDirectFBPaintEnginePrivate::dfbCanHandleClip() const
+{
+    return dfbHandledClip;
+}
+
+bool QDirectFBPaintEnginePrivate::isSimpleBrush(const QBrush &brush) const
+{
+    return (brush.style() == Qt::NoBrush) || (brush.style() == Qt::SolidPattern && !antialiased);
+}
+
+void QDirectFBPaintEnginePrivate::lock()
+{
+    // We will potentially get a new pointer to the buffer after a
+    // lock so we need to call the base implementation of prepare so
+    // it updates its rasterBuffer to point to the new buffer address.
+    Q_ASSERT(dfbDevice);
+    if (dfbDevice->lockFlags() != (DSLF_WRITE|DSLF_READ)
+        || dfbDevice->height() != lastLockedHeight
+        || dfbDevice->memory() != lockedMemory) {
+        prepare(dfbDevice);
+        lastLockedHeight = dfbDevice->height();
+        lockedMemory = dfbDevice->memory();
+    }
+}
+
+void QDirectFBPaintEnginePrivate::unlock()
+{
+    Q_ASSERT(dfbDevice);
+    dfbDevice->unlockDirectFB();
+    lockedMemory = 0;
+}
+
+void QDirectFBPaintEnginePrivate::setTransform(const QTransform &m)
+{
+    transform = m;
+    matrixRotShear = (transform.m12() != 0 || transform.m21() != 0);
+    if (qMin(transform.m11(), transform.m22()) < 0) {
+        scale = NegativeScale;
+    } else if (transform.m11() != 1 || transform.m22() != 1) {
+        scale = Scaled;
+    } else {
+        scale = NoScale;
+    }
+}
+
+void QDirectFBPaintEnginePrivate::begin(QPaintDevice *device)
+{
+    lastLockedHeight = -1;
+    if (device->devType() == QInternal::CustomRaster)
+        dfbDevice = static_cast<QDirectFBPaintDevice*>(device);
+    else if (device->devType() == QInternal::Pixmap) {
+        QPixmapData *data = static_cast<QPixmap*>(device)->pixmapData();
+        Q_ASSERT(data->classId() == QPixmapData::DirectFBClass);
+        QDirectFBPixmapData* dfbPixmapData = static_cast<QDirectFBPixmapData*>(data);
+        dfbDevice = static_cast<QDirectFBPaintDevice*>(dfbPixmapData);
+    }
+
+    if (dfbDevice)
+        surface = dfbDevice->directFBSurface();
+
+    if (!surface) {
+        qFatal("QDirectFBPaintEngine used on an invalid device: 0x%x",
+               device->devType());
+    }
+    lockedMemory = 0;
+    forceRasterPrimitives = dfbDevice->forceRasterPrimitives();
+
+    surface->GetSize(surface, &fbWidth, &fbHeight);
+
+    setTransform(QTransform());
+    antialiased = false;
+    opacity = 255;
+    setCompositionMode(q->state()->compositionMode());
+    dirtyClip = true;
+    setPen(q->state()->pen);
+    setDFBColor(pen.color());
+}
+
+void QDirectFBPaintEnginePrivate::end()
+{
+    lockedMemory = 0;
+    dfbDevice = 0;
+    surface->ReleaseSource(surface);
+    surface->SetClip(surface, NULL);
+    surface = 0;
+}
+
+void QDirectFBPaintEnginePrivate::setPen(const QPen &p)
+{
+    pen = p;
+    simplePen = (pen.style() == Qt::NoPen) ||
+                (pen.style() == Qt::SolidLine
+                 && !antialiased
+                 && (pen.brush().style() == Qt::SolidPattern)
+                 && (pen.widthF() <= 1 && scale != NoScale));
+}
+
+void QDirectFBPaintEnginePrivate::setCompositionMode(QPainter::CompositionMode mode)
+{
+    blitFlagsFromCompositionMode = DSBLIT_NOFX;
+    drawFlagsFromCompositionMode = DSDRAW_NOFX;
+
+    bool blend = true;
+    switch (mode) {
+    case QPainter::CompositionMode_SourceOver:
+        porterDuffRule = DSPD_SRC_OVER;
+        break;
+    case QPainter::CompositionMode_DestinationOver:
+        porterDuffRule = DSPD_DST_OVER;
+        break;
+    case QPainter::CompositionMode_Clear:
+        porterDuffRule = DSPD_CLEAR;
+        blend = false;
+        break;
+    case QPainter::CompositionMode_Source:
+        porterDuffRule = DSPD_SRC;
+        blend = false;
+        break;
+    case QPainter::CompositionMode_Destination:
+        porterDuffRule = DSPD_NONE; // ### need to double check this
+        blend = false;
+        return;
+    case QPainter::CompositionMode_SourceIn:
+        porterDuffRule = DSPD_SRC_IN;
+        break;
+    case QPainter::CompositionMode_DestinationIn:
+        porterDuffRule = DSPD_DST_IN;
+        break;
+    case QPainter::CompositionMode_SourceOut:
+        porterDuffRule = DSPD_SRC_OUT;
+        break;
+    case QPainter::CompositionMode_DestinationOut:
+        porterDuffRule = DSPD_DST_OUT;
+        break;
+    case QPainter::CompositionMode_Xor:
+        porterDuffRule = DSPD_XOR;
+        blitFlagsFromCompositionMode |= DSBLIT_XOR;
+        drawFlagsFromCompositionMode |= DSDRAW_XOR;
+        break;
+//     case QPainter::CompositionMode_Plus: // ???
+//         porterDuffRule = DSPD_ADD;
+//         break;
+    default:
+        qWarning("QDirectFBPaintEnginePrivate::setCompositionMode(): "
+                 "mode %d not implemented", mode);
+        return;
+    }
+    // intentially not comparing with current porterDuffRule. surface might have changed.
+    if (blend) {
+        blitFlagsFromCompositionMode |= DSBLIT_BLEND_ALPHACHANNEL;
+        drawFlagsFromCompositionMode |= DSDRAW_BLEND;
+    }
+    if (opacity != 255) {
+        setOpacity(opacity);
+    }
+}
+
+void QDirectFBPaintEnginePrivate::setOpacity(quint8 op)
+{
+    opacity = op;
+    if (opacity == 255) {
+        blitFlagsFromCompositionMode &= ~DSBLIT_BLEND_COLORALPHA;
+    } else {
+        blitFlagsFromCompositionMode |= DSBLIT_BLEND_COLORALPHA;
+    }
+}
+
+void QDirectFBPaintEnginePrivate::setRenderHints(QPainter::RenderHints hints)
+{
+    const bool old = antialiased;
+    antialiased = bool(hints & QPainter::Antialiasing);
+    if (old != antialiased) {
+        setPen(q->state()->pen);
+    }
+}
+
+void QDirectFBPaintEnginePrivate::prepareForBlit(bool alpha)
+{
+    quint32 blittingFlags = blitFlagsFromCompositionMode;
+    if (alpha) {
+        surface->SetPorterDuff(surface,
+                               (blittingFlags & DSBLIT_BLEND_COLORALPHA)
+                               ? DSPD_NONE
+                               : porterDuffRule);
+    } else {
+        blittingFlags &= ~DSBLIT_BLEND_ALPHACHANNEL;
+        surface->SetPorterDuff(surface, DSPD_NONE);
+    }
+    surface->SetColor(surface, 0xff, 0xff, 0xff, opacity);
+    surface->SetBlittingFlags(surface, DFBSurfaceBlittingFlags(blittingFlags));
+}
+
+void QDirectFBPaintEnginePrivate::setDFBColor(const QColor &color)
+{
+    Q_ASSERT(surface);
+    const quint8 alpha = (opacity == 255 ?
+                          color.alpha() : ALPHA_MUL(color.alpha(), opacity));
+    surface->SetColor(surface,
+                      color.red(), color.green(), color.blue(), alpha);
+    quint32 drawingFlags = drawFlagsFromCompositionMode;
+    if (alpha == 255) {
+        drawingFlags &= ~DSDRAW_BLEND;
+    }
+    surface->SetPorterDuff(surface, DSPD_NONE);
+    // PorterDuff messes up alpha values for primitives
+    surface->SetDrawingFlags(surface, DFBSurfaceDrawingFlags(drawingFlags));
+}
+
+void QDirectFBPaintEnginePrivate::drawLines(const QLine *lines, int n)
+{
+    for (int i = 0; i < n; ++i) {
+        const QLine l = transform.map(lines[i]);
+        surface->DrawLine(surface, l.x1(), l.y1(), l.x2(), l.y2());
+    }
+}
+
+void QDirectFBPaintEnginePrivate::drawLines(const QLineF *lines, int n)
+{
+    for (int i = 0; i < n; ++i) {
+        const QLine l = transform.map(lines[i]).toLine();
+        surface->DrawLine(surface, l.x1(), l.y1(), l.x2(), l.y2());
+    }
+}
+
+void QDirectFBPaintEnginePrivate::fillRegion(const QRegion &region)
+{
+    Q_ASSERT(isSimpleBrush(q->state()->brush));
+    setDFBColor(q->state()->brush.color());
+    const QVector<QRect> rects = region.rects();
+    const int n = rects.size();
+    fillRects(rects.constData(), n);
+}
+
+void QDirectFBPaintEnginePrivate::fillRects(const QRect *rects, int n)
+{
+    for (int i = 0; i < n; ++i) {
+        const QRect r = transform.mapRect(rects[i]);
+        surface->FillRectangle(surface, r.x(), r.y(),
+                               r.width(), r.height());
+    }
+}
+
+void QDirectFBPaintEnginePrivate::fillRects(const QRectF *rects, int n)
+{
+    for (int i = 0; i < n; ++i) {
+        const QRect r = transform.mapRect(rects[i]).toRect();
+        surface->FillRectangle(surface, r.x(), r.y(),
+                               r.width(), r.height());
+    }
+}
+
+void QDirectFBPaintEnginePrivate::drawRects(const QRect *rects, int n)
+{
+    for (int i = 0; i < n; ++i) {
+        const QRect r = transform.mapRect(rects[i]);
+        surface->DrawRectangle(surface, r.x(), r.y(),
+                               r.width() + 1, r.height() + 1);
+    }
+}
+
+void QDirectFBPaintEnginePrivate::drawRects(const QRectF *rects, int n)
+{
+    for (int i = 0; i < n; ++i) {
+        const QRect r = transform.mapRect(rects[i]).toRect();
+        surface->DrawRectangle(surface, r.x(), r.y(),
+                               r.width() + 1, r.height() + 1);
+    }
+}
+
+IDirectFBSurface *QDirectFBPaintEnginePrivate::getSurface(const QImage &img, bool *release)
+{
+#ifndef QT_DIRECTFB_IMAGECACHE
+    *release = true;
+    return QDirectFBScreen::instance()->createDFBSurface(img, QDirectFBScreen::DontTrackSurface);
+#else
+    const qint64 key = img.cacheKey();
+    *release = false;
+    if (imageCache.contains(key)) {
+        return imageCache[key]->surface;
+    }
+
+    const int cost = cacheCost(img);
+    const bool cache = cost <= imageCache.maxCost();
+    QDirectFBScreen *screen = QDirectFBScreen::instance();
+    const QImage::Format format = (img.format() == screen->alphaPixmapFormat() || QDirectFBPixmapData::hasAlphaChannel(img)
+                                   ? screen->alphaPixmapFormat() : screen->pixelFormat());
+
+    IDirectFBSurface *surface = screen->copyToDFBSurface(img, format,
+                                                         cache
+                                                         ? QDirectFBScreen::TrackSurface
+                                                         : QDirectFBScreen::DontTrackSurface);
+    if (cache) {
+        CachedImage *cachedImage = new CachedImage;
+        const_cast<QImage&>(img).data_ptr()->is_cached = true;
+        cachedImage->surface = surface;
+        imageCache.insert(key, cachedImage, cost);
+    } else {
+        *release = true;
+    }
+    return surface;
+#endif
+}
+
+
+void QDirectFBPaintEnginePrivate::blit(const QRectF &dest, IDirectFBSurface *s, const QRectF &src)
+{
+    const QRect sr = src.toRect();
+    const QRect dr = transform.mapRect(dest).toRect();
+    const DFBRectangle sRect = { sr.x(), sr.y(), sr.width(), sr.height() };
+    DFBResult result;
+
+    if (dr.size() == sr.size()) {
+        result = surface->Blit(surface, s, &sRect, dr.x(), dr.y());
+    } else {
+        const DFBRectangle dRect = { dr.x(), dr.y(), dr.width(), dr.height() };
+        result = surface->StretchBlit(surface, s, &sRect, &dRect);
+    }
+    if (result != DFB_OK)
+        DirectFBError("QDirectFBPaintEngine::drawPixmap()", result);
+}
+
+void QDirectFBPaintEnginePrivate::drawTiledPixmap(const QRectF &dest,
+                                                  const QPixmap &pixmap)
+{
+    prepareForBlit(pixmap.hasAlphaChannel());
+    QPixmapData *data = pixmap.pixmapData();
+    Q_ASSERT(data->classId() == QPixmapData::DirectFBClass);
+    QDirectFBPixmapData *dfbData = static_cast<QDirectFBPixmapData*>(data);
+    IDirectFBSurface *s = dfbData->directFBSurface();
+    const QRect dr = transform.mapRect(dest).toRect();
+    DFBResult result = DFB_OK;
+
+    if (scale == NoScale && dr == QRect(0, 0, fbWidth, fbHeight)) {
+        result = surface->TileBlit(surface, s, 0, 0, 0);
+    } else if (scale == NoScale) {
+        const int dx = pixmap.width();
+        const int dy = pixmap.height();
+        const DFBRectangle rect = { 0, 0, dx, dy };
+        QVarLengthArray<DFBRectangle> rects;
+        QVarLengthArray<DFBPoint> points;
+
+        for (int y = dr.y(); y <= dr.bottom(); y += dy) {
+            for (int x = dr.x(); x <= dr.right(); x += dx) {
+                rects.append(rect);
+                const DFBPoint point = { x, y };
+                points.append(point);
+            }
+        }
+        result = surface->BatchBlit(surface, s, rects.constData(),
+                                    points.constData(), points.size());
+    } else {
+        const QRect sr = transform.mapRect(QRect(0, 0, pixmap.width(), pixmap.height()));
+        const int dx = sr.width();
+        const int dy = sr.height();
+        const DFBRectangle sRect = { 0, 0, dx, dy };
+
+        for (int y = dr.y(); y <= dr.bottom(); y += dy) {
+            for (int x = dr.x(); x <= dr.right(); x += dx) {
+                const DFBRectangle dRect = { x, y, dx, dy };
+                result = surface->StretchBlit(surface, s, &sRect, &dRect);
+                if (result != DFB_OK) {
+                    y = dr.bottom() + 1;
+                    break;
+                }
+            }
+        }
+    }
+
+    if (result != DFB_OK)
+        DirectFBError("QDirectFBPaintEngine::drawTiledPixmap()", result);
+}
+
+void QDirectFBPaintEnginePrivate::updateClip()
+{
+    if (!dirtyClip)
+        return;
+
+    const QClipData *clipData = clip();
+    if (!clipData || !clipData->enabled) {
+        surface->SetClip(surface, NULL);
+        dfbHandledClip = true;
+    } else if (clipData->hasRectClip) {
+        const DFBRegion r = {
+            clipData->clipRect.x(),
+            clipData->clipRect.y(),
+            clipData->clipRect.x() + clipData->clipRect.width(),
+            clipData->clipRect.y() + clipData->clipRect.height()
+        };
+        surface->SetClip(surface, &r);
+        dfbHandledClip = true;
+    } else if (clipData->hasRegionClip && ignoreSystemClip && clipData->clipRegion == systemClip) {
+        dfbHandledClip = true;
+    } else {
+        dfbHandledClip = false;
+    }
+
+    dirtyClip = false;
+}
+
+void QDirectFBPaintEnginePrivate::systemStateChanged()
+{
+    dirtyClip = true;
+    QRasterPaintEnginePrivate::systemStateChanged();
+}
+
 #endif // QT_NO_DIRECTFB
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h
index e79ec61..d33255b 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h
@@ -106,6 +106,7 @@ public:
     virtual void clip(const QVectorPath &path, Qt::ClipOperation op);
     virtual void clip(const QRect &rect, Qt::ClipOperation op);
 
+    static void initImageCache(int size);
 };
 
 QT_END_HEADER
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
index f7c428b..7297a99 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
@@ -157,6 +157,16 @@ static bool checkForAlphaPixels(const QImage &img)
     return false;
 }
 
+bool QDirectFBPixmapData::hasAlphaChannel(const QImage &img)
+{
+#ifndef QT_NO_DIRECTFB_OPAQUE_DETECTION
+    return ::checkForAlphaPixels(img);
+#else
+    return img.hasAlphaChannel();
+#endif
+}
+
+
 void QDirectFBPixmapData::fromImage(const QImage &i,
                                     Qt::ImageConversionFlags flags)
 {
@@ -166,7 +176,7 @@ void QDirectFBPixmapData::fromImage(const QImage &i,
     const QImage img = (i.depth() == 1 ? i.convertToFormat(screen->alphaPixmapFormat()) : i);
     if (img.hasAlphaChannel()
 #ifndef QT_NO_DIRECTFB_OPAQUE_DETECTION
-        && (flags & Qt::NoOpaqueDetection || ::checkForAlphaPixels(img))
+        && (flags & Qt::NoOpaqueDetection || QDirectFBPixmapData::hasAlphaChannel(img))
 #endif
         ) {
         alpha = true;
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.h b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.h
index 697e5ce..7cd60d6 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.h
@@ -75,6 +75,7 @@ public:
     // Pure virtual in QPixmapData, so re-implement here and delegate to QDirectFBPaintDevice
     int metric(QPaintDevice::PaintDeviceMetric m) const {return QDirectFBPaintDevice::metric(m);}
     inline QImage::Format pixelFormat() const { return format; }
+    static bool hasAlphaChannel(const QImage &img);
 private:
     void invalidate();
     QDirectFBPaintEngine *engine;
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
index 59f5934..25e24fd 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
@@ -113,9 +113,9 @@ QDirectFBScreenPrivate::~QDirectFBScreenPrivate()
     delete keyboard;
 #endif
 
-    foreach (IDirectFBSurface *surf, allocatedSurfaces)
-        surf->Release(surf);
-    allocatedSurfaces.clear();
+    for (QSet<IDirectFBSurface*>::const_iterator it = allocatedSurfaces.begin(); it != allocatedSurfaces.end(); ++it) {
+        (*it)->Release(*it);
+    }
 
     if (dfbSurface)
         dfbSurface->Release(dfbSurface);
@@ -350,6 +350,7 @@ QDirectFBScreen::DirectFBFlags QDirectFBScreen::directFBFlags() const
 {
     return d_ptr->directFBFlags;
 }
+
 IDirectFB *QDirectFBScreen::dfb()
 {
     return d_ptr->dfb;
@@ -751,43 +752,43 @@ struct FlagDescription {
 };
 
 static const FlagDescription accelerationDescriptions[] = {
-    { "DFXL_NONE ", DFXL_NONE },
-    { "DFXL_FILLRECTANGLE", DFXL_FILLRECTANGLE },
-    { "DFXL_DRAWRECTANGLE", DFXL_DRAWRECTANGLE },
-    { "DFXL_DRAWLINE", DFXL_DRAWLINE },
-    { "DFXL_FILLTRIANGLE", DFXL_FILLTRIANGLE },
-    { "DFXL_BLIT", DFXL_BLIT },
-    { "DFXL_STRETCHBLIT", DFXL_STRETCHBLIT },
-    { "DFXL_TEXTRIANGLES", DFXL_TEXTRIANGLES },
-    { "DFXL_DRAWSTRING", DFXL_DRAWSTRING },
+    { " DFXL_NONE ", DFXL_NONE },
+    { " DFXL_FILLRECTANGLE", DFXL_FILLRECTANGLE },
+    { " DFXL_DRAWRECTANGLE", DFXL_DRAWRECTANGLE },
+    { " DFXL_DRAWLINE", DFXL_DRAWLINE },
+    { " DFXL_FILLTRIANGLE", DFXL_FILLTRIANGLE },
+    { " DFXL_BLIT", DFXL_BLIT },
+    { " DFXL_STRETCHBLIT", DFXL_STRETCHBLIT },
+    { " DFXL_TEXTRIANGLES", DFXL_TEXTRIANGLES },
+    { " DFXL_DRAWSTRING", DFXL_DRAWSTRING },
     { 0, 0 }
 };
 
 static const FlagDescription blitDescriptions[] = {
-    { "DSBLIT_NOFX", DSBLIT_NOFX },
-    { "DSBLIT_BLEND_ALPHACHANNEL", DSBLIT_BLEND_ALPHACHANNEL },
-    { "DSBLIT_BLEND_COLORALPHA", DSBLIT_BLEND_COLORALPHA },
-    { "DSBLIT_COLORIZE", DSBLIT_COLORIZE },
-    { "DSBLIT_SRC_COLORKEY", DSBLIT_SRC_COLORKEY },
-    { "DSBLIT_DST_COLORKEY", DSBLIT_DST_COLORKEY },
-    { "DSBLIT_SRC_PREMULTIPLY", DSBLIT_SRC_PREMULTIPLY },
-    { "DSBLIT_DST_PREMULTIPLY", DSBLIT_DST_PREMULTIPLY },
-    { "DSBLIT_DEMULTIPLY", DSBLIT_DEMULTIPLY },
-    { "DSBLIT_DEINTERLACE", DSBLIT_DEINTERLACE },
-    { "DSBLIT_SRC_PREMULTCOLOR", DSBLIT_SRC_PREMULTCOLOR },
-    { "DSBLIT_XOR", DSBLIT_XOR },
-    { "DSBLIT_INDEX_TRANSLATION", DSBLIT_INDEX_TRANSLATION },
+    { " DSBLIT_NOFX", DSBLIT_NOFX },
+    { " DSBLIT_BLEND_ALPHACHANNEL", DSBLIT_BLEND_ALPHACHANNEL },
+    { " DSBLIT_BLEND_COLORALPHA", DSBLIT_BLEND_COLORALPHA },
+    { " DSBLIT_COLORIZE", DSBLIT_COLORIZE },
+    { " DSBLIT_SRC_COLORKEY", DSBLIT_SRC_COLORKEY },
+    { " DSBLIT_DST_COLORKEY", DSBLIT_DST_COLORKEY },
+    { " DSBLIT_SRC_PREMULTIPLY", DSBLIT_SRC_PREMULTIPLY },
+    { " DSBLIT_DST_PREMULTIPLY", DSBLIT_DST_PREMULTIPLY },
+    { " DSBLIT_DEMULTIPLY", DSBLIT_DEMULTIPLY },
+    { " DSBLIT_DEINTERLACE", DSBLIT_DEINTERLACE },
+    { " DSBLIT_SRC_PREMULTCOLOR", DSBLIT_SRC_PREMULTCOLOR },
+    { " DSBLIT_XOR", DSBLIT_XOR },
+    { " DSBLIT_INDEX_TRANSLATION", DSBLIT_INDEX_TRANSLATION },
     { 0, 0 }
 };
 
 static const FlagDescription drawDescriptions[] = {
-    { "DSDRAW_NOFX", DSDRAW_NOFX },
-    { "DSDRAW_BLEND", DSDRAW_BLEND },
-    { "DSDRAW_DST_COLORKEY", DSDRAW_DST_COLORKEY },
-    { "DSDRAW_SRC_PREMULTIPLY", DSDRAW_SRC_PREMULTIPLY },
-    { "DSDRAW_DST_PREMULTIPLY", DSDRAW_DST_PREMULTIPLY },
-    { "DSDRAW_DEMULTIPLY", DSDRAW_DEMULTIPLY },
-    { "DSDRAW_XOR", DSDRAW_XOR },
+    { " DSDRAW_NOFX", DSDRAW_NOFX },
+    { " DSDRAW_BLEND", DSDRAW_BLEND },
+    { " DSDRAW_DST_COLORKEY", DSDRAW_DST_COLORKEY },
+    { " DSDRAW_SRC_PREMULTIPLY", DSDRAW_SRC_PREMULTIPLY },
+    { " DSDRAW_DST_PREMULTIPLY", DSDRAW_DST_PREMULTIPLY },
+    { " DSDRAW_DEMULTIPLY", DSDRAW_DEMULTIPLY },
+    { " DSDRAW_XOR", DSDRAW_XOR },
     { 0, 0 }
 };
 #endif
@@ -829,7 +830,7 @@ static void printDirectFBInfo(IDirectFB *fb)
     }
 
     qDebug("Device: %s (%s), Driver: %s v%i.%i (%s)\n"
-           "  acceleration: 0x%x%s,\nblit: 0x%x%s,\ndraw: 0x%0x%s\nvideo: %iKB\n",
+           "acceleration: 0x%x%s\nblit: 0x%x%s\ndraw: 0x%0x%s\nvideo: %iKB\n",
            dev.name, dev.vendor, dev.driver.name, dev.driver.major,
            dev.driver.minor, dev.driver.vendor, dev.acceleration_mask,
            ::flagDescriptions(dev.acceleration_mask, accelerationDescriptions).constData(),
@@ -900,6 +901,12 @@ bool QDirectFBScreen::connect(const QString &displaySpec)
         d_ptr->directFBFlags |= BoundingRectFlip;
     }
 
+#ifdef QT_DIRECTFB_IMAGECACHE
+    int imageCacheSize = 4 * 1024 * 1024; // 4 MB
+    ::setIntOption(displayArgs, QLatin1String("imagecachesize"), &imageCacheSize);
+    QDirectFBPaintEngine::initImageCache(imageCacheSize);
+#endif
+
     if (displayArgs.contains(QLatin1String("ignoresystemclip"), Qt::CaseInsensitive))
         d_ptr->directFBFlags |= IgnoreSystemClip;
 
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
index e91a06b..84199a2 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
@@ -105,8 +105,6 @@ public:
         TrackSurface = 1
     };
     Q_DECLARE_FLAGS(SurfaceCreationOptions, SurfaceCreationOption);
-    IDirectFBSurface *createDFBSurface(DFBSurfaceDescription desc,
-                                       SurfaceCreationOptions options);
     IDirectFBSurface *createDFBSurface(const QImage &image,
                                        SurfaceCreationOptions options);
     IDirectFBSurface *createDFBSurface(const QSize &size,
@@ -130,6 +128,7 @@ public:
     static bool initSurfaceDescriptionPixelFormat(DFBSurfaceDescription *description, QImage::Format format);
     static inline bool isPremultiplied(QImage::Format format);
     static inline bool hasAlpha(DFBSurfacePixelFormat format);
+    static inline bool hasAlpha(IDirectFBSurface *surface);
     QImage::Format alphaPixmapFormat() const;
 
 #ifndef QT_NO_DIRECTFB_PALETTE
@@ -140,11 +139,14 @@ public:
     static uchar *lockSurface(IDirectFBSurface *surface, uint flags, int *bpl = 0);
 
 private:
+    IDirectFBSurface *createDFBSurface(DFBSurfaceDescription desc,
+                                       SurfaceCreationOptions options);
     void compose(const QRegion &r);
     void blit(IDirectFBSurface *src, const QPoint &topLeft,
               const QRegion &region);
 
     QDirectFBScreenPrivate *d_ptr;
+    friend class SurfaceCache;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QDirectFBScreen::SurfaceCreationOptions);
@@ -186,6 +188,14 @@ inline bool QDirectFBScreen::hasAlpha(DFBSurfacePixelFormat format)
     }
 }
 
+inline bool QDirectFBScreen::hasAlpha(IDirectFBSurface *surface)
+{
+    Q_ASSERT(surface);
+    DFBSurfacePixelFormat format;
+    surface->GetPixelFormat(surface, &format);
+    return QDirectFBScreen::hasAlpha(format);
+}
+
 QT_END_HEADER
 
 #endif // QDIRECTFBSCREEN_H
diff --git a/src/sql/drivers/mysql/qsql_mysql.cpp b/src/sql/drivers/mysql/qsql_mysql.cpp
index a84e840..1f54db7 100644
--- a/src/sql/drivers/mysql/qsql_mysql.cpp
+++ b/src/sql/drivers/mysql/qsql_mysql.cpp
@@ -224,7 +224,7 @@ static QTextCodec* codec(MYSQL* mysql)
 static QSqlError qMakeError(const QString& err, QSqlError::ErrorType type,
                             const QMYSQLDriverPrivate* p)
 {
-    const char *cerr = mysql_error(p->mysql);
+    const char *cerr = p->mysql ? mysql_error(p->mysql) : 0;
     return QSqlError(QLatin1String("QMYSQL: ") + err,
                      p->tc ? toUnicode(p->tc, cerr) : QString::fromLatin1(cerr),
                      type, mysql_errno(p->mysql));