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

202 files changed, 5597 insertions, 2834 deletions

diff --git a/src/3rdparty/README b/src/3rdparty/README
index 2be1036..ef05674 100644
--- a/src/3rdparty/README
+++ b/src/3rdparty/README
@@ -20,3 +20,8 @@ have been removed:
 
 Some patches are applied from time to time. Recent patches can be
 found in the patches subdirectory.
+
+
+The pvr2d.h & wsegl.h in the powervr directory are required for building
+the PowerVR plugin on Qt for Embedded Linux. These headers are for SGX
+based SoCs, but may also work on MBX SoCs.
diff --git a/src/3rdparty/phonon/ds9/mediaobject.cpp b/src/3rdparty/phonon/ds9/mediaobject.cpp
index 93a19b0..1d0b69d 100644
--- a/src/3rdparty/phonon/ds9/mediaobject.cpp
+++ b/src/3rdparty/phonon/ds9/mediaobject.cpp
@@ -519,6 +519,15 @@ namespace Phonon
 
             qSwap(m_graphs[0], m_graphs[1]); //swap the graphs
 
+            if (currentGraph()->mediaSource().type() != Phonon::MediaSource::Invalid &&
+                catchComError(currentGraph()->renderResult())) {
+                    setState(Phonon::ErrorState);
+                    return;
+            }
+
+            //we need to play the next media
+            play();
+
             //we tell the video widgets to switch now to the new source
 #ifndef QT_NO_PHONON_VIDEO
             for (int i = 0; i < m_videoWidgets.count(); ++i) {
@@ -527,15 +536,6 @@ namespace Phonon
 #endif //QT_NO_PHONON_VIDEO
 
             emit currentSourceChanged(currentGraph()->mediaSource());
-
-            if (currentGraph()->isLoading()) {
-                //will simply tell that when loading is finished 
-                //it should start the playback
-                play(); 
-            }
-
-
-
             emit metaDataChanged(currentGraph()->metadata());
 
             if (nextGraph()->hasVideo() != currentGraph()->hasVideo()) {
@@ -548,15 +548,6 @@ namespace Phonon
 #ifndef QT_NO_PHONON_MEDIACONTROLLER
             setTitles(currentGraph()->titles());
 #endif //QT_NO_PHONON_MEDIACONTROLLER
-
-            //this manages only gapless transitions
-            if (currentGraph()->mediaSource().type() != Phonon::MediaSource::Invalid) {
-                if (catchComError(currentGraph()->renderResult())) {
-                    setState(Phonon::ErrorState);
-                } else {
-                    play();
-                }
-            }
         }
 
         Phonon::State MediaObject::state() const
diff --git a/src/3rdparty/phonon/phonon/phononnamespace.h b/src/3rdparty/phonon/phonon/phononnamespace.h
index 0bbf4f4..2492ee6 100644
--- a/src/3rdparty/phonon/phonon/phononnamespace.h
+++ b/src/3rdparty/phonon/phonon/phononnamespace.h
@@ -25,6 +25,11 @@
 
 #include "phonon_export.h"
 
+#ifdef __QT_SYNCQT__
+// Tell syncqt to create a "Global" header here
+#pragma qt_class(Phonon::Global)
+#endif
+
 /**
  * Helper macro that can be used like
  * \code
diff --git a/src/3rdparty/powervr/pvr2d.h b/src/3rdparty/powervr/pvr2d.h
new file mode 100644
index 0000000..07f28c7
--- /dev/null
+++ b/src/3rdparty/powervr/pvr2d.h
@@ -0,0 +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)
+******************************************************************************/
diff --git a/src/3rdparty/powervr/wsegl.h b/src/3rdparty/powervr/wsegl.h
new file mode 100644
index 0000000..0490607
--- /dev/null
+++ b/src/3rdparty/powervr/wsegl.h
@@ -0,0 +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)
+******************************************************************************/
diff --git a/src/3rdparty/webkit/ChangeLog b/src/3rdparty/webkit/ChangeLog
index ec8242d..76cfc80 100644
--- a/src/3rdparty/webkit/ChangeLog
+++ b/src/3rdparty/webkit/ChangeLog
@@ -1,3 +1,11 @@
+2009-04-24  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Reviewed by Ariya Hidayat.
+
+        Added support for generating API docs in the Qt build using "make docs"
+
+        * WebKit.pro: Include docs.pri for "make docs" target.
+
 2008-12-19  Marco Barisione  <marco.barisione@collabora.co.uk>
 
         Reviewed by Holger Freyther.
diff --git a/src/3rdparty/webkit/JavaScriptCore/ChangeLog b/src/3rdparty/webkit/JavaScriptCore/ChangeLog
index fe85bb9..3321570 100644
--- a/src/3rdparty/webkit/JavaScriptCore/ChangeLog
+++ b/src/3rdparty/webkit/JavaScriptCore/ChangeLog
@@ -1,3 +1,60 @@
+2009-01-22  Oliver Hunt  <oliver@apple.com>
+
+        Reviewed by Geoff Garen.
+
+        <rdar://problem/6516853> (r39682-r39736) JSFunFuzz: crash on "(function(){({ x2: x }), })()"
+        <https://bugs.webkit.org/show_bug.cgi?id=23479>
+
+        Automatic semicolon insertion was resulting in this being accepted in the initial
+        nodeless parsing, but subsequent reparsing for code generation would fail, leading
+        to a crash.  The solution is to ensure that reparsing a function performs parsing
+        in the same state as the initial parse.  We do this by modifying the saved source
+        ranges to include rather than exclude the opening and closing braces.
+
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::reparseForExceptionInfoIfNecessary): add an assertion for successful recompile
+        * parser/Lexer.h:
+        (JSC::Lexer::sourceCode): include rather than exclude braces.
+        * parser/Nodes.h:
+        (JSC::FunctionBodyNode::toSourceString):  No need to append braces anymore.
+
+2009-01-21  Alexey Proskuryakov  <ap@webkit.org>
+
+        Suggested by Oliver Hunt. Reviewed by Oliver Hunt.
+
+        https://bugs.webkit.org/show_bug.cgi?id=23456
+        Function argument names leak
+
+        * parser/Nodes.cpp: (JSC::FunctionBodyNode::~FunctionBodyNode): Destruct parameter names.
+
+2009-01-22  Beth Dakin  <bdakin@apple.com>
+
+        Reviewed by Sam Weinig.
+
+        Fix for https://bugs.webkit.org/show_bug.cgi?id=23461 LayoutTests/
+        fast/js/numeric-conversion.html is broken, and corresponding 
+        <rdar://problem/6514842>
+
+        The basic problem here is that parseInt(Infinity) should be NaN, 
+        but we were returning 0. NaN matches Safari 3.2.1 and Firefox.
+
+        * runtime/JSGlobalObjectFunctions.cpp:
+        (JSC::globalFuncParseInt):
+
+2009-01-13  Beth Dakin  <bdakin@apple.com>
+
+        Reviewed by Darin Adler and Oliver Hunt.
+
+        <rdar://problem/6489314> REGRESSION: Business widget's front side 
+        fails to render correctly when flipping widget
+
+        The problem here is that parseInt was parsing NaN as 0. This patch 
+        corrects that by parsing NaN as NaN. This matches our old behavior 
+        and Firefox. 
+
+        * runtime/JSGlobalObjectFunctions.cpp:
+        (JSC::globalFuncParseInt):
+
 2009-02-13  Adam Treat  <adam.treat@torchmobile.com>
 
         Reviewed by George Staikos.
diff --git a/src/3rdparty/webkit/JavaScriptCore/bytecode/CodeBlock.cpp b/src/3rdparty/webkit/JavaScriptCore/bytecode/CodeBlock.cpp
index 91fb1c0..9207c8a 100644
--- a/src/3rdparty/webkit/JavaScriptCore/bytecode/CodeBlock.cpp
+++ b/src/3rdparty/webkit/JavaScriptCore/bytecode/CodeBlock.cpp
@@ -1397,6 +1397,7 @@ void CodeBlock::reparseForExceptionInfoIfNecessary(CallFrame* callFrame)
         case FunctionCode: {
             FunctionBodyNode* ownerFunctionBodyNode = static_cast<FunctionBodyNode*>(m_ownerNode);
             RefPtr<FunctionBodyNode> newFunctionBody = m_globalData->parser->reparse<FunctionBodyNode>(m_globalData, ownerFunctionBodyNode);
+            ASSERT(newFunctionBody);
             newFunctionBody->finishParsing(ownerFunctionBodyNode->copyParameters(), ownerFunctionBodyNode->parameterCount());
             CodeBlock& newCodeBlock = newFunctionBody->bytecodeForExceptionInfoReparse(scopeChain);
             ASSERT(newCodeBlock.m_exceptionInfo);
diff --git a/src/3rdparty/webkit/JavaScriptCore/parser/Lexer.h b/src/3rdparty/webkit/JavaScriptCore/parser/Lexer.h
index cb553af..afcf09f 100644
--- a/src/3rdparty/webkit/JavaScriptCore/parser/Lexer.h
+++ b/src/3rdparty/webkit/JavaScriptCore/parser/Lexer.h
@@ -88,7 +88,7 @@ namespace JSC {
         bool sawError() const { return m_error; }
 
         void clear();
-        SourceCode sourceCode(int openBrace, int closeBrace, int firstLine) { return SourceCode(m_source->provider(), openBrace + 1, closeBrace, firstLine); }
+        SourceCode sourceCode(int openBrace, int closeBrace, int firstLine) { return SourceCode(m_source->provider(), openBrace, closeBrace + 1, firstLine); }
 
     private:
         friend class JSGlobalData;
diff --git a/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.cpp b/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.cpp
index bdc5d2f..201af28 100644
--- a/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.cpp
+++ b/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.cpp
@@ -2552,6 +2552,8 @@ FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, SourceElements* chi
 FunctionBodyNode::~FunctionBodyNode()
 {
     ASSERT(!m_refCount);
+    for (size_t i = 0; i < m_parameterCount; ++i)
+        m_parameters[i].~Identifier();
     fastFree(m_parameters);
 }
 
diff --git a/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.h b/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.h
index f8512f7..20885c3 100644
--- a/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.h
+++ b/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.h
@@ -2205,7 +2205,7 @@ namespace JSC {
         void finishParsing(const SourceCode&, ParameterNode*);
         void finishParsing(Identifier* parameters, size_t parameterCount);
         
-        UString toSourceString() const JSC_FAST_CALL { return UString("{") + source().toString() + UString("}"); }
+        UString toSourceString() const JSC_FAST_CALL { return source().toString(); }
 
         // These objects are ref/deref'd a lot in the scope chain, so this is a faster ref/deref.
         // If the virtual machine changes so this doesn't happen as much we can change back.
diff --git a/src/3rdparty/webkit/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp b/src/3rdparty/webkit/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp
index f12d2f3..ecdddcf 100644
--- a/src/3rdparty/webkit/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp
+++ b/src/3rdparty/webkit/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp
@@ -302,9 +302,11 @@ JSValuePtr globalFuncParseInt(ExecState* exec, JSObject*, JSValuePtr, const ArgL
         if (JSImmediate::isImmediate(value))
             return value;
         double d = value->uncheckedGetNumber();
-        if (!isfinite(d))
-            return JSImmediate::zeroImmediate();
-        return jsNumber(exec, floor(d));
+        if (isfinite(d))
+            return jsNumber(exec, floor(d));
+        if (isnan(d) || isinf(d))
+            return jsNaN(&exec->globalData());
+        return JSImmediate::zeroImmediate();
     }
 
     return jsNumber(exec, parseInt(value->toString(exec), radix));
diff --git a/src/3rdparty/webkit/VERSION b/src/3rdparty/webkit/VERSION
index bfaefa2..26ce489 100644
--- a/src/3rdparty/webkit/VERSION
+++ b/src/3rdparty/webkit/VERSION
@@ -8,4 +8,4 @@ The commit imported was from the
 
 and has the sha1 checksum
 
-        450331808bfe11b1472c213a8cb311190355c2de
+        a6ebe3865025e2bb4d767a79435af4daf5a9b4db
diff --git a/src/3rdparty/webkit/WebCore/ChangeLog b/src/3rdparty/webkit/WebCore/ChangeLog
index 9be6e72..00bd427 100644
--- a/src/3rdparty/webkit/WebCore/ChangeLog
+++ b/src/3rdparty/webkit/WebCore/ChangeLog
@@ -1,3 +1,111 @@
+2009-03-13  Adam Bergkvist <adam.bergkvist@ericsson.com>
+
+        Reviewed by Alexey Proskuryakov.
+
+        https://bugs.webkit.org/show_bug.cgi?id=24349
+        [QT] HTTP status text is never set
+
+        Set HTTP status text to the reason phrase attribute of QNetworkReply.
+
+        * platform/network/qt/QNetworkReplyHandler.cpp:
+        (WebCore::QNetworkReplyHandler::sendResponseIfNeeded):
+
+2009-03-02  Dirk Schulze  <krit@webkit.org>
+
+        Reviewed by Holger Freyther.
+
+        Added putImageData to Qt. Discussed with Ariya Hidayat.
+
+        [Qt] lacks putImageData support in Canvas
+        https://bugs.webkit.org/show_bug.cgi?id=22186
+
+        * platform/graphics/qt/ImageBufferQt.cpp:
+        (WebCore::ImageBuffer::putImageData):
+
+2009-03-01  Larry Ewing  <lewing@novell.com>
+
+        Reviewed by Alexey Proskuryakov.
+
+        https://bugs.webkit.org/show_bug.cgi?id=24080
+        NPN_GetValue casting to the wrong type and writing outside bounds
+
+        Make sure to cast the value to the correct type so that only
+        memory owned by the value is written to.
+
+        * plugins/gtk/PluginViewGtk.cpp (PluginView::getValueStatic): 
+        * plugins/qt/PluginViewQt.cpp (PluginView::getValueStatic):
+        * plugins/mac/PluginViewMac.cpp (PluginView::getValueStatic): 
+        (PluginView::getValue):
+
+2009-02-27  Adam Treat  <adam.treat@torchmobile.com>
+
+        Reviewed by Eric Seidel.
+
+        https://bugs.webkit.org/show_bug.cgi?id=24229
+        If an image has no alpha channel there is no reason to use SourceOver.
+
+        * platform/graphics/qt/ImageQt.cpp:
+        (WebCore::Image::drawPattern):
+        (WebCore::BitmapImage::draw):
+
+2009-02-27  Zack Rusin  <zack@kde.org>
+
+        Reviewed by Nikolas Zimmermann.
+
+        Qt: be more reasonable about scrolled lines
+
+        cMouseWheelPixelsPerLineStep is currently a constant set to 13.3. it doesn't
+        match our metrics meaning that Qt scrolls by ~2 lines by default which is quite
+        irritating. so lets scroll vertically by the Qt set number of lines * Qt default
+        single step scroll
+
+        * platform/qt/WheelEventQt.cpp:
+
+2009-02-25  Dirk Schulze  <krit@webkit.org>
+
+        Reviewed by Oliver Hunt.
+
+        Ported arcTo to Qt. Qt has no native support for arcTo. This changes
+        calculate the behavior of arcTo and draws it with lineTo and arc.
+
+        [QT] implement Canvas arcTo
+        https://bugs.webkit.org/show_bug.cgi?id=23873
+
+        * platform/graphics/qt/PathQt.cpp:
+        (WebCore::Path::addArcTo):
+
+2009-03-12  Adam Treat  <adam.treat@torchmobile.com>
+
+        Reviewed by Oliver Hunt.
+
+        https://bugs.webkit.org/show_bug.cgi?id=24498
+        Fix the Qt port to use the same algorithm for drawing dashed and dotted
+        borders as the other ports.  This makes the Qt port pixel-for-pixel perfect
+        compared to border drawing with Apple's canonical mac port and much closer
+        to konqueror and firefox behavior.
+
+        * platform/graphics/qt/GraphicsContextQt.cpp:
+        (WebCore::GraphicsContext::drawLine):
+
+2009-03-09  Adam Treat  <adam.treat@torchmobile.com>
+
+        Reviewed by George Staikos.
+
+        https://bugs.webkit.org/show_bug.cgi?id=24463
+        WebCore::qstring is detaching and copying twice for every single
+        WebCore::TextRun that is processed and drawn.  This elevates this method
+        to one of the top-ten most expensive methods in all of QtWebKit according
+        to profiling.  This changes the method so that QString only detaches
+        when absolutely necessary.
+
+        * platform/graphics/qt/FontQt.cpp:
+        (WebCore::qstring):
+        (WebCore::fixSpacing):
+        (WebCore::Font::drawComplexText):
+        (WebCore::Font::floatWidthForComplexText):
+        (WebCore::Font::offsetForPositionForComplexText):
+        (WebCore::Font::selectionRectForComplexText):
+
 2009-02-04  Simon Hausmann  <simon.hausmann@nokia.com>
 
         Unreviewed Qt build fix.
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp
index deeea99..4e78083 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp
@@ -37,20 +37,27 @@
 #if QT_VERSION >= 0x040400
 namespace WebCore {
 
-static QString qstring(const TextRun& run)
+static const QString qstring(const TextRun& run)
 {
-    QString string((QChar *)run.characters(), run.length());
-    QChar *uc = string.data();
+    //We don't detach
+    return QString::fromRawData((const QChar *)run.characters(), run.length());
+}
+
+static const QString fixSpacing(const QString &string)
+{
+    //Only detach if we're actually changing something
+    QString possiblyDetached = string;
     for (int i = 0; i < string.length(); ++i) {
-        if (Font::treatAsSpace(uc[i].unicode()))
-            uc[i] = 0x20;
-        else if (Font::treatAsZeroWidthSpace(uc[i].unicode()))
-            uc[i] = 0x200c;
+        const QChar c = string.at(i);
+        if (c.unicode() != 0x20 && Font::treatAsSpace(c.unicode())) {
+            possiblyDetached[i] = 0x20; //detach
+        } else if (c.unicode() != 0x200c && Font::treatAsZeroWidthSpace(c.unicode())) {
+            possiblyDetached[i] = 0x200c; //detach
+        }
     }
-    return string;
+    return possiblyDetached;
 }
 
-
 static QTextLine setupLayout(QTextLayout* layout, const TextRun& style)
 {
     int flags = style.rtl() ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight;
@@ -75,7 +82,7 @@ void Font::drawComplexText(GraphicsContext* ctx, const TextRun& run, const Float
     Color color = ctx->fillColor();
     p->setPen(QColor(color));
 
-    QString string = qstring(run);
+    const QString string = fixSpacing(qstring(run));
 
     // text shadow
     IntSize shadowSize;
@@ -144,7 +151,7 @@ float Font::floatWidthForComplexText(const TextRun& run) const
 {
     if (!run.length())
         return 0;
-    QString string = qstring(run);
+    const QString string = fixSpacing(qstring(run));
     QTextLayout layout(string, font());
     QTextLine line = setupLayout(&layout, run);
     int w = int(line.naturalTextWidth());
@@ -157,7 +164,7 @@ float Font::floatWidthForComplexText(const TextRun& run) const
 
 int Font::offsetForPositionForComplexText(const TextRun& run, int position, bool includePartialGlyphs) const
 {
-    QString string = qstring(run);
+    const QString string = fixSpacing(qstring(run));
     QTextLayout layout(string, font());
     QTextLine line = setupLayout(&layout, run);
     return line.xToCursor(position);
@@ -165,7 +172,7 @@ int Font::offsetForPositionForComplexText(const TextRun& run, int position, bool
 
 FloatRect Font::selectionRectForComplexText(const TextRun& run, const IntPoint& pt, int h, int from, int to) const
 {
-    QString string = qstring(run);
+    const QString string = fixSpacing(qstring(run));
     QTextLayout layout(string, font());
     QTextLine line = setupLayout(&layout, run);
 
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp
index 936c1ea..6c90ea3 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp
@@ -470,13 +470,21 @@ void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2)
     if (paintingDisabled())
         return;
 
+    StrokeStyle style = strokeStyle();
+    Color color = strokeColor();
+    if (style == NoStroke || !color.alpha())
+        return;
+
+    float width = strokeThickness();
+
     FloatPoint p1 = point1;
     FloatPoint p2 = point2;
+    bool isVerticalLine = (p1.x() == p2.x());
 
     QPainter *p = m_data->p();
     const bool antiAlias = p->testRenderHint(QPainter::Antialiasing);
     p->setRenderHint(QPainter::Antialiasing, m_data->antiAliasingForRectsAndLines);
-    adjustLineToPixelBoundaries(p1, p2, strokeThickness(), strokeStyle());
+    adjustLineToPixelBoundaries(p1, p2, width, style);
 
     IntSize shadowSize;
     int shadowBlur;
@@ -489,8 +497,76 @@ void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2)
         p->restore();
     }
 
+    int patWidth = 0;
+    switch (style) {
+        case NoStroke:
+        case SolidStroke:
+            break;
+        case DottedStroke:
+            patWidth = (int)width;
+            break;
+        case DashedStroke:
+            patWidth = 3 * (int)width;
+            break;
+    }
+
+    if (patWidth) {
+        p->save();
+
+        // Do a rect fill of our endpoints.  This ensures we always have the
+        // appearance of being a border.  We then draw the actual dotted/dashed line.
+        if (isVerticalLine) {
+            p->fillRect(FloatRect(p1.x() - width / 2, p1.y() - width, width, width), color);
+            p->fillRect(FloatRect(p2.x() - width / 2, p2.y(), width, width), color);
+        } else {
+            p->fillRect(FloatRect(p1.x() - width, p1.y() - width / 2, width, width), color);
+            p->fillRect(FloatRect(p2.x(), p2.y() - width / 2, width, width), color);
+        }
+
+        // Example: 80 pixels with a width of 30 pixels.
+        // Remainder is 20.  The maximum pixels of line we could paint
+        // will be 50 pixels.
+        int distance = (isVerticalLine ? (point2.y() - point1.y()) : (point2.x() - point1.x())) - 2*(int)width;
+        int remainder = distance % patWidth;
+        int coverage = distance - remainder;
+        int numSegments = coverage / patWidth;
+
+        float patternOffset = 0.0f;
+        // Special case 1px dotted borders for speed.
+        if (patWidth == 1)
+            patternOffset = 1.0f;
+        else {
+            bool evenNumberOfSegments = numSegments % 2 == 0;
+            if (remainder)
+                evenNumberOfSegments = !evenNumberOfSegments;
+            if (evenNumberOfSegments) {
+                if (remainder) {
+                    patternOffset += patWidth - remainder;
+                    patternOffset += remainder / 2;
+                } else
+                    patternOffset = patWidth / 2;
+            } else {
+                if (remainder)
+                    patternOffset = (patWidth - remainder)/2;
+            }
+        }
+
+        QVector<qreal> dashes;
+        dashes << qreal(patWidth) / width << qreal(patWidth) / width;
+
+        QPen pen = p->pen();
+        pen.setWidthF(width);
+        pen.setCapStyle(Qt::FlatCap);
+        pen.setDashPattern(dashes);
+        pen.setDashOffset(patternOffset / width);
+        p->setPen(pen);
+    }
+
     p->drawLine(p1, p2);
 
+    if (patWidth)
+        p->restore();
+
     p->setRenderHint(QPainter::Antialiasing, antiAlias);
 }
 
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp
index d1009b5..29a02d4 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2008 Holger Hans Peter Freyther
+ * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,7 +32,6 @@
 #include "GraphicsContext.h"
 #include "ImageData.h"
 #include "MIMETypeRegistry.h"
-#include "NotImplemented.h"
 #include "StillImageQt.h"
 
 #include <QBuffer>
@@ -111,9 +111,7 @@ PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const
         endy = m_size.height();
     int numRows = endy - originy;
 
-    QImage image = m_data.m_pixmap.toImage();
-    if (image.format() != QImage::Format_ARGB32)
-        image = image.convertToFormat(QImage::Format_ARGB32);
+    QImage image = m_data.m_pixmap.toImage().convertToFormat(QImage::Format_ARGB32);
     ASSERT(!image.isNull());
 
     unsigned destBytesPerRow = 4 * rect.width();
@@ -134,9 +132,58 @@ PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const
     return result;
 }
 
-void ImageBuffer::putImageData(ImageData*, const IntRect&, const IntPoint&)
+void ImageBuffer::putImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
 {
-    notImplemented();
+    ASSERT(sourceRect.width() > 0);
+    ASSERT(sourceRect.height() > 0);
+
+    int originx = sourceRect.x();
+    int destx = destPoint.x() + sourceRect.x();
+    ASSERT(destx >= 0);
+    ASSERT(destx < m_size.width());
+    ASSERT(originx >= 0);
+    ASSERT(originx <= sourceRect.right());
+
+    int endx = destPoint.x() + sourceRect.right();
+    ASSERT(endx <= m_size.width());
+
+    int numColumns = endx - destx;
+
+    int originy = sourceRect.y();
+    int desty = destPoint.y() + sourceRect.y();
+    ASSERT(desty >= 0);
+    ASSERT(desty < m_size.height());
+    ASSERT(originy >= 0);
+    ASSERT(originy <= sourceRect.bottom());
+
+    int endy = destPoint.y() + sourceRect.bottom();
+    ASSERT(endy <= m_size.height());
+    int numRows = endy - desty;
+
+    unsigned srcBytesPerRow = 4 * source->width();
+
+    bool isPainting = m_data.m_painter->isActive();
+    if (isPainting)
+        m_data.m_painter->end();
+
+    QImage image = m_data.m_pixmap.toImage().convertToFormat(QImage::Format_ARGB32);
+    ASSERT(!image.isNull());
+
+    unsigned char* srcRows = source->data()->data() + originy * srcBytesPerRow + originx * 4;
+    for (int y = 0; y < numRows; ++y) {
+        quint32* scanLine = reinterpret_cast<quint32*>(image.scanLine(y + desty));
+        for (int x = 0; x < numColumns; x++) {
+            int basex = x * 4;
+            scanLine[x + destx] = reinterpret_cast<quint32*>(srcRows + basex)[0];
+        }
+
+        srcRows += srcBytesPerRow;
+    }
+
+    m_data.m_pixmap = QPixmap::fromImage(image);
+
+    if (isPainting)
+        m_data.m_painter->begin(&m_data.m_pixmap);
 }
 
 // We get a mimeType here but QImageWriter does not support mimetypes but
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageQt.cpp
index be7d1e0..e266c07 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageQt.cpp
@@ -109,6 +109,8 @@ void Image::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRect, const
     ctxt->save();
     ctxt->setCompositeOperation(op);
     QPainter* p = ctxt->platformContext();
+    if (!pixmap.hasAlpha() && p->compositionMode() == QPainter::CompositionMode_SourceOver)
+        p->setCompositionMode(QPainter::CompositionMode_Source);
     p->setBrushOrigin(phase);
     p->fillRect(destRect, b);
     ctxt->restore();
@@ -146,6 +148,9 @@ void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dst,
 
     QPainter* painter(ctxt->platformContext());
 
+    if (!image->hasAlpha() && painter->compositionMode() == QPainter::CompositionMode_SourceOver)
+        painter->setCompositionMode(QPainter::CompositionMode_Source);
+
     // Test using example site at
     // http://www.meyerweb.com/eric/css/edge/complexspiral/demo.html    
     painter->drawPixmap(dst, *image, src);
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp
index 90b342e..e68be2b 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp
@@ -1,6 +1,7 @@
 /*
- * Copyright (C) 2006 Zack Rusin <zack@kde.org>
- *               2006 Rob Buis   <buis@kde.org>
+ * Copyright (C) 2006 Zack Rusin   <zack@kde.org>
+ *               2006 Rob Buis     <buis@kde.org>
+ *               2009 Dirk Schulze <krit@webkit.org>
  *
  * All rights reserved.
  *
@@ -139,9 +140,72 @@ void Path::addBezierCurveTo(const FloatPoint& cp1, const FloatPoint& cp2, const
 
 void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)
 {
-    //FIXME: busted
-    qWarning("arcTo is busted");
-    m_path->arcTo(p1.x(), p1.y(), p2.x(), p2.y(), radius, 90);
+    FloatPoint p0(m_path->currentPosition());
+
+    if ((p1.x() == p0.x() && p1.y() == p0.y()) || (p1.x() == p2.x() && p1.y() == p2.y()) || radius == 0.f) {
+        m_path->lineTo(p1);
+        return;
+    }
+
+    FloatPoint p1p0((p0.x() - p1.x()),(p0.y() - p1.y()));
+    FloatPoint p1p2((p2.x() - p1.x()),(p2.y() - p1.y()));
+    float p1p0_length = sqrtf(p1p0.x() * p1p0.x() + p1p0.y() * p1p0.y());
+    float p1p2_length = sqrtf(p1p2.x() * p1p2.x() + p1p2.y() * p1p2.y());
+
+    double cos_phi = (p1p0.x() * p1p2.x() + p1p0.y() * p1p2.y()) / (p1p0_length * p1p2_length);
+    // all points on a line logic
+    if (cos_phi == -1) {
+        m_path->lineTo(p1);
+        return;
+    }
+    if (cos_phi == 1) {
+        // add infinite far away point
+        unsigned int max_length = 65535;
+        double factor_max = max_length / p1p0_length;
+        FloatPoint ep((p0.x() + factor_max * p1p0.x()), (p0.y() + factor_max * p1p0.y()));
+        m_path->lineTo(ep);
+        return;
+    }
+
+    float tangent = radius / tan(acos(cos_phi) / 2);
+    float factor_p1p0 = tangent / p1p0_length;
+    FloatPoint t_p1p0((p1.x() + factor_p1p0 * p1p0.x()), (p1.y() + factor_p1p0 * p1p0.y()));
+
+    FloatPoint orth_p1p0(p1p0.y(), -p1p0.x());
+    float orth_p1p0_length = sqrt(orth_p1p0.x() * orth_p1p0.x() + orth_p1p0.y() * orth_p1p0.y());
+    float factor_ra = radius / orth_p1p0_length;
+
+    // angle between orth_p1p0 and p1p2 to get the right vector orthographic to p1p0
+    double cos_alpha = (orth_p1p0.x() * p1p2.x() + orth_p1p0.y() * p1p2.y()) / (orth_p1p0_length * p1p2_length);
+    if (cos_alpha < 0.f)
+        orth_p1p0 = FloatPoint(-orth_p1p0.x(), -orth_p1p0.y());
+
+    FloatPoint p((t_p1p0.x() + factor_ra * orth_p1p0.x()), (t_p1p0.y() + factor_ra * orth_p1p0.y()));
+
+    // calculate angles for addArc
+    orth_p1p0 = FloatPoint(-orth_p1p0.x(), -orth_p1p0.y());
+    float sa = acos(orth_p1p0.x() / orth_p1p0_length);
+    if (orth_p1p0.y() < 0.f)
+        sa = 2 * piDouble - sa;
+
+    // anticlockwise logic
+    bool anticlockwise = false;
+
+    float factor_p1p2 = tangent / p1p2_length;
+    FloatPoint t_p1p2((p1.x() + factor_p1p2 * p1p2.x()), (p1.y() + factor_p1p2 * p1p2.y()));
+    FloatPoint orth_p1p2((t_p1p2.x() - p.x()),(t_p1p2.y() - p.y()));
+    float orth_p1p2_length = sqrtf(orth_p1p2.x() * orth_p1p2.x() + orth_p1p2.y() * orth_p1p2.y());
+    float ea = acos(orth_p1p2.x() / orth_p1p2_length);
+    if (orth_p1p2.y() < 0)
+        ea = 2 * piDouble - ea;
+    if ((sa > ea) && ((sa - ea) < piDouble))
+        anticlockwise = true;
+    if ((sa < ea) && ((ea - sa) > piDouble))
+        anticlockwise = true;
+
+    m_path->lineTo(t_p1p0);
+
+    addArc(p, radius, sa, ea, anticlockwise);
 }
 
 void Path::closeSubpath()
diff --git a/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.cpp b/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.cpp
index 2de2125..2c730a6 100644
--- a/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.cpp
@@ -269,8 +269,10 @@ void QNetworkReplyHandler::sendResponseIfNeeded()
 
     const bool isLocalFileReply = (m_reply->url().scheme() == QLatin1String("file"));
     int statusCode = m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-    if (!isLocalFileReply)
+    if (!isLocalFileReply) {
         response.setHTTPStatusCode(statusCode);
+        response.setHTTPStatusText(m_reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toByteArray().constData());
+    }
     else if (m_reply->error() == QNetworkReply::ContentNotFoundError)
         response.setHTTPStatusCode(404);
 
diff --git a/src/3rdparty/webkit/WebCore/platform/qt/WheelEventQt.cpp b/src/3rdparty/webkit/WebCore/platform/qt/WheelEventQt.cpp
index cc8acd2..b25ae7a 100644
--- a/src/3rdparty/webkit/WebCore/platform/qt/WheelEventQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/qt/WheelEventQt.cpp
@@ -21,7 +21,9 @@
 #include "PlatformWheelEvent.h"
 
 #include "PlatformMouseEvent.h"
+#include "Scrollbar.h"
 
+#include <qapplication.h>
 #include <QWheelEvent>
 
 namespace WebCore {
@@ -54,9 +56,14 @@ PlatformWheelEvent::PlatformWheelEvent(QWheelEvent* e)
         m_deltaY = (e->delta() / 120);
     }
 
-    // FIXME: retrieve the user setting for the number of lines to scroll on each wheel event
-    m_deltaX *= horizontalLineMultiplier();
-    m_deltaY *= verticalLineMultiplier();
+    m_deltaX *= QApplication::wheelScrollLines();
+    // use the same single scroll step as QTextEdit (in
+    // QTextEditPrivate::init [h,v]bar->setSingleStep )
+    // and divide by the default WebKit scroll step to
+    // get the Qt mouse wheel scroll behavior
+    static const float cDefaultQtScrollStep = 20.f;
+    m_deltaY *= QApplication::wheelScrollLines() *
+                (cDefaultQtScrollStep / cMouseWheelPixelsPerLineStep);
 }
 #endif // QT_NO_WHEELEVENT
 
diff --git a/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.cpp b/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.cpp
index 1d7d570..3229922 100644
--- a/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.cpp
+++ b/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.cpp
@@ -220,11 +220,11 @@ NPError PluginView::getValueStatic(NPNVariable variable, void* value)
 
     switch (variable) {
     case NPNVToolkit:
-        *((uint32 *)value) = 0;
+        *static_cast<uint32*>(value) = 0;
         return NPERR_NO_ERROR;
 
     case NPNVjavascriptEnabledBool:
-        *((uint32 *)value) = true;
+        *static_cast<NPBool*>(value) = true;
         return NPERR_NO_ERROR;
 
     default:
@@ -275,7 +275,7 @@ NPError PluginView::getValue(NPNVariable variable, void* value)
     }
 
     case NPNVsupportsCoreGraphicsBool:
-        *((uint32 *)value) = true;
+        *static_cast<NPBool*>(value) = true;
         return NPERR_NO_ERROR;
 
     default:
diff --git a/src/3rdparty/webkit/WebCore/plugins/qt/PluginViewQt.cpp b/src/3rdparty/webkit/WebCore/plugins/qt/PluginViewQt.cpp
index 5aa8933..c8dd0e5 100644
--- a/src/3rdparty/webkit/WebCore/plugins/qt/PluginViewQt.cpp
+++ b/src/3rdparty/webkit/WebCore/plugins/qt/PluginViewQt.cpp
@@ -301,15 +301,15 @@ NPError PluginView::getValueStatic(NPNVariable variable, void* value)
 {
     switch (variable) {
     case NPNVToolkit:
-        *((uint32 *)value) = 0;
+        *static_cast<uint32*>(value) = 0;
         return NPERR_NO_ERROR;
 
     case NPNVSupportsXEmbedBool:
-        *((uint32 *)value) = true;
+        *static_cast<NPBool*>(value) = true;
         return NPERR_NO_ERROR;
 
     case NPNVjavascriptEnabledBool:
-        *((uint32 *)value) = true;
+        *static_cast<NPBool*>(value) = true;
         return NPERR_NO_ERROR;
 
     default:
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp b/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp
index e17306d..01b68eb 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp
@@ -1095,7 +1095,7 @@ QVariant QWebPage::inputMethodQuery(Qt::InputMethodQuery property) const
     This enum describes the types of action which can be performed on the web page.
 
     Actions only have an effect when they are applicable. The availability of
-    actions can be be determined by checking \l{QAction::}{enabled()} on the
+    actions can be be determined by checking \l{QAction::}{isEnabled()} on the
     action returned by \l{QWebPage::}{action()}.
 
     One method of enabling the text editing, cursor movement, and text selection actions
@@ -1198,18 +1198,18 @@ QVariant QWebPage::inputMethodQuery(Qt::InputMethodQuery property) const
 
     Suppose we have a \c Thumbnail class as follows:
 
-    \snippet doc/src/snippets/webkit/webpage/main.cpp 0
+    \snippet webkitsnippets/webpage/main.cpp 0
 
     The \c Thumbnail's constructor takes in a \a url. We connect our QWebPage
     object's \l{QWebPage::}{loadFinished()} signal to our private slot,
     \c render().
 
-    \snippet doc/src/snippets/webkit/webpage/main.cpp 1
+    \snippet webkitsnippets/webpage/main.cpp 1
 
     The \c render() function shows how we can paint a thumbnail using a
     QWebPage object.
 
-    \snippet doc/src/snippets/webkit/webpage/main.cpp 2
+    \snippet webkitsnippets/webpage/main.cpp 2
 
     We begin by setting the \l{QWebPage::viewportSize()}{viewportSize} and
     then we instantiate a QImage object, \c image, with the same size as our
@@ -1450,9 +1450,16 @@ void QWebPage::triggerAction(WebAction action, bool checked)
             openNewWindow(url, frame);
             break;
         }
-        case CopyLinkToClipboard:
+        case CopyLinkToClipboard: {
+#if defined(Q_WS_X11)
+            bool oldSelectionMode = Pasteboard::generalPasteboard()->isSelectionMode();
+            Pasteboard::generalPasteboard()->setSelectionMode(true);
+            editor->copyURL(d->hitTestResult.linkUrl(), d->hitTestResult.linkText());
+            Pasteboard::generalPasteboard()->setSelectionMode(oldSelectionMode);
+#endif
             editor->copyURL(d->hitTestResult.linkUrl(), d->hitTestResult.linkText());
             break;
+        }
         case OpenImageInNewWindow:
             openNewWindow(d->hitTestResult.imageUrl(), frame);
             break;
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebview.cpp b/src/3rdparty/webkit/WebKit/qt/Api/qwebview.cpp
index a843eba..9753f4f 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebview.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebview.cpp
@@ -86,7 +86,7 @@ public:
     Qt Widgets, the show() function must be invoked in order to display
     QWebView. The snippet below illustrates this:
 
-    \snippet doc/src/snippets/webkit/simple/main.cpp Using QWebView
+    \snippet webkitsnippets/simple/main.cpp Using QWebView
 
     Alternatively, setUrl() can also be used to load a web site. If you have
     the HTML content readily available, you can use setHtml() instead.
@@ -325,7 +325,7 @@ void QWebView::setContent(const QByteArray &data, const QString &mimeType, const
 
     It is equivalent to
 
-    \snippet doc/src/snippets/code/src_3rdparty_webkit_WebKit_qt_Api_qwebview.cpp 0
+    \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 0
 */
 QWebHistory *QWebView::history() const
 {
@@ -337,7 +337,7 @@ QWebHistory *QWebView::history() const
 
     It is equivalent to
 
-    \snippet doc/src/snippets/code/src_3rdparty_webkit_WebKit_qt_Api_qwebview.cpp 1
+    \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 1
 
     \sa QWebSettings::globalSettings()
 */
@@ -429,7 +429,7 @@ QAction *QWebView::pageAction(QWebPage::WebAction action) const
     The following example triggers the copy action and therefore copies any
     selected text to the clipboard.
 
-    \snippet doc/src/snippets/code/src_3rdparty_webkit_WebKit_qt_Api_qwebview.cpp 2
+    \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 2
 
     \sa pageAction()
 */
@@ -606,7 +606,7 @@ void QWebView::print(QPrinter *printer) const
 
     It is equivalent to
 
-    \snippet doc/src/snippets/code/src_3rdparty_webkit_WebKit_qt_Api_qwebview.cpp 3
+    \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 3
 
     \sa reload(), pageAction(), loadFinished()
 */
@@ -622,7 +622,7 @@ void QWebView::stop()
 
     It is equivalent to
 
-    \snippet doc/src/snippets/code/src_3rdparty_webkit_WebKit_qt_Api_qwebview.cpp 4
+    \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 4
 
     \sa forward(), pageAction()
 */
@@ -638,7 +638,7 @@ void QWebView::back()
 
     It is equivalent to
 
-    \snippet doc/src/snippets/code/src_3rdparty_webkit_WebKit_qt_Api_qwebview.cpp 5
+    \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 5
 
     \sa back(), pageAction()
 */
diff --git a/src/3rdparty/webkit/WebKit/qt/ChangeLog b/src/3rdparty/webkit/WebKit/qt/ChangeLog
index 5a23200..c3bd633 100644
--- a/src/3rdparty/webkit/WebKit/qt/ChangeLog
+++ b/src/3rdparty/webkit/WebKit/qt/ChangeLog
@@ -1,3 +1,42 @@
+2009-04-24  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Rubber-stamped by Ariya Hidayat.
+
+        Fix qdoc warning about link to QAction::isEnabled.
+
+        * Api/qwebpage.cpp:
+
+2009-04-24  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Reviewed by Ariya Hidayat.
+
+        Added support for generating API docs in the Qt build using "make docs"
+
+        Added code snippets and overview from the Qt sources references in the API docs.
+
+        * Api/qwebpage.cpp: Adjust paths to snippets.
+        * Api/qwebview.cpp: Ditto.
+        * docs/docs.pri: Added.
+        * docs/qtwebkit.qdoc: Added.
+        * docs/qtwebkit.qdocconf: Added.
+        * docs/webkitsnippets/qtwebkit_build_snippet.qdoc: Added.
+        * docs/webkitsnippets/qtwebkit_qwebview_snippet.cpp: Added.
+        * docs/webkitsnippets/simple/main.cpp: Added.
+        * docs/webkitsnippets/simple/simple.pro: Added.
+        * docs/webkitsnippets/webpage/main.cpp: Added.
+        * docs/webkitsnippets/webpage/webpage.pro: Added.
+
+2009-03-02  Benjamin C Meyer  <benjamin.meyer@torchmobile.com>
+
+        Reviewed by George Staikos.
+
+        https://bugs.webkit.org/show_bug.cgi?id=21230
+        On X11 match the behavior of Firefox and also copy the url to the
+        clipboard selection when the action Copy Link Location is executed.
+
+        * Api/qwebpage.cpp:
+        (QWebPage::triggerAction):
+
 2009-03-07  Adam Treat  <adam.treat@torchmobile.com>
 
         Reviewed by Cameron Zwarich.
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/docs.pri b/src/3rdparty/webkit/WebKit/qt/docs/docs.pri
new file mode 100644
index 0000000..4a8c165
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/docs.pri
@@ -0,0 +1,15 @@
+include(../../../WebKit.pri)
+
+unix {
+    QDOC = SRCDIR=$$PWD/../../.. OUTPUT_DIR=$$OUTPUT_DIR $$(QTDIR)/tools/qdoc3/qdoc3
+} else {
+    QDOC = $$(QTDIR)\tools\qdoc3\release\qdoc3.exe
+}
+
+unix {
+docs.commands = $$QDOC $$PWD/qtwebkit.qdocconf
+} else {
+docs.commands = \"$$QDOC $$PWD/qtwebkit.qdocconf\"
+}
+
+QMAKE_EXTRA_TARGETS += docs
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdoc b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdoc
new file mode 100644
index 0000000..06305e0
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdoc
@@ -0,0 +1,189 @@
+/*!
+    \module QtWebKit
+    \title QtWebKit Module
+    \contentspage Qt's Modules
+    \previouspage QtSvg
+    \nextpage QtXml
+    \ingroup architecture
+    \ingroup modules
+    \brief An introduction to the QtWebKit module.
+
+    \keyword Browser
+    \keyword Web Browser
+
+    \since 4.4
+
+    QtWebKit provides a Web browser engine that makes it easy to embed content
+    from the World Wide Web into your Qt application. At the same time Web
+    content can be enhanced with native controls.
+
+    QtWebKit provides facilities for rendering of HyperText Markup Language
+    (HTML), Extensible HyperText Markup Language (XHTML) and Scalable Vector
+    Graphics (SVG) documents, styled using Cascading Style Sheets (CSS) and
+    scripted with JavaScript.
+
+    A bridge between the JavaScript execution environment and the Qt object
+    model makes it possible for custom QObjects to be scripted. Integration
+    with the Qt networking module enables Web pages to be transparently loaded
+    from Web servers, the local file system or even the Qt resource system.
+
+    In addition to providing pure rendering features, HTML documents can be
+    made fully editable to the user through the use of the \c{contenteditable}
+    attribute on HTML elements.
+
+    QtWebKit is based on the Open Source WebKit engine. More information about
+    WebKit itself can be found on the \l{WebKit Open Source Project} Web site.
+
+    The QtWebKit module is part of the \l{Qt Full Framework Edition}, and the
+    \l{Open Source Versions of Qt}.
+
+    \note Building the QtWebKit module with debugging symbols is problematic
+    on many platforms due to the size of the WebKit engine. We recommend
+    building the module in release mode only for embedded platforms.
+
+    \note Web site icons, also known as "FavIcons", are currently not supported
+    on Windows. We plan to address this in a future release.
+
+    \note WebKit has certain minimum requirements that must be met on
+    Embedded Linux systems. See the \l{Qt for Embedded Linux Requirements}
+    document for more information.
+
+    Topics:
+
+    \tableofcontents
+
+    \section1 Configuring the Build Process
+
+    Applications that use QtWebKit's classes need to be configured to be built
+    against the QtWebKit module. The following declaration in a \c qmake
+    project file ensures that an application is compiled and linked
+    appropriately:
+
+    \snippet webkitsnippets/qtwebkit_build_snippet.qdoc 0
+
+    This line is necessary because only the QtCore and QtGui modules are used
+    in the default build process.
+
+    To include the definitions of the module's classes, use the following
+    directive:
+
+    \snippet webkitsnippets/qtwebkit_build_snippet.qdoc 1
+
+    \section1 Architecture
+
+    The easiest way to render content is through the QWebView class. As a
+    widget it can be embedded into your forms or a graphics view, and it
+    provides convenience functions for downloading and rendering web sites.
+
+    \snippet webkitsnippets/simple/main.cpp Using QWebView
+
+    QWebView acts as a view onto Web pages, each of which is represented by an
+    instance of the QWebPage class. QWebPage provides access to the document
+    structure in a page, describing features such as frames, the navigation
+    history, and the undo/redo stack for editable content.
+
+    HTML documents can be nested using frames in a frameset. An individual
+    frame in HTML is represented using the QWebFrame class. It includes the
+    bridge to the JavaScript window object and can be painted using QPainter.
+    Each QWebPage has one QWebFrame object as its main frame.
+
+    Individual browser features, defaults and other settings can be configured
+    through the QWebSettings class. It is possible to provide defaults for all
+    QWebPage instances through the default settings. Individual attributes
+    can be overidden by the page specific settings object.
+
+    \section1 Netscape Plugin Support
+
+    Since WebKit supports the Netscape Plugin API, Qt applications can display
+    Web pages that embed common plugins, as long as the user has the appropriate
+    binary files for those plugins installed.
+
+    The following locations are searched for plugins:
+
+    \table
+    \header \o Linux/Unix  \o Windows
+    \row \o{1,3}
+    \list
+    \o \c{.mozilla/plugins} in the user's home directory
+    \o \c{.netscape/plugins} in the user's home directory
+    \o System locations, such as
+    \list
+    \o \c{/usr/lib/browser/plugins}
+    \o \c{/usr/local/lib/mozilla/plugins}
+    \o \c{/usr/lib/firefox/plugins}
+    \o \c{/usr/lib64/browser-plugins}
+    \o \c{/usr/lib/browser-plugins}
+    \o \c{/usr/lib/mozilla/plugins}
+    \o \c{/usr/local/netscape/plugins}
+    \o \c{/opt/mozilla/plugins}
+    \o \c{/opt/mozilla/lib/plugins}
+    \o \c{/opt/netscape/plugins}
+    \o \c{/opt/netscape/communicator/plugins}
+    \o \c{/usr/lib/netscape/plugins}
+    \o \c{/usr/lib/netscape/plugins-libc5}
+    \o \c{/usr/lib/netscape/plugins-libc6}
+    \o \c{/usr/lib64/netscape/plugins}
+    \o \c{/usr/lib64/mozilla/plugins}
+    \endlist
+    \o Locations specified by environment variables:
+    \list
+    \o \c{$MOZILLA_HOME/plugins}
+    \o \c{$MOZ_PLUGIN_PATH}
+    \o \c{$QTWEBKIT_PLUGIN_PATH}
+    \endlist
+    \endlist
+
+    \o
+    \list
+    \o The user's \c{Application Data\Mozilla\plugins} directory
+    \o Standard system locations of plugins for Quicktime, Flash, etc.
+    \endlist
+
+    \row
+    \raw HTML
+    <th class="qt-style">Mac OS X</th>
+    \endraw
+    \row
+    \o
+    \list
+    \o \c{Library/Internet Plug-Ins} in the user's home directory
+    \o The system \c{/Library/Internet Plug-Ins} directory
+    \endlist
+    \endtable
+
+    \section1 License Information
+
+    This is a snapshot of the Qt port of WebKit. The exact version information
+    can be found in the \c{src/3rdparty/webkit/VERSION} file supplied with Qt.
+
+    Qt Commercial Edition licensees that wish to distribute applications that
+    use the QtWebKit module need to be aware of their obligations under the
+    GNU Lesser General Public License (LGPL). 
+
+    Developers using the Open Source Edition can choose to redistribute
+    the module under the appropriate version of the GNU LGPL; version 2.1
+    for applications and libraries licensed under the GNU GPL version 2,
+    or version 3 for applications and libraries licensed under the GNU
+    GPL version 2.
+
+    \legalese
+    WebKit is licensed under the GNU Library General Public License.
+    Individual contributor names and copyright dates can be found
+    inline in the code.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+    \endlegalese
+*/
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdocconf b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdocconf
new file mode 100644
index 0000000..e60e586
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdocconf
@@ -0,0 +1,195 @@
+# Run qdoc from the directory that contains this file.
+
+project     = qtwebkit
+description = "Qt WebKit API Documentation"
+
+headerdirs = $SRCDIR/WebKit/qt/Api
+sourcedirs = $SRCDIR/WebKit/qt/Api $SRCDIR/WebKit/qt/docs
+outputdir = $OUTPUT_DIR/doc/html
+outputformats = HTML
+sources.fileextensions  = "*.cpp *.doc *.qdoc *.h"
+exampledirs = $SRCDIR/WebKit/qt/docs
+
+indexes = $QTDIR/doc/html/qt.index
+
+# macros.qdocconf
+
+macro.aring.HTML        = "&aring;"
+macro.Auml.HTML         = "&Auml;"
+macro.author            = "\\bold{Author:}"
+macro.br.HTML           = "<br />"
+macro.BR.HTML           = "<br />"
+macro.aacute.HTML       = "&aacute;"
+macro.eacute.HTML       = "&eacute;"
+macro.iacute.HTML       = "&iacute;"
+macro.gui               = "\\bold"
+macro.hr.HTML           = "<hr />"
+macro.key               = "\\bold"
+macro.menu              = "\\bold"
+macro.note              = "\\bold{Note:}"
+macro.oslash.HTML       = "&oslash;"
+macro.ouml.HTML         = "&ouml;"
+macro.QA                = "\\e{Qt Assistant}"
+macro.QD                = "\\e{Qt Designer}"
+macro.QL                = "\\e{Qt Linguist}"
+macro.param             = "\\e"
+macro.raisedaster.HTML  = "<sup>*</sup>"
+macro.reg.HTML          = "<sup>&reg;</sup>"
+macro.return            = "Returns"
+macro.starslash         = "\\c{*/}"
+macro.uuml.HTML         = "&uuml;"
+macro.mdash.HTML        = "&mdash;"
+
+# compat.qdocconf
+
+alias.i				= e
+alias.include			= input
+
+macro.0                         = "\\\\0"
+macro.b                         = "\\\\b"
+macro.n                         = "\\\\n"
+macro.r                         = "\\\\r"
+macro.i                         = "\\o"
+macro.i11                       = "\\o{1,1}"
+macro.i12                       = "\\o{1,2}"
+macro.i13                       = "\\o{1,3}"
+macro.i14                       = "\\o{1,4}"
+macro.i15                       = "\\o{1,5}"
+macro.i16                       = "\\o{1,6}"
+macro.i17                       = "\\o{1,7}"
+macro.i18                       = "\\o{1,8}"
+macro.i19                       = "\\o{1,9}"
+macro.i21                       = "\\o{2,1}"
+macro.i31                       = "\\o{3,1}"
+macro.i41                       = "\\o{4,1}"
+macro.i51                       = "\\o{5,1}"
+macro.i61                       = "\\o{6,1}"
+macro.i71                       = "\\o{7,1}"
+macro.i81                       = "\\o{8,1}"
+macro.i91                       = "\\o{9,1}"
+macro.img                       = "\\image"
+macro.endquote                  = "\\endquotation"
+
+spurious			= "Missing comma in .*" \
+				  "Missing pattern .*"
+
+# Doxygen compatibility commands
+
+macro.see                       = "\\sa"
+macro.function                  = "\\fn"
+
+# qt-cpp-ignore.qdocconf
+
+Cpp.ignoretokens        = QAXFACTORY_EXPORT \
+                          QDESIGNER_COMPONENTS_LIBRARY \
+                          QDESIGNER_EXTENSION_LIBRARY \
+                          QDESIGNER_SDK_LIBRARY \
+                          QDESIGNER_SHARED_LIBRARY \
+                          QDESIGNER_UILIB_LIBRARY \
+                          QM_EXPORT_CANVAS \
+                          QM_EXPORT_DNS \
+                          QM_EXPORT_DOM \
+                          QM_EXPORT_FTP \
+                          QM_EXPORT_HTTP \
+                          QM_EXPORT_ICONVIEW \
+                          QM_EXPORT_NETWORK \
+                          QM_EXPORT_OPENGL \
+                          QM_EXPORT_SQL \
+                          QM_EXPORT_TABLE \
+                          QM_EXPORT_WORKSPACE \
+                          QM_EXPORT_XML \
+                          QT_ASCII_CAST_WARN \
+                          QT_ASCII_CAST_WARN_CONSTRUCTOR \
+                          QT_BEGIN_HEADER \
+                          QT_DESIGNER_STATIC \
+                          QT_END_HEADER \
+                          QT_FASTCALL \
+                          QT_WIDGET_PLUGIN_EXPORT \
+                          Q_COMPAT_EXPORT \
+                          Q_CORE_EXPORT \
+                          Q_EXPLICIT \
+                          Q_EXPORT \
+                          Q_EXPORT_CODECS_CN \
+                          Q_EXPORT_CODECS_JP \
+                          Q_EXPORT_CODECS_KR \
+                          Q_EXPORT_PLUGIN \
+                          Q_GFX_INLINE \
+                          Q_GUI_EXPORT \
+                          Q_GUI_EXPORT_INLINE \
+                          Q_GUI_EXPORT_STYLE_CDE \
+                          Q_GUI_EXPORT_STYLE_COMPACT \
+                          Q_GUI_EXPORT_STYLE_MAC \
+                          Q_GUI_EXPORT_STYLE_MOTIF \
+                          Q_GUI_EXPORT_STYLE_MOTIFPLUS \
+                          Q_GUI_EXPORT_STYLE_PLATINUM \
+                          Q_GUI_EXPORT_STYLE_POCKETPC \
+                          Q_GUI_EXPORT_STYLE_SGI \
+                          Q_GUI_EXPORT_STYLE_WINDOWS \
+                          Q_GUI_EXPORT_STYLE_WINDOWSXP \
+                          QHELP_EXPORT \
+                          Q_INLINE_TEMPLATE \
+                          Q_INTERNAL_WIN_NO_THROW \
+                          Q_NETWORK_EXPORT \
+                          Q_OPENGL_EXPORT \
+                          Q_OUTOFLINE_TEMPLATE \
+                          Q_SQL_EXPORT \
+                          Q_SVG_EXPORT \
+                          Q_SCRIPT_EXPORT \
+                          Q_TESTLIB_EXPORT \
+                          Q_TYPENAME \
+                          Q_XML_EXPORT \
+                          Q_XMLSTREAM_EXPORT \
+                          Q_XMLPATTERNS_EXPORT \
+                          QDBUS_EXPORT \
+                          QT_BEGIN_NAMESPACE \
+                          QT_BEGIN_INCLUDE_NAMESPACE \
+                          QT_END_NAMESPACE \
+                          QT_END_INCLUDE_NAMESPACE \
+                          PHONON_EXPORT \
+                          EXTENSIONSYSTEM_EXPORT
+Cpp.ignoredirectives    = Q_DECLARE_HANDLE \
+                          Q_DECLARE_INTERFACE \
+                          Q_DECLARE_METATYPE \
+                          Q_DECLARE_OPERATORS_FOR_FLAGS \
+                          Q_DECLARE_PRIVATE \
+                          Q_DECLARE_PUBLIC \
+                          Q_DECLARE_SHARED \
+                          Q_DECLARE_TR_FUNCTIONS \
+                          Q_DECLARE_TYPEINFO \
+                          Q_DISABLE_COPY \
+                          QT_FORWARD_DECLARE_CLASS \
+                          Q_DUMMY_COMPARISON_OPERATOR \
+                          Q_ENUMS \
+                          Q_FLAGS \
+                          Q_INTERFACES \
+                          __attribute__ \
+                          K_DECLARE_PRIVATE \
+                          PHONON_OBJECT \
+                          PHONON_HEIR
+
+
+
+HTML.style              = "" \
+                          "h3.fn,span.fn { margin-left: 1cm; text-indent: -1cm; }"\
+                          "a:link { color: #004faf; text-decoration: none }"\
+                          "a:visited { color: #672967; text-decoration: none }"\
+                          "td.postheader { font-family: sans-serif }"\
+                          "tr.address { font-family: sans-serif }"\
+                          "body { background: #ffffff; color: black }"\
+                          "table tr.odd { background: #f0f0f0; color: black; }"\
+                          "table tr.even { background: #e4e4e4; color: black; }"\
+                          "table.annotated th { padding: 3px; text-align: left }"\
+                          "table.annotated td { padding: 3px; } "\
+                          "table tr pre { padding-top: none; padding-bottom: none; padding-left: none; padding-right: none; border: none; background: none }"\
+                          "tr.qt-style { background: #a2c511; color: black }"\
+                          "body pre { padding: 0.2em; border: #e7e7e7 1px solid; background: #f1f1f1; color: black }"\
+                          "span.preprocessor, span.preprocessor a { color: darkblue; }"\
+                          "span.comment { color: darkred; font-style: italic }"\
+                          "span.string,span.char { color: darkgreen; }"\
+                          ".title { text-align: center }"\
+                          ".subtitle { font-size: 0.8em }"\
+                          ".small-subtitle { font-size: 0.65em }"
+
+HTML.postheader         = ""
+
+HTML.footer             = ""
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_build_snippet.qdoc b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_build_snippet.qdoc
new file mode 100644
index 0000000..d4fc2bd
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_build_snippet.qdoc
@@ -0,0 +1,8 @@
+//! [0]
+QT += webkit
+//! [0]
+
+
+//! [1]
+#include <QtWebKit>
+//! [1]
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_qwebview_snippet.cpp b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_qwebview_snippet.cpp
new file mode 100644
index 0000000..f04cd29
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_qwebview_snippet.cpp
@@ -0,0 +1,35 @@
+
+void wrapInFunction()
+{
+
+//! [0]
+    view->page()->history();
+//! [0]
+
+
+//! [1]
+    view->page()->settings();
+//! [1]
+
+
+//! [2]
+    view->triggerAction(QWebPage::Copy);
+//! [2]
+
+
+//! [3]
+    view->page()->triggerPageAction(QWebPage::Stop);
+//! [3]
+
+
+//! [4]
+    view->page()->triggerPageAction(QWebPage::GoBack);
+//! [4]
+
+
+//! [5]
+    view->page()->triggerPageAction(QWebPage::GoForward);
+//! [5]
+
+}
+
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/simple/main.cpp b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/simple/main.cpp
new file mode 100644
index 0000000..82f5b6c
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/simple/main.cpp
@@ -0,0 +1,34 @@
+/*
+    Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include <QApplication>
+#include <QUrl>
+#include <QWebView>
+
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+    QWidget *parent = 0;
+//! [Using QWebView]
+    QWebView *view = new QWebView(parent);
+    view->load(QUrl("http://qtsoftware.com/"));
+    view->show();
+//! [Using QWebView]
+    return app.exec();
+}
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/simple/simple.pro b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/simple/simple.pro
new file mode 100644
index 0000000..61cd3bf
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/simple/simple.pro
@@ -0,0 +1,2 @@
+QT       += webkit
+SOURCES   = main.cpp
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/webpage/main.cpp b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/webpage/main.cpp
new file mode 100644
index 0000000..b91bc30
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/webpage/main.cpp
@@ -0,0 +1,81 @@
+/*
+    Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include <QtGui>
+#include <QWebPage>
+#include <QWebFrame>
+
+//! [0]
+class Thumbnailer : public QObject
+{
+    Q_OBJECT
+
+public:
+    Thumbnailer(const QUrl &url);
+
+signals:
+    void finished();
+
+private slots:
+    void render();
+
+private:
+    QWebPage page;
+
+};
+//! [0]
+
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+
+    Thumbnailer thumbnail(QUrl("http://qtsoftware.com"));
+
+    QObject::connect(&thumbnail, SIGNAL(finished()),
+        &app, SLOT(quit()));
+
+    return app.exec();
+}
+
+//! [1]
+Thumbnailer::Thumbnailer(const QUrl &url)
+{
+    page.mainFrame()->load(url);
+    connect(&page, SIGNAL(loadFinished(bool)),
+        this, SLOT(render()));
+}
+//! [1]
+
+//! [2]
+void Thumbnailer::render()
+{
+    page.setViewportSize(page.mainFrame()->contentsSize());
+    QImage image(page.viewportSize(), QImage::Format_ARGB32);
+    QPainter painter(&image);
+
+    page.mainFrame()->render(&painter);
+    painter.end();
+
+    QImage thumbnail = image.scaled(400, 400);
+    thumbnail.save("thumbnail.png");
+
+    emit finished();
+}
+//! [2]
+#include "main.moc"
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/webpage/webpage.pro b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/webpage/webpage.pro
new file mode 100644
index 0000000..fcad03b
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/webpage/webpage.pro
@@ -0,0 +1,3 @@
+CONFIG += console
+QT += webkit
+SOURCES = main.cpp
\ No newline at end of file
diff --git a/src/activeqt/container/container.pro b/src/activeqt/container/container.pro
index ceedacf..d654f92 100644
--- a/src/activeqt/container/container.pro
+++ b/src/activeqt/container/container.pro
@@ -21,25 +21,21 @@ LIBS    += -lole32 -loleaut32
 !wince*:LIBS    += -luser32 -lgdi32 -ladvapi32
 win32-g++:LIBS += -luuid
 
-contains(QT_EDITION, OpenSource|Console) {
-    message( "You are not licensed to use ActiveQt." )
-} else {
-    HEADERS         = ../control/qaxaggregated.h \
-                      qaxbase.h \
-		      qaxwidget.h \
-		      qaxobject.h \
-		      qaxscript.h \
-                      qaxselect.h \
-		      ../shared/qaxtypes.h
-
-    SOURCES         = qaxbase.cpp \
-		      qaxdump.cpp \
-		      qaxwidget.cpp \
-		      qaxobject.cpp \
-		      qaxscript.cpp \
-		      qaxscriptwrapper.cpp \
-                      qaxselect.cpp \
-		      ../shared/qaxtypes.cpp
-
-    FORMS           = qaxselect.ui
-}
+HEADERS =   ../control/qaxaggregated.h \
+            qaxbase.h \
+            qaxwidget.h \
+            qaxobject.h \
+            qaxscript.h \
+            qaxselect.h \
+            ../shared/qaxtypes.h
+
+SOURCES =   qaxbase.cpp \
+            qaxdump.cpp \
+            qaxwidget.cpp \
+            qaxobject.cpp \
+            qaxscript.cpp \
+            qaxscriptwrapper.cpp \
+            qaxselect.cpp \
+            ../shared/qaxtypes.cpp
+
+FORMS =     qaxselect.ui
diff --git a/src/activeqt/control/control.pro b/src/activeqt/control/control.pro
index 65b0251..bf3647e 100644
--- a/src/activeqt/control/control.pro
+++ b/src/activeqt/control/control.pro
@@ -24,20 +24,16 @@ win32-borland:DEFINES += QT_NEEDS_QMAIN
 LIBS    += -luser32 -lole32 -loleaut32 -lgdi32
 win32-g++:LIBS += -luuid
 
-contains(QT_EDITION, OpenSource|Console) {
-    message( "You are not licensed to use ActiveQt." )
-} else {
-    HEADERS     = qaxaggregated.h \
-                  qaxbindable.h \
-		  qaxfactory.h \
-		  ../shared/qaxtypes.h
-
-    SOURCES     = qaxserver.cpp \
-		  qaxserverbase.cpp \
-		  qaxbindable.cpp \
-		  qaxfactory.cpp \
-		  qaxservermain.cpp \
-		  qaxserverdll.cpp \
-		  qaxmain.cpp \
-		  ../shared/qaxtypes.cpp
-}
+HEADERS =   qaxaggregated.h \
+            qaxbindable.h \
+            qaxfactory.h \
+            ../shared/qaxtypes.h
+
+SOURCES =   qaxserver.cpp \
+            qaxserverbase.cpp \
+            qaxbindable.cpp \
+            qaxfactory.cpp \
+            qaxservermain.cpp \
+            qaxserverdll.cpp \
+            qaxmain.cpp \
+            ../shared/qaxtypes.cpp
diff --git a/src/corelib/arch/qatomic_mips.h b/src/corelib/arch/qatomic_mips.h
index b263aab..ea9954b 100644
--- a/src/corelib/arch/qatomic_mips.h
+++ b/src/corelib/arch/qatomic_mips.h
@@ -103,16 +103,25 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree()
 
 #if defined(Q_CC_GNU) && !defined(Q_OS_IRIX)
 
+#if _MIPS_SIM == _ABIO32
+#define SET_MIPS2 ".set mips2\n\t"
+#else
+#define SET_MIPS2
+#endif
+
 inline bool QBasicAtomicInt::ref()
 {
     register int originalValue;
     register int newValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  "ll %[originalValue], %[_q_value]\n"
                  "addiu %[newValue], %[originalValue], %[one]\n"
                  "sc %[newValue], %[_q_value]\n"
                  "beqz %[newValue], 0b\n"
                  "nop\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [_q_value] "+m" (_q_value),
                    [newValue] "=&r" (newValue)
@@ -125,12 +134,15 @@ inline bool QBasicAtomicInt::deref()
 {
     register int originalValue;
     register int newValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  "ll %[originalValue], %[_q_value]\n"
                  "addiu %[newValue], %[originalValue], %[minusOne]\n"
                  "sc %[newValue], %[_q_value]\n"
                  "beqz %[newValue], 0b\n"
                  "nop\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [_q_value] "+m" (_q_value),
                    [newValue] "=&r" (newValue)
@@ -143,7 +155,9 @@ inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
 {
     register int result;
     register int tempValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  "ll %[result], %[_q_value]\n"
                  "xor %[result], %[result], %[expectedValue]\n"
                  "bnez %[result], 0f\n"
@@ -153,6 +167,7 @@ inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
                  "beqz %[tempValue], 0b\n"
                  "nop\n"
                  "0:\n"
+                 ".set pop\n"
                  : [result] "=&r" (result),
                    [tempValue] "=&r" (tempValue),
                    [_q_value] "+m" (_q_value)
@@ -166,7 +181,9 @@ inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
 {
     register int result;
     register int tempValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  "ll %[result], %[_q_value]\n"
                  "xor %[result], %[result], %[expectedValue]\n"
                  "bnez %[result], 0f\n"
@@ -177,6 +194,7 @@ inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
                  "nop\n"
                  "sync\n"
                  "0:\n"
+                 ".set pop\n"
                  : [result] "=&r" (result),
                    [tempValue] "=&r" (tempValue),
                    [_q_value] "+m" (_q_value)
@@ -190,7 +208,9 @@ inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
 {
     register int result;
     register int tempValue;
-    asm volatile("sync\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "sync\n"
                  "0:\n"
                  "ll %[result], %[_q_value]\n"
                  "xor %[result], %[result], %[expectedValue]\n"
@@ -201,6 +221,7 @@ inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
                  "beqz %[tempValue], 0b\n"
                  "nop\n"
                  "0:\n"
+                 ".set pop\n"
                  : [result] "=&r" (result),
                    [tempValue] "=&r" (tempValue),
                    [_q_value] "+m" (_q_value)
@@ -219,12 +240,15 @@ inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
 {
     register int originalValue;
     register int tempValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  "ll %[originalValue], %[_q_value]\n"
                  "move %[tempValue], %[newValue]\n"
                  "sc %[tempValue], %[_q_value]\n"
                  "beqz %[tempValue], 0b\n"
                  "nop\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [tempValue] "=&r" (tempValue),
                    [_q_value] "+m" (_q_value)
@@ -237,13 +261,16 @@ inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
 {
     register int originalValue;
     register int tempValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  "ll %[originalValue], %[_q_value]\n"
                  "move %[tempValue], %[newValue]\n"
                  "sc %[tempValue], %[_q_value]\n"
                  "beqz %[tempValue], 0b\n"
                  "nop\n"
                  "sync\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [tempValue] "=&r" (tempValue),
                    [_q_value] "+m" (_q_value)
@@ -256,13 +283,16 @@ inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
 {
     register int originalValue;
     register int tempValue;
-    asm volatile("sync\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "sync\n"
                  "0:\n"
                  "ll %[originalValue], %[_q_value]\n"
                  "move %[tempValue], %[newValue]\n"
                  "sc %[tempValue], %[_q_value]\n"
                  "beqz %[tempValue], 0b\n"
                  "nop\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [tempValue] "=&r" (tempValue),
                    [_q_value] "+m" (_q_value)
@@ -280,12 +310,15 @@ inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
 {
     register int originalValue;
     register int newValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  "ll %[originalValue], %[_q_value]\n"
                  "addu %[newValue], %[originalValue], %[valueToAdd]\n"
                  "sc %[newValue], %[_q_value]\n"
                  "beqz %[newValue], 0b\n"
                  "nop\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [_q_value] "+m" (_q_value),
                    [newValue] "=&r" (newValue)
@@ -298,13 +331,16 @@ inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
 {
     register int originalValue;
     register int newValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  "ll %[originalValue], %[_q_value]\n"
                  "addu %[newValue], %[originalValue], %[valueToAdd]\n"
                  "sc %[newValue], %[_q_value]\n"
                  "beqz %[newValue], 0b\n"
                  "nop\n"
                  "sync\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [_q_value] "+m" (_q_value),
                    [newValue] "=&r" (newValue)
@@ -317,13 +353,16 @@ inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
 {
     register int originalValue;
     register int newValue;
-    asm volatile("sync\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "sync\n"
                  "0:\n"
                  "ll %[originalValue], %[_q_value]\n"
                  "addu %[newValue], %[originalValue], %[valueToAdd]\n"
                  "sc %[newValue], %[_q_value]\n"
                  "beqz %[newValue], 0b\n"
                  "nop\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [_q_value] "+m" (_q_value),
                    [newValue] "=&r" (newValue)
@@ -350,7 +389,9 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValu
 {
     register T *result;
     register T *tempValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  LLP" %[result], %[_q_value]\n"
                  "xor %[result], %[result], %[expectedValue]\n"
                  "bnez %[result], 0f\n"
@@ -360,6 +401,7 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValu
                  "beqz %[tempValue], 0b\n"
                  "nop\n"
                  "0:\n"
+                 ".set pop\n"
                  : [result] "=&r" (result),
                    [tempValue] "=&r" (tempValue),
                    [_q_value] "+m" (_q_value)
@@ -374,7 +416,9 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValu
 {
     register T *result;
     register T *tempValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  LLP" %[result], %[_q_value]\n"
                  "xor %[result], %[result], %[expectedValue]\n"
                  "bnez %[result], 0f\n"
@@ -385,6 +429,7 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValu
                  "nop\n"
                  "sync\n"
                  "0:\n"
+                 ".set pop\n"
                  : [result] "=&r" (result),
                    [tempValue] "=&r" (tempValue),
                    [_q_value] "+m" (_q_value)
@@ -399,7 +444,9 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValu
 {
     register T *result;
     register T *tempValue;
-    asm volatile("sync\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "sync\n"
                  "0:\n"
                  LLP" %[result], %[_q_value]\n"
                  "xor %[result], %[result], %[expectedValue]\n"
@@ -410,6 +457,7 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValu
                  "beqz %[tempValue], 0b\n"
                  "nop\n"
                  "0:\n"
+                 ".set pop\n"
                  : [result] "=&r" (result),
                    [tempValue] "=&r" (tempValue),
                    [_q_value] "+m" (_q_value)
@@ -430,12 +478,15 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
 {
     register T *originalValue;
     register T *tempValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  LLP" %[originalValue], %[_q_value]\n"
                  "move %[tempValue], %[newValue]\n"
                  SCP" %[tempValue], %[_q_value]\n"
                  "beqz %[tempValue], 0b\n"
                  "nop\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [tempValue] "=&r" (tempValue),
                    [_q_value] "+m" (_q_value)
@@ -449,13 +500,16 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
 {
     register T *originalValue;
     register T *tempValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  LLP" %[originalValue], %[_q_value]\n"
                  "move %[tempValue], %[newValue]\n"
                  SCP" %[tempValue], %[_q_value]\n"
                  "beqz %[tempValue], 0b\n"
                  "nop\n"
                  "sync\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [tempValue] "=&r" (tempValue),
                    [_q_value] "+m" (_q_value)
@@ -469,13 +523,16 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
 {
     register T *originalValue;
     register T *tempValue;
-    asm volatile("sync\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "sync\n"
                  "0:\n"
                  LLP" %[originalValue], %[_q_value]\n"
                  "move %[tempValue], %[newValue]\n"
                  SCP" %[tempValue], %[_q_value]\n"
                  "beqz %[tempValue], 0b\n"
                  "nop\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [tempValue] "=&r" (tempValue),
                    [_q_value] "+m" (_q_value)
@@ -495,12 +552,15 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueTo
 {
     register T *originalValue;
     register T *newValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  LLP" %[originalValue], %[_q_value]\n"
                  "addu %[newValue], %[originalValue], %[valueToAdd]\n"
                  SCP" %[newValue], %[_q_value]\n"
                  "beqz %[newValue], 0b\n"
                  "nop\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [_q_value] "+m" (_q_value),
                    [newValue] "=&r" (newValue)
@@ -514,13 +574,16 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueTo
 {
     register T *originalValue;
     register T *newValue;
-    asm volatile("0:\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "0:\n"
                  LLP" %[originalValue], %[_q_value]\n"
                  "addu %[newValue], %[originalValue], %[valueToAdd]\n"
                  SCP" %[newValue], %[_q_value]\n"
                  "beqz %[newValue], 0b\n"
                  "nop\n"
                  "sync\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [_q_value] "+m" (_q_value),
                    [newValue] "=&r" (newValue)
@@ -534,13 +597,16 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueTo
 {
     register T *originalValue;
     register T *newValue;
-    asm volatile("sync\n"
+    asm volatile(".set push\n"
+                 SET_MIPS2
+                 "sync\n"
                  "0:\n"
                  LLP" %[originalValue], %[_q_value]\n"
                  "addu %[newValue], %[originalValue], %[valueToAdd]\n"
                  SCP" %[newValue], %[_q_value]\n"
                  "beqz %[newValue], 0b\n"
                  "nop\n"
+                 ".set pop\n"
                  : [originalValue] "=&r" (originalValue),
                    [_q_value] "+m" (_q_value),
                    [newValue] "=&r" (newValue)
diff --git a/src/corelib/codecs/qtsciicodec.cpp b/src/corelib/codecs/qtsciicodec.cpp
index 14d2c9c..0ec0567 100644
--- a/src/corelib/codecs/qtsciicodec.cpp
+++ b/src/corelib/codecs/qtsciicodec.cpp
@@ -180,8 +180,7 @@ QByteArray QTsciiCodec::name() const
 */
 int QTsciiCodec::mibEnum() const
 {
-  /* There is no MIBEnum for TSCII now */
-  return -3197;
+  return 2107;
 }
 
 static const int UnToTsLast = 124; // 125 items -- so the last will be 124
diff --git a/src/corelib/codecs/qutfcodec.cpp b/src/corelib/codecs/qutfcodec.cpp
index 281bf75..1ac592e 100644
--- a/src/corelib/codecs/qutfcodec.cpp
+++ b/src/corelib/codecs/qutfcodec.cpp
@@ -413,9 +413,7 @@ QByteArray QUtf16Codec::name() const
 
 QList<QByteArray> QUtf16Codec::aliases() const
 {
-    QList<QByteArray> list;
-    list << "ISO-10646-UCS-2";
-    return list;
+    return QList<QByteArray>();
 }
 
 int QUtf16BECodec::mibEnum() const
diff --git a/src/corelib/concurrent/qfutureinterface.h b/src/corelib/concurrent/qfutureinterface.h
index 85d03c9..345bebe 100644
--- a/src/corelib/concurrent/qfutureinterface.h
+++ b/src/corelib/concurrent/qfutureinterface.h
@@ -165,6 +165,8 @@ public:
 
     QFutureInterface &operator=(const QFutureInterface &other)
     {
+        if (referenceCountIsOne())
+            resultStore().clear();
         QFutureInterfaceBase::operator=(other);
         return *this;
     }
diff --git a/src/corelib/global/qfeatures.h b/src/corelib/global/qfeatures.h
index 6d55f7c..2189723 100644
--- a/src/corelib/global/qfeatures.h
+++ b/src/corelib/global/qfeatures.h
@@ -120,6 +120,9 @@
 // QMovie
 //#define QT_NO_MOVIE
 
+// QNetworkInterface
+//#define QT_NO_NETWORKINTERFACE
+
 // QNetworkProxy
 //#define QT_NO_NETWORKPROXY
 
@@ -198,12 +201,12 @@
 // Qt Prerendered Font Format
 //#define QT_NO_QWS_QPF
 
-// Raster Paint Engine callback functions
-//#define QT_NO_RASTERCALLBACKS
-
 // Qt Prerendered Font Format 2
 //#define QT_NO_QWS_QPF2
 
+// Raster Paint Engine callback functions
+//#define QT_NO_RASTERCALLBACKS
+
 // Resize Handler
 //#define QT_NO_RESIZEHANDLER
 
@@ -273,9 +276,6 @@
 // HtmlParser
 //#define QT_NO_TEXTHTMLPARSER
 
-// OdfWriter
-//#define QT_NO_TEXTODFWRITER
-
 // QTextStream
 //#define QT_NO_TEXTSTREAM
 
@@ -316,6 +316,11 @@
 #define QT_NO_BUTTONGROUP
 #endif
 
+// QClipboard
+#if !defined(QT_NO_CLIPBOARD) && (defined(QT_NO_QWS_PROPERTIES))
+#define QT_NO_CLIPBOARD
+#endif
+
 // Codecs
 #if !defined(QT_NO_CODECS) && (defined(QT_NO_TEXTCODEC))
 #define QT_NO_CODECS
@@ -376,11 +381,6 @@
 #define QT_NO_PHONON_VOLUMESLIDER
 #endif
 
-// QPrinter
-#if !defined(QT_NO_PRINTER) && (defined(QT_NO_TEXTSTREAM))
-#define QT_NO_PRINTER
-#endif
-
 // QProcess
 #if !defined(QT_NO_PROCESS) && (defined(QT_NO_THREAD))
 #define QT_NO_PROCESS
@@ -481,11 +481,6 @@
 #define QT_NO_XMLSTREAMWRITER
 #endif
 
-// Odf Writer 
-#if !defined(QT_NO_TEXTODFWRITER) && (defined(QT_NO_XMLSTREAMWRITER)) 
-#define QT_NO_TEXTODFWRITER 
-#endif 
-
 // Context menu
 #if !defined(QT_NO_CONTEXTMENU) && (defined(QT_NO_MENU))
 #define QT_NO_CONTEXTMENU
@@ -511,11 +506,21 @@
 #define QT_NO_LIBRARY
 #endif
 
+// QPrinter
+#if !defined(QT_NO_PRINTER) && (defined(QT_NO_TEXTSTREAM) || defined(QT_NO_PICTURE))
+#define QT_NO_PRINTER
+#endif
+
 // QScrollArea
 #if !defined(QT_NO_SCROLLAREA) && (defined(QT_NO_SCROLLBAR))
 #define QT_NO_SCROLLAREA
 #endif
 
+// OdfWriter
+#if !defined(QT_NO_TEXTODFWRITER) && (defined(QT_NO_XMLSTREAMWRITER))
+#define QT_NO_TEXTODFWRITER
+#endif
+
 // QToolButton
 #if !defined(QT_NO_TOOLBUTTON) && (defined(QT_NO_ICON) || defined(QT_NO_ACTION))
 #define QT_NO_TOOLBUTTON
@@ -636,16 +641,6 @@
 #define QT_NO_WHATSTHIS
 #endif
 
-// QClipboard
-#if !defined(QT_NO_CLIPBOARD) && (defined(QT_NO_QWS_PROPERTIES))
-#define QT_NO_CLIPBOARD
-#endif
-
-// Common UNIX Printing System
-#if !defined(QT_NO_CUPS) && (defined(QT_NO_PRINTER) || defined(QT_NO_LIBRARY))
-#define QT_NO_CUPS
-#endif
-
 // QDirModel
 #if !defined(QT_NO_DIRMODEL) && (defined(QT_NO_ITEMVIEWS))
 #define QT_NO_DIRMODEL
@@ -726,6 +721,11 @@
 #define QT_NO_COMPLETER
 #endif
 
+// Common UNIX Printing System
+#if !defined(QT_NO_CUPS) && (defined(QT_NO_PRINTER) || defined(QT_NO_LIBRARY))
+#define QT_NO_CUPS
+#endif
+
 // QDataWidgetMapper
 #if !defined(QT_NO_DATAWIDGETMAPPER) && (defined(QT_NO_ITEMVIEWS) || defined(QT_NO_PROPERTIES))
 #define QT_NO_DATAWIDGETMAPPER
@@ -757,7 +757,7 @@
 #endif
 
 // QPrintPreviewWidget
-#if !defined(QT_NO_PRINTPREVIEWWIDGET) && (defined(QT_NO_GRAPHICSVIEW) || defined(QT_NO_PRINTER) || defined(QT_NO_PICTURE))
+#if !defined(QT_NO_PRINTPREVIEWWIDGET) && (defined(QT_NO_GRAPHICSVIEW) || defined(QT_NO_PRINTER))
 #define QT_NO_PRINTPREVIEWWIDGET
 #endif
 
diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index 025442a..a0ea68c 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -44,11 +44,11 @@
 
 #include <stddef.h>
 
-#define QT_VERSION_STR   "4.5.1"
+#define QT_VERSION_STR   "4.5.2"
 /*
    QT_VERSION is (major << 16) + (minor << 8) + patch.
 */
-#define QT_VERSION 0x040501
+#define QT_VERSION 0x040502
 /*
    can be used like #if (QT_VERSION >= QT_VERSION_CHECK(4, 4, 0))
 */
@@ -2281,9 +2281,9 @@ QT3_SUPPORT Q_CORE_EXPORT const char *qInstallPathSysconf();
                                  | QT_MODULE_GRAPHICSVIEW \
                                  | QT_MODULE_HELP \
                                  | QT_MODULE_TEST \
-                                 | QT_MODULE_DBUS)
-#define QT_EDITION_DESKTOP      (QT_EDITION_OPENSOURCE \
+                                 | QT_MODULE_DBUS \
                                  | QT_MODULE_ACTIVEQT)
+#define QT_EDITION_DESKTOP      (QT_EDITION_OPENSOURCE)
 #define QT_EDITION_UNIVERSAL    QT_EDITION_DESKTOP
 #define QT_EDITION_ACADEMIC     QT_EDITION_DESKTOP
 #define QT_EDITION_EDUCATIONAL  QT_EDITION_DESKTOP
diff --git a/src/corelib/global/qlibraryinfo.cpp b/src/corelib/global/qlibraryinfo.cpp
index ada08c7..29e356e 100644
--- a/src/corelib/global/qlibraryinfo.cpp
+++ b/src/corelib/global/qlibraryinfo.cpp
@@ -485,100 +485,27 @@ QT_END_NAMESPACE
 
 #if defined(Q_CC_GNU) && defined(Q_OS_LINUX) && !defined(QT_LINUXBASE) && !defined(QT_BOOTSTRAPPED)
 
-#  include <sys/syscall.h>
-#  include <unistd.h>
-
-static const char boilerplate[] =
-    "This is the QtCore library version " QT_VERSION_STR "\n"
-    "Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).\n"
-    "Contact: Qt Software Information (qt-info@nokia.com)\n"
-    "\n"
-    "Build key:           " QT_BUILD_KEY;
-
-extern "C" {
-void qt_core_init_boilerplate() __attribute__((noreturn));
-}
+#  include <stdio.h>
+#  include <stdlib.h>
 
-#  if defined(QT_ARCH_I386)
-#define sysinit() (void)0
-#define syswrite(msg, len)                                              \
-    ({ int res;                                                         \
-        asm volatile ("movl  %%ebx, %%edi\n"                            \
-                      "movl  $1, %%ebx\n"                               \
-                      "int   $0x80\n"                                   \
-                      "movl  %%edi, %%ebx\n"                            \
-                      : "=a" (res) : "0" (SYS_write), "c" (msg), "d" (len) : "edi"); res; })
-#define sysexit(c)                              \
-    asm ("xor   %%ebx, %%ebx\n"                 \
-         "int   $0x80\n"                        \
-         : : "a" (SYS_exit)); _exit(c)
-
-#  elif defined(QT_ARCH_X86_64)
-#define sysinit() (void)0
-#define syswrite(msg, len)                                              \
-    ({ int res;                                                         \
-        asm volatile ("syscall\n"                                       \
-                      : "=a" (res) : "0" (SYS_write), "D" (1), "S" (msg), "d" (len) : "rcx"); res; })
-#define sysexit(c)                              \
-    asm ("syscall\n"                            \
-         : : "a" (SYS_exit), "D" (0)); _exit(c)
-
-#  elif defined(QT_ARCH_IA64)
-#define sysinit()                                               \
-    asm volatile ("{.mlx\n"                                     \
-                  "      nop.m  0\n"                            \
-                  "      movl   r2  = @pcrel(boilerplate);;"    \
-                  "}\n"                                         \
-                  "{.mii\n"                                     \
-                  "      mov   r10 = @ltoffx(boilerplate)\n"    \
-                  "      mov   r1  = ip\n"                      \
-                  "      adds  r2  = -16, r2\n;;\n"             \
-                  "}\n"                                         \
-                  "      add   r1  = r2, r1;;\n"                \
-                  "      sub   r1  = r1, r10;;\n"               \
-                  : : : "r2", "r10")
-#define syswrite(msg, len)                                              \
-    ({ const char *_msg = msg;                                          \
-        asm ("mov    out0=%1\n"                                         \
-             "mov    out1=%2\n"                                         \
-             "mov    out2=%3\n"                                         \
-             ";;\n"                                                     \
-             "mov    r15=%0\n"                                          \
-             "break  0x100000;;\n"                                      \
-             : : "I" (SYS_write), "I" (1), "r" (_msg), "r" (len)); })
-#define sysexit(c)                                                      \
-    asm ("mov    out0=%1\n"                                             \
-         ";;\n"                                                         \
-         "mov    r15=%0\n"                                              \
-         "break  0x100000;;\n"                                          \
-         : : "I" (SYS_exit), "O" (0)); write(1, 0, 0); _exit(c)
-# else
-#define sysinit() (void)0
-#define syswrite(msg, len) (msg); (len)
-#define sysexit(c)         __builtin_exit(c)
-#  endif
-
-#define sysputs(msg) syswrite(msg, -1 + sizeof(msg))
-#define sysendl()    syswrite("\n", 1)
-#define print_qt_configure(_which)              \
-    ({const char *which = _which;               \
-        which += 12;                            \
-        int len = 0;                            \
-        while (which[len]) ++len;               \
-        syswrite(which, len); })
+extern const char qt_core_interpreter[] __attribute__((section(".interp")))
+    = "/lib/ld-linux.so.2";
 
+extern "C"
 void qt_core_init_boilerplate()
 {
-    sysinit();
-    sysputs(boilerplate);
-    sysputs("\nInstallation prefix: ");
-    print_qt_configure(qt_configure_prefix_path_str);
-    sysputs("\nLibrary path:        ");
-    print_qt_configure(qt_configure_libraries_path_str);
-    sysputs("\nInclude path:        ");
-    print_qt_configure(qt_configure_headers_path_str);
-    sysendl();
-    sysexit(0);
+    printf("This is the QtCore library version " QT_VERSION_STR "\n"
+           "Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).\n"
+           "Contact: Qt Software Information (qt-info@nokia.com)\n"
+           "\n"
+           "Build key:           " QT_BUILD_KEY "\n"
+           "Installation prefix: %s\n"
+           "Library path:        %s\n"
+           "Include path:        %s\n",
+           qt_configure_prefix_path_str + 12,
+           qt_configure_libraries_path_str + 12,
+           qt_configure_headers_path_str + 12);
+    exit(0);
 }
 
 #endif
diff --git a/src/corelib/io/qdatastream.cpp b/src/corelib/io/qdatastream.cpp
index 9990696..b203899 100644
--- a/src/corelib/io/qdatastream.cpp
+++ b/src/corelib/io/qdatastream.cpp
@@ -514,7 +514,7 @@ void QDataStream::setByteOrder(ByteOrder bo)
     \value Qt_4_2 Version 8 (Qt 4.2)
     \value Qt_4_3 Version 9 (Qt 4.3)
     \value Qt_4_4 Version 10 (Qt 4.4)
-    \value Qt_4_5 Version 10 (Qt 4.5)
+    \value Qt_4_5 Version 11 (Qt 4.5)
     \omitvalue Qt_4_6
 
     \sa setVersion(), version()
diff --git a/src/corelib/io/qdir.cpp b/src/corelib/io/qdir.cpp
index 6d75c59..b7861ba 100644
--- a/src/corelib/io/qdir.cpp
+++ b/src/corelib/io/qdir.cpp
@@ -50,6 +50,7 @@
 #include "qstring.h"
 #include "qregexp.h"
 #include "qvector.h"
+#include "qalgorithms.h"
 #ifdef QT_BUILD_CORE_LIB
 # include "qresource.h"
 #endif
@@ -190,32 +191,28 @@ QDirPrivate::~QDirPrivate()
 
 /* For sorting */
 struct QDirSortItem {
-    QString filename_cache;
-    QString suffix_cache;
+    mutable QString filename_cache;
+    mutable QString suffix_cache;
     QFileInfo item;
 };
-static int qt_cmp_si_sort_flags;
 
-#if defined(Q_C_CALLBACKS)
-extern "C" {
-#endif
 
-#ifdef Q_OS_WINCE
-static int __cdecl qt_cmp_si(const void *n1, const void *n2)
-#else
-static int qt_cmp_si(const void *n1, const void *n2)
-#endif
-{
-    if (!n1 || !n2)
-        return 0;
+class QDirSortItemComparator {
+    int qt_cmp_si_sort_flags;
+public:
+    QDirSortItemComparator(int flags) : qt_cmp_si_sort_flags(flags) {}
+    bool operator()(const QDirSortItem &, const QDirSortItem &);
+};
 
-    QDirSortItem* f1 = (QDirSortItem*)n1;
-    QDirSortItem* f2 = (QDirSortItem*)n2;
+bool QDirSortItemComparator::operator()(const QDirSortItem &n1, const QDirSortItem &n2)
+{
+    const QDirSortItem* f1 = &n1;
+    const QDirSortItem* f2 = &n2;
 
     if ((qt_cmp_si_sort_flags & QDir::DirsFirst) && (f1->item.isDir() != f2->item.isDir()))
-        return f1->item.isDir() ? -1 : 1;
+        return f1->item.isDir();
     if ((qt_cmp_si_sort_flags & QDir::DirsLast) && (f1->item.isDir() != f2->item.isDir()))
-        return f1->item.isDir() ? 1 : -1;
+        return !f1->item.isDir();
 
     int r = 0;
     int sortBy = (qt_cmp_si_sort_flags & QDir::SortByMask)
@@ -264,18 +261,11 @@ static int qt_cmp_si(const void *n1, const void *n2)
             : f1->filename_cache.compare(f2->filename_cache);
     }
 
-    if (r == 0) // Enforce an order - the order the items appear in the array
-        r = (char*)n1 - (char*)n2;
-
     if (qt_cmp_si_sort_flags & QDir::Reversed)
-        return -r;
-    return r;
+        return r > 0;
+    return r < 0;
 }
 
-#if defined(Q_C_CALLBACKS)
-}
-#endif
-
 inline void QDirPrivate::sortFileList(QDir::SortFlags sort, QStringList &l,
                                       QStringList *names, QFileInfoList *infos) const
 {
@@ -292,9 +282,8 @@ inline void QDirPrivate::sortFileList(QDir::SortFlags sort, QStringList &l,
                 path += QLatin1Char('/');
             si[i].item = QFileInfo(path + l.at(i));
         }
-        qt_cmp_si_sort_flags = sort;
         if ((sort & QDir::SortByMask) != QDir::Unsorted)
-            qsort(si, i, sizeof(si[0]), qt_cmp_si);
+            qStableSort(si, si+i, QDirSortItemComparator(sort));
         // put them back in the list(s)
         for (int j = 0; j<i; j++) {
             if(infos)
diff --git a/src/corelib/io/qfsfileengine_unix.cpp b/src/corelib/io/qfsfileengine_unix.cpp
index 0d88b06..18b92e2 100644
--- a/src/corelib/io/qfsfileengine_unix.cpp
+++ b/src/corelib/io/qfsfileengine_unix.cpp
@@ -780,7 +780,7 @@ QString QFSFileEngine::fileName(FileName file) const
 #endif
             if (len > 0) {
                 QString ret;
-                if (S_ISDIR(d->st.st_mode) && s[0] != '/') {
+                if (d->doStat() && S_ISDIR(d->st.st_mode) && s[0] != '/') {
                     QDir parent(d->filePath);
                     parent.cdUp();
                     ret = parent.path();
diff --git a/src/corelib/io/qfsfileengine_win.cpp b/src/corelib/io/qfsfileengine_win.cpp
index 522be20..63506c2 100644
--- a/src/corelib/io/qfsfileengine_win.cpp
+++ b/src/corelib/io/qfsfileengine_win.cpp
@@ -346,8 +346,15 @@ bool QFSFileEnginePrivate::uncListSharesOnServer(const QString &server, QStringL
 static bool isUncRoot(const QString &server)
 {
     QString localPath = QDir::toNativeSeparators(server);
-    QStringList parts = localPath.split(QLatin1Char('\\'), QString::SkipEmptyParts);
-    return localPath.startsWith(QLatin1String("\\\\")) && parts.count() <= 1;
+    if (!localPath.startsWith(QLatin1String("\\\\")))
+        return false;
+
+    int idx = localPath.indexOf(QLatin1Char('\\'), 2);
+    if (idx == -1 || idx + 1 == localPath.length())
+        return true;
+
+    localPath = localPath.right(localPath.length() - idx - 1).trimmed();
+    return localPath.isEmpty();
 }
 
 static bool isUncPath(const QString &path)
diff --git a/src/corelib/io/qtemporaryfile.cpp b/src/corelib/io/qtemporaryfile.cpp
index 6a7b067..6a9125c 100644
--- a/src/corelib/io/qtemporaryfile.cpp
+++ b/src/corelib/io/qtemporaryfile.cpp
@@ -105,100 +105,100 @@ QT_BEGIN_NAMESPACE
  */
 static int _gettemp(char *path, int *doopen, int domkdir, int slen)
 {
-	char *start, *trv, *suffp;
-	QT_STATBUF sbuf;
-	int rval;
+    char *start, *trv, *suffp;
+    QT_STATBUF sbuf;
+    int rval;
 #if defined(Q_OS_WIN)
     int pid;
 #else
-	pid_t pid;
+    pid_t pid;
 #endif
 
-	if (doopen && domkdir) {
-		errno = EINVAL;
-		return(0);
-	}
-
-	for (trv = path; *trv; ++trv)
-		;
-	trv -= slen;
-	suffp = trv;
-	--trv;
-	if (trv < path) {
-		errno = EINVAL;
-		return (0);
-	}
+    if (doopen && domkdir) {
+        errno = EINVAL;
+        return 0;
+    }
+
+    for (trv = path; *trv; ++trv)
+        ;
+    trv -= slen;
+    suffp = trv;
+    --trv;
+    if (trv < path) {
+        errno = EINVAL;
+        return 0;
+    }
 #if defined(Q_OS_WIN) && defined(_MSC_VER) && _MSC_VER >= 1400
-        pid = _getpid();
+    pid = _getpid();
 #else
-        pid = getpid();
+    pid = getpid();
 #endif
-	while (trv >= path && *trv == 'X' && pid != 0) {
-		*trv-- = (pid % 10) + '0';
-		pid /= 10;
-        }
+    while (trv >= path && *trv == 'X' && pid != 0) {
+        *trv-- = (pid % 10) + '0';
+        pid /= 10;
+    }
 
 #ifndef S_ISDIR
-#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
+#  define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
 #endif
 
-        while (trv >= path && *trv == 'X') {
-            char c;
-
-            // CHANGE arc4random() -> random()
-            pid = (qrand() & 0xffff) % (26+26);
-		if (pid < 26)
-			c = pid + 'A';
-		else
-			c = (pid - 26) + 'a';
-		*trv-- = c;
-	}
-	start = trv + 1;
-
-	/*
-	 * check the target directory; if you have six X's and it
-	 * doesn't exist this runs for a *very* long time.
-	 */
-	if (doopen || domkdir) {
-		for (;; --trv) {
-			if (trv <= path)
-				break;
-			if (*trv == '/') {
-				*trv = '\0';
+    while (trv >= path && *trv == 'X') {
+        char c;
+
+        // CHANGE arc4random() -> random()
+        pid = (qrand() & 0xffff) % (26+26);
+        if (pid < 26)
+            c = pid + 'A';
+        else
+            c = (pid - 26) + 'a';
+        *trv-- = c;
+    }
+    start = trv + 1;
+
+    /*
+     * check the target directory; if you have six X's and it
+     * doesn't exist this runs for a *very* long time.
+     */
+    if (doopen || domkdir) {
+        for (;; --trv) {
+            if (trv <= path)
+                break;
+            if (*trv == '/') {
+                *trv = '\0';
 #if defined (Q_OS_WIN) && !defined(Q_OS_WINCE)
-                                if (trv - path == 2 && path[1] == ':') {
-                                    // Special case for Windows drives
-                                    // (e.g., "C:" => "C:\").
-                                    // ### Better to use a Windows
-                                    // call for this.
-									char drive[] = "c:\\";
-                                    drive[0] = path[0];
-                                    rval = QT_STAT(drive, &sbuf);
-                                } else
+                if (trv - path == 2 && path[1] == ':') {
+                    // Special case for Windows drives
+                    // (e.g., "C:" => "C:\").
+                    // ### Better to use a Windows
+                    // call for this.
+                    char drive[] = "c:\\";
+                    drive[0] = path[0];
+                    rval = QT_STAT(drive, &sbuf);
+                } else
 #endif
-				rval = QT_STAT(path, &sbuf);
-				*trv = '/';
-				if (rval != 0)
-					return(0);
-				if (!S_ISDIR(sbuf.st_mode)) {
-					errno = ENOTDIR;
-					return(0);
-				}
-				break;
-			}
-		}
-	}
-
-	for (;;) {
-		if (doopen) {
+                    rval = QT_STAT(path, &sbuf);
+                *trv = '/';
+                if (rval != 0)
+                    return 0;
+                if (!S_ISDIR(sbuf.st_mode)) {
+                    errno = ENOTDIR;
+                    return 0;
+                }
+                break;
+            }
+        }
+    }
+
+    for (;;) {
+        if (doopen) {
 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400
-                        if (_sopen_s(doopen, path, QT_OPEN_CREAT|O_EXCL|QT_OPEN_RDWR|QT_OPEN_BINARY
-#ifdef QT_LARGEFILE_SUPPORT
-                                     |QT_OPEN_LARGEFILE
-#endif
-                                     , _SH_DENYNO, _S_IREAD | _S_IWRITE)== 0)
-#else
-#if defined(Q_OS_WINCE)
+            if (_sopen_s(doopen, path, QT_OPEN_CREAT|O_EXCL|QT_OPEN_RDWR|QT_OPEN_BINARY
+#  ifdef QT_LARGEFILE_SUPPORT
+                                       |QT_OPEN_LARGEFILE
+#  endif
+                         , _SH_DENYNO, _S_IREAD | _S_IWRITE)== 0)
+#else // WIN && !CE
+#  if defined(Q_OS_WINCE)
             QString targetPath;
             if (QDir::isAbsolutePath(QString::fromLatin1(path)))
                 targetPath = QLatin1String(path);
@@ -207,72 +207,82 @@ static int _gettemp(char *path, int *doopen, int domkdir, int slen)
 
             if ((*doopen =
                 QT_OPEN(targetPath.toLocal8Bit(), O_CREAT|O_EXCL|O_RDWR
-#else
-                        if ((*doopen =
-                            open(path, QT_OPEN_CREAT|O_EXCL|QT_OPEN_RDWR
-#endif
-#ifdef QT_LARGEFILE_SUPPORT
-                                 |QT_OPEN_LARGEFILE
-#endif
+#  else // CE
+            if ((*doopen =
+                open(path, QT_OPEN_CREAT|O_EXCL|QT_OPEN_RDWR
+#  endif
+#  ifdef QT_LARGEFILE_SUPPORT
+                           |QT_OPEN_LARGEFILE
+#  endif
 #  if defined(Q_OS_WINCE)
-                                                             |_O_BINARY
+                           |_O_BINARY
 #  elif defined(Q_OS_WIN)
-                                 |O_BINARY
+                           |O_BINARY
+#  endif
+#  ifdef O_CLOEXEC
+                           // supported on Linux >= 2.6.23; avoids one extra system call
+                           // and avoids a race condition: if another thread forks, we could
+                           // end up leaking a file descriptor...
+                           |O_CLOEXEC
 #  endif
-                                 , 0600)) >= 0)
+                     , 0600)) >= 0)
+#endif // WIN && !CE
+            {
+#if defined(Q_OS_UNIX) && !defined(O_CLOEXEC)
+                fcntl(*doopen, F_SETFD, FD_CLOEXEC);
 #endif
-
-                                return(1);
-                        if (errno != EEXIST)
-                                return(0);
-                } else if (domkdir) {
+                return 1;
+            }
+            if (errno != EEXIST)
+                return 0;
+        } else if (domkdir) {
 #ifdef Q_OS_WIN
-                    if (QT_MKDIR(path) == 0)
+            if (QT_MKDIR(path) == 0)
 #else
-                    if (mkdir(path, 0700) == 0)
+            if (mkdir(path, 0700) == 0)
 #endif
-                                return(1);
-                        if (errno != EEXIST)
-                                return(0);
-            }
+                return 1;
+            if (errno != EEXIST)
+                return 0;
+        }
 #ifndef Q_OS_WIN
-            else if (QT_LSTAT(path, &sbuf))
-			return(errno == ENOENT ? 1 : 0);
+        else if (QT_LSTAT(path, &sbuf))
+            return (errno == ENOENT) ? 1 : 0;
 #else
-            if (!QFileInfo(QLatin1String(path)).exists())
-                return 1;
+        if (!QFileInfo(QLatin1String(path)).exists())
+            return 1;
 #endif
 
-                /* tricky little algorwwithm for backward compatibility */
-                for (trv = start;;) {
-                        if (!*trv)
-                                return (0);
-                        if (*trv == 'Z') {
-                                if (trv == suffp)
-                                        return (0);
-                                *trv++ = 'a';
-                        } else {
-                                if (isdigit(*trv))
-                                        *trv = 'a';
-                                else if (*trv == 'z')	/* inc from z to A */
-                                        *trv = 'A';
-                                else {
-                                        if (trv == suffp)
-                                                return (0);
-                                        ++*trv;
-                                }
-                                break;
-                        }
+        /* tricky little algorwwithm for backward compatibility */
+        for (trv = start;;) {
+            if (!*trv)
+                return 0;
+            if (*trv == 'Z') {
+                if (trv == suffp)
+                    return 0;
+                *trv++ = 'a';
+            } else {
+                if (isdigit(*trv))
+                    *trv = 'a';
+                else if (*trv == 'z') /* inc from z to A */
+                    *trv = 'A';
+                else {
+                    if (trv == suffp)
+                        return 0;
+                    ++*trv;
                 }
+                break;
+            }
         }
-        /*NOTREACHED*/
+    }
+    /*NOTREACHED*/
 }
 
 #ifndef Q_WS_WIN
 static int qt_mkstemps(char *path, int slen)
 {
-        int fd = 0;
-        return (_gettemp(path, &fd, 0, slen) ? fd : -1);
+    int fd = 0;
+    return (_gettemp(path, &fd, 0, slen) ? fd : -1);
 }
 #endif
 
@@ -284,6 +294,8 @@ public:
     QTemporaryFileEngine(const QString &file) : QFSFileEngine(file) { }
     ~QTemporaryFileEngine();
 
+    void setFileName(const QString &file);
+
     bool open(QIODevice::OpenMode flags);
     bool remove();
     bool close();
@@ -294,6 +306,13 @@ QTemporaryFileEngine::~QTemporaryFileEngine()
     QFSFileEngine::close();
 }
 
+void QTemporaryFileEngine::setFileName(const QString &file)
+{
+    // Really close the file, so we don't leak
+    QFSFileEngine::close();
+    QFSFileEngine::setFileName(file);
+}
+
 bool QTemporaryFileEngine::open(QIODevice::OpenMode openMode)
 {
     Q_D(QFSFileEngine);
diff --git a/src/corelib/io/qtextstream.cpp b/src/corelib/io/qtextstream.cpp
index ed9d0aa..1167671 100644
--- a/src/corelib/io/qtextstream.cpp
+++ b/src/corelib/io/qtextstream.cpp
@@ -67,8 +67,10 @@ static const int QTEXTSTREAM_BUFFERSIZE = 16384;
     \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 1
 
     Note that you cannot use QTextStream::atEnd(), which returns true when you
-    have reached the end of the data stream, with stdin.
-
+    have reached the end of the data stream, with stdin. The reason for this is
+    that as long as stdin doesn't give any input to the QTextStream, \c atEnd()
+    will return true even if the stdin is open and waiting for more characters.
+    
     Besides using QTextStream's constructors, you can also set the
     device or string QTextStream operates on by calling setDevice() or
     setString(). You can seek to a position by calling seek(), and
diff --git a/src/corelib/kernel/qcoreevent.cpp b/src/corelib/kernel/qcoreevent.cpp
index fa2e7b0..d6b0174 100644
--- a/src/corelib/kernel/qcoreevent.cpp
+++ b/src/corelib/kernel/qcoreevent.cpp
@@ -260,6 +260,7 @@ QT_BEGIN_NAMESPACE
     \omitvalue ApplicationActivated
     \omitvalue ApplicationDeactivated
     \omitvalue MacGLWindowChange
+    \omitvalue MacGLClearDrawable
     \omitvalue NetworkReplyUpdated
     \omitvalue FutureCallOut
     \omitvalue CocoaRequestModal
diff --git a/src/corelib/kernel/qeventdispatcher_glib.cpp b/src/corelib/kernel/qeventdispatcher_glib.cpp
index 3fd768a..3c5b277 100644
--- a/src/corelib/kernel/qeventdispatcher_glib.cpp
+++ b/src/corelib/kernel/qeventdispatcher_glib.cpp
@@ -42,6 +42,7 @@
 #include "qeventdispatcher_glib_p.h"
 #include "qeventdispatcher_unix_p.h"
 
+#include <private/qmutexpool_p.h>
 #include <private/qthread_p.h>
 
 #include "qcoreapplication.h"
@@ -224,6 +225,8 @@ QEventDispatcherGlibPrivate::QEventDispatcherGlibPrivate(GMainContext *context)
     : mainContext(context)
 {
     if (qgetenv("QT_NO_THREADED_GLIB").isEmpty()) {
+        static int dummyValue = 0; // only used for its address
+        QMutexLocker locker(QMutexPool::instance()->get(&dummyValue));
         if (!g_thread_supported())
             g_thread_init(NULL);
     }
diff --git a/src/corelib/kernel/qeventloop.cpp b/src/corelib/kernel/qeventloop.cpp
index 92bdf73..600f787 100644
--- a/src/corelib/kernel/qeventloop.cpp
+++ b/src/corelib/kernel/qeventloop.cpp
@@ -188,8 +188,9 @@ int QEventLoop::exec(ProcessEventsFlags flags)
     d->threadData->eventLoops.push(this);
 
     // remove posted quit events when entering a new event loop
-    if (qApp->thread() == thread())
-        QCoreApplication::removePostedEvents(qApp, QEvent::Quit);
+    QCoreApplication *app = QCoreApplication::instance();
+    if (app && app->thread() == thread())
+        QCoreApplication::removePostedEvents(app, QEvent::Quit);
 
 #if defined(QT_NO_EXCEPTIONS)
     while (!d->exit)
diff --git a/src/corelib/thread/qthread_unix.cpp b/src/corelib/thread/qthread_unix.cpp
index f602821..8f1c698 100644
--- a/src/corelib/thread/qthread_unix.cpp
+++ b/src/corelib/thread/qthread_unix.cpp
@@ -180,8 +180,7 @@ void *QThreadPrivate::start(void *arg)
     data->quitNow = false;
 
     // ### TODO: allow the user to create a custom event dispatcher
-    if (QCoreApplication::instance())
-        createEventDispatcher(data);
+    createEventDispatcher(data);
 
     emit thr->started();
     pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
diff --git a/src/corelib/thread/qthread_win.cpp b/src/corelib/thread/qthread_win.cpp
index 27193c6..7094e3d 100644
--- a/src/corelib/thread/qthread_win.cpp
+++ b/src/corelib/thread/qthread_win.cpp
@@ -292,8 +292,7 @@ unsigned int __stdcall QThreadPrivate::start(void *arg)
 
     data->quitNow = false;
     // ### TODO: allow the user to create a custom event dispatcher
-    if (QCoreApplication::instance())
-        createEventDispatcher(data);
+    createEventDispatcher(data);
 
 #if !defined(QT_NO_DEBUG) && defined(Q_CC_MSVC) && !defined(Q_OS_WINCE)
     // sets the name of the current thread.
diff --git a/src/corelib/tools/qbytearraymatcher.cpp b/src/corelib/tools/qbytearraymatcher.cpp
index cd4cf90..211d190 100644
--- a/src/corelib/tools/qbytearraymatcher.cpp
+++ b/src/corelib/tools/qbytearraymatcher.cpp
@@ -120,6 +120,7 @@ QByteArrayMatcher::QByteArrayMatcher()
     : d(0)
 {
     p.p = 0;
+    p.l = 0;
     qMemSet(p.q_skiptable, 0, sizeof(p.q_skiptable));
 }
 
@@ -170,7 +171,7 @@ QByteArrayMatcher::~QByteArrayMatcher()
 QByteArrayMatcher &QByteArrayMatcher::operator=(const QByteArrayMatcher &other)
 {
     q_pattern = other.q_pattern;
-    qMemCopy(p.q_skiptable, other.p.q_skiptable, sizeof(p.q_skiptable));
+    qMemCopy(&p, &other.p, sizeof(p));
     return *this;
 }
 
diff --git a/src/corelib/tools/qbytearraymatcher.h b/src/corelib/tools/qbytearraymatcher.h
index d7f2366..633e92c 100644
--- a/src/corelib/tools/qbytearraymatcher.h
+++ b/src/corelib/tools/qbytearraymatcher.h
@@ -67,7 +67,12 @@ public:
 
     int indexIn(const QByteArray &ba, int from = 0) const;
     int indexIn(const char *str, int len, int from = 0) const;
-    inline QByteArray pattern() const { return q_pattern; }
+    inline QByteArray pattern() const
+    {
+        if (q_pattern.isNull())
+            return QByteArray((const char*)p.p, p.l);
+        return q_pattern;
+    }
 
 private:
     QByteArrayMatcherPrivate *d;
diff --git a/src/corelib/tools/qhash.cpp b/src/corelib/tools/qhash.cpp
index 540f43d..b2512e1 100644
--- a/src/corelib/tools/qhash.cpp
+++ b/src/corelib/tools/qhash.cpp
@@ -91,7 +91,7 @@ static uint hash(const QChar *p, int n)
 
 uint qHash(const QByteArray &key)
 {
-    return hash(reinterpret_cast<const uchar *>(key.data()), key.size());
+    return hash(reinterpret_cast<const uchar *>(key.constData()), key.size());
 }
 
 uint qHash(const QString &key)
@@ -107,7 +107,7 @@ uint qHash(const QStringRef &key)
 uint qHash(const QBitArray &bitArray)
 {
     int m = bitArray.d.size() - 1;
-    uint result = hash(reinterpret_cast<const uchar *>(bitArray.d.data()), qMax(0, m));
+    uint result = hash(reinterpret_cast<const uchar *>(bitArray.d.constData()), qMax(0, m));
 
     // deal with the last 0 to 7 bits manually, because we can't trust that
     // the padding is initialized to 0 in bitArray.d
@@ -379,6 +379,107 @@ void QHashData::checkSanity()
 #endif
 
 /*!
+    \fn uint qHash(const QPair<T1, T2> &key)
+    \relates QHash
+    \since 4.3
+
+    Returns the hash value for the \a key.
+
+    Types \c T1 and \c T2 must be supported by qHash().
+*/
+
+/*! \fn uint qHash(char key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(uchar key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(signed char key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(ushort key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(short key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(uint key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(int key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(ulong key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(long key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(quint64 key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(qint64 key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(QChar key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(const QByteArray &key)
+    \fn uint qHash(const QBitArray &key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(const QString &key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*! \fn uint qHash(const T *key)
+    \relates QHash
+
+    Returns the hash value for the \a key.
+*/
+
+/*!
     \class QHash
     \brief The QHash class is a template class that provides a hash-table-based dictionary.
 
@@ -401,7 +502,7 @@ void QHashData::checkSanity()
        key. With QHash, the items are arbitrarily ordered.
     \i The key type of a QMap must provide operator<(). The key
        type of a QHash must provide operator==() and a global
-       \l{qHash()}{qHash}(Key) function.
+       \l{qHash()} {hash} function.
     \endlist
 
     Here's an example QHash with QString keys and \c int values:
@@ -732,7 +833,6 @@ void QHashData::checkSanity()
 */
 
 /*! \fn const T QHash::value(const Key &key, const T &defaultValue) const
-
     \overload
 
     If the hash contains no item with the given \a key, the function returns
@@ -1490,121 +1590,6 @@ void QHashData::checkSanity()
     \sa operator+=(), operator-()
 */
 
-/*! \fn uint qHash(char key)
-    \relates QHash
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(uchar key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(signed char key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(ushort key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(short key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(uint key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(int key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(ulong key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(long key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(quint64 key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(qint64 key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(QChar key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(const QByteArray &key)
-    \fn uint qHash(const QBitArray &key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(const QString &key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*! \fn uint qHash(const T *key)
-    \relates QHash
-    \overload
-
-    Returns the hash value for the \a key.
-*/
-
-/*!
-    \fn uint qHash(const QPair<T1, T2> &key)
-    \relates QHash
-    \since 4.3
-
-    Returns the hash value for the \a key.
-
-    Types \c T1 and \c T2 must be supported by qHash().
-*/
-
 /*! \fn QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash)
     \relates QHash
 
diff --git a/src/corelib/tools/qlistdata.cpp b/src/corelib/tools/qlistdata.cpp
index d7c39a7..d40b6b6 100644
--- a/src/corelib/tools/qlistdata.cpp
+++ b/src/corelib/tools/qlistdata.cpp
@@ -764,6 +764,10 @@ void **QListData::erase(void **xi)
     This function requires the value type to have an implementation of
     \c operator==().
 
+    Note that QList uses 0-based indexes, just like C++ arrays. Negative
+    indexes are not supported with the exception of the value mentioned
+    above.
+
     \sa lastIndexOf(), contains()
 */
 
@@ -780,6 +784,10 @@ void **QListData::erase(void **xi)
     This function requires the value type to have an implementation of
     \c operator==().
 
+    Note that QList uses 0-based indexes, just like C++ arrays. Negative 
+    indexes are not supported with the exception of the value mentioned
+    above.
+
     \sa indexOf()
 */
 
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index 375d672..c3649e3 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -743,7 +743,9 @@ int QString::grow(int size)
 /*!
     \since 4.2
 
-    Returns a copy of the \a string string encoded in ucs4.
+    Returns a copy of the \a string, where the encoding of \a string depends on 
+    the size of wchar. If wchar is 4 bytes, the \a string is interpreted as ucs-4,
+    if wchar is 2 bytes it is interpreted as ucs-2.
 
     If \a size is -1 (default), the \a string has to be 0 terminated.
 
diff --git a/src/corelib/tools/qstring.h b/src/corelib/tools/qstring.h
index 1493dce..69c4f2f 100644
--- a/src/corelib/tools/qstring.h
+++ b/src/corelib/tools/qstring.h
@@ -113,7 +113,7 @@ public:
 
     int capacity() const;
     inline void reserve(int size);
-    inline void squeeze() { if (d->size < d->alloc) realloc(); d->capacity = 0;}
+    inline void squeeze() { if (d->size < d->alloc || d->ref != 1) realloc(); d->capacity = 0;}
 
     inline const QChar *unicode() const;
     inline QChar *data();
diff --git a/src/corelib/tools/qvector.h b/src/corelib/tools/qvector.h
index 3fd52ee..1f047b8 100644
--- a/src/corelib/tools/qvector.h
+++ b/src/corelib/tools/qvector.h
@@ -315,7 +315,7 @@ void QVector<T>::detach_helper()
 { realloc(d->size, d->alloc); }
 template <typename T>
 void QVector<T>::reserve(int asize)
-{ if (asize > d->alloc) realloc(d->size, asize); d->capacity = 1; }
+{ if (asize > d->alloc || d->ref != 1) realloc(d->size, asize); d->capacity = 1; }
 template <typename T>
 void QVector<T>::resize(int asize)
 { realloc(asize, (asize > d->alloc || (!d->capacity && asize < d->size && asize < (d->alloc >> 1))) ?
diff --git a/src/dbus/qdbusintegrator.cpp b/src/dbus/qdbusintegrator.cpp
index 8c701f5..f40a45f 100644
--- a/src/dbus/qdbusintegrator.cpp
+++ b/src/dbus/qdbusintegrator.cpp
@@ -1102,7 +1102,7 @@ void QDBusConnectionPrivate::socketWrite(int fd)
     }
 
     for (int i = 0; i < pendingWatches.size(); ++i)
-        if (!q_dbus_watch_handle(pendingWatches[i], DBUS_WATCH_READABLE))
+        if (!q_dbus_watch_handle(pendingWatches[i], DBUS_WATCH_WRITABLE))
             qDebug("OUT OF MEM");
 }
 
@@ -1125,12 +1125,7 @@ void QDBusConnectionPrivate::objectDestroyed(QObject *obj)
 void QDBusConnectionPrivate::relaySignal(QObject *obj, const QMetaObject *mo, int signalId,
                                          const QVariantList &args)
 {
-    int mciid = mo->indexOfClassInfo(QCLASSINFO_DBUS_INTERFACE);
-    Q_ASSERT(mciid != -1);
-
-    QMetaClassInfo mci = mo->classInfo(mciid);
-    Q_ASSERT(mci.value());
-    const char *interface = mci.value();
+    QString interface = qDBusInterfaceFromMetaObject(mo);
 
     QMetaMethod mm = mo->method(signalId);
     QByteArray memberName = mm.signature();
@@ -1146,12 +1141,12 @@ void QDBusConnectionPrivate::relaySignal(QObject *obj, const QMetaObject *mo, in
         }
 
     QDBusReadLocker locker(RelaySignalAction, this);
-    QDBusMessage message = QDBusMessage::createSignal(QLatin1String("/"), QLatin1String(interface),
+    QDBusMessage message = QDBusMessage::createSignal(QLatin1String("/"), interface,
                                                       QLatin1String(memberName));
     message.setArguments(args);
     DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message);
     if (!msg) {
-        qWarning("QDBusConnection: Could not emit signal %s.%s", interface, memberName.constData());
+        qWarning("QDBusConnection: Could not emit signal %s.%s", qPrintable(interface), memberName.constData());
         return;
     }
 
diff --git a/src/dbus/qdbuspendingcall.cpp b/src/dbus/qdbuspendingcall.cpp
index 9753bbe..955f4a0 100644
--- a/src/dbus/qdbuspendingcall.cpp
+++ b/src/dbus/qdbuspendingcall.cpp
@@ -432,9 +432,14 @@ inline void QDBusPendingCallWatcherPrivate::_q_finished()
 QDBusPendingCallWatcher::QDBusPendingCallWatcher(const QDBusPendingCall &call, QObject *parent)
     : QObject(*new QDBusPendingCallWatcherPrivate, parent), QDBusPendingCall(call)
 {
-    if (d) {
-        if (!d->watcherHelper)
+    if (d) {                    // QDBusPendingCall::d
+        if (!d->watcherHelper) {
             d->watcherHelper = new QDBusPendingCallWatcherHelper;
+            if (isFinished()) {
+                // cause a signal emission anyways
+                QMetaObject::invokeMethod(d->watcherHelper, "finished", Qt::QueuedConnection);
+            }
+        }
         d->watcherHelper->add(this);
     }
 }
@@ -464,6 +469,7 @@ void QDBusPendingCallWatcher::waitForFinished()
         d->waitForFinished();
 
         // our signals were queued, so deliver them
+        QCoreApplication::sendPostedEvents(d->watcherHelper, QEvent::MetaCall);
         QCoreApplication::sendPostedEvents(this, QEvent::MetaCall);
     }
 }
diff --git a/src/gui/dialogs/qabstractprintdialog.cpp b/src/gui/dialogs/qabstractprintdialog.cpp
index 0dc16c9..5ed8852 100644
--- a/src/gui/dialogs/qabstractprintdialog.cpp
+++ b/src/gui/dialogs/qabstractprintdialog.cpp
@@ -400,7 +400,7 @@ void QAbstractPrintDialogPrivate::setPrinter(QPrinter *newPrinter)
     QAbstractPrintDialog::setEnabledOptions() and
     QAbstractPrintDialog::addEnabledOption() have no effect.
 
-    In Qt 4.4, it was possible to use the satic functions to show a sheet on
+    In Qt 4.4, it was possible to use the static functions to show a sheet on
     Mac OS X. This is no longer supported in Qt 4.5. If you want this
     functionality, use QPrintDialog::open().
 
diff --git a/src/gui/dialogs/qfiledialog.cpp b/src/gui/dialogs/qfiledialog.cpp
index f70669c..eeb2743 100644
--- a/src/gui/dialogs/qfiledialog.cpp
+++ b/src/gui/dialogs/qfiledialog.cpp
@@ -96,9 +96,8 @@ Q_GUI_EXPORT _qt_filedialog_save_filename_hook qt_filedialog_save_filename_hook
   order to select one or many files or a directory.
 
   The easiest way to create a QFileDialog is to use the static
-  functions. On Windows, these static functions will call the native
-  Windows file dialog, and on Mac OS X these static function will call
-  the native Mac OS X file dialog.
+  functions. On Windows, Mac OS X, KDE and GNOME, these static functions will
+  call the native file dialog when possible.
 
   \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 0
 
@@ -216,7 +215,7 @@ Q_GUI_EXPORT _qt_filedialog_save_filename_hook qt_filedialog_save_filename_hook
     are resolved.
     \value DontConfirmOverwrite Don't ask for confirmation if an existing file is selected.
     By default confirmation is requested.
-    \value DontUseNativeDialog Don't use the native file dialog. By default on Mac OS X and Windows,
+    \value DontUseNativeDialog Don't use the native file dialog. By default on Mac OS X,
     the native file dialog is used unless you use a subclass of QFileDialog that contains the
     Q_OBJECT macro.
     \value ReadOnly Indicates that the model is readonly.
@@ -693,7 +692,10 @@ void QFileDialog::setVisible(bool visible)
 */
 void QFileDialogPrivate::_q_goToUrl(const QUrl &url)
 {
-    QModelIndex idx = model->index(url.toLocalFile());
+    //The shortcut in the side bar may have a parent that is not fetched yet (e.g. an hidden file)
+    //so we force the fetching
+    QFileSystemModelPrivate::QFileSystemNode *node = model->d_func()->node(url.toLocalFile(), true);
+    QModelIndex idx =  model->d_func()->index(node);
     _q_enterDirectory(idx);
 }
 
@@ -1437,6 +1439,8 @@ void QFileDialog::setIconProvider(QFileIconProvider *provider)
 {
     Q_D(QFileDialog);
     d->model->setIconProvider(provider);
+    //It forces the refresh of all entries in the side bar, then we can get new icons
+    d->qFileDialogUi->sidebar->setUrls(d->qFileDialogUi->sidebar->urls());
 }
 
 /*!
@@ -1533,52 +1537,51 @@ extern QString qt_win_get_existing_directory(const QFileDialogArgs &args);
 #endif
 
 /*!
-  This is a convenience static function that returns an existing file
-  selected by the user. If the user presses Cancel, it returns a null
-  string.
+    This is a convenience static function that returns an existing file
+    selected by the user. If the user presses Cancel, it returns a null string.
 
-  \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 8
+    \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 8
 
-  The function creates a modal file dialog with the given \a parent widget.
-  If the parent is not 0, the dialog will be shown centered over the
-  parent widget.
+    The function creates a modal file dialog with the given \a parent widget.
+    If \a parent is not 0, the dialog will be shown centered over the parent
+    widget.
 
-  The file dialog's working directory will be set to \a dir.  If \a
-  dir includes a file name, the file will be selected. Only files
-  that match the given \a filter are shown. The filter selected is
-  set to \a selectedFilter. The parameters \a dir, \a
-  selectedFilter, and \a filter may be empty strings. If you want
-  multiple filters, separate them with ';;', for example:
+    The file dialog's working directory will be set to \a dir. If \a dir
+    includes a file name, the file will be selected. Only files that match the
+    given \a filter are shown. The filter selected is set to \a selectedFilter.
+    The parameters \a dir, \a selectedFilter, and \a filter may be empty
+    strings. If you want multiple filters, separate them with ';;', for
+    example:
 
-  \code
+    \code
     "Images (*.png *.xpm *.jpg);;Text files (*.txt);;XML files (*.xml)"
-  \endcode
+    \endcode
 
-  The \a options argument holds various
-  options about how to run the dialog, see the QFileDialog::Option enum for
-  more information on the flags you can pass.
+    The \a options argument holds various options about how to run the dialog,
+    see the QFileDialog::Option enum for more information on the flags you can
+    pass.
 
-  The dialog's caption is set to \a caption. If \a caption is not
-  specified then a default caption will be used.
+    The dialog's caption is set to \a caption. If \a caption is not specified
+    then a default caption will be used.
 
-  Under Windows and Mac OS X, this static function will use the native
-  file dialog and not a QFileDialog.
+    On Windows and Mac OS X, this static function will use the native file
+    dialog and not a QFileDialog.
 
-  Note that on Windows the dialog will spin a blocking modal event loop
-  that will not dispatch any QTimers, and if parent is not 0 then it will
-  position the dialog just under the parent's title bar.
+    On Windows the dialog will spin a blocking modal event loop that will not
+    dispatch any QTimers, and if \a parent is not 0 then it will position the
+    dialog just below the parent's title bar.
 
-  Under Unix/X11, the normal behavior of the file dialog is to resolve
-  and follow symlinks. For example, if \c{/usr/tmp} is a symlink to
-  \c{/var/tmp}, the file dialog will change to \c{/var/tmp} after
-  entering \c{/usr/tmp}. If \a options includes DontResolveSymlinks,
-  the file dialog will treat symlinks as regular directories.
+    On Unix/X11, the normal behavior of the file dialog is to resolve and
+    follow symlinks. For example, if \c{/usr/tmp} is a symlink to \c{/var/tmp},
+    the file dialog will change to \c{/var/tmp} after entering \c{/usr/tmp}. If
+    \a options includes DontResolveSymlinks, the file dialog will treat
+    symlinks as regular directories.
 
-  \warning Do not delete \a parent during the execution of the dialog.
-           If you want to do this, you should create the dialog
-           yourself using one of the QFileDialog constructors.
+    \warning Do not delete \a parent during the execution of the dialog. If you
+    want to do this, you should create the dialog yourself using one of the
+    QFileDialog constructors.
 
-  \sa getOpenFileNames(), getSaveFileName(), getExistingDirectory()
+    \sa getOpenFileNames(), getSaveFileName(), getExistingDirectory()
 */
 QString QFileDialog::getOpenFileName(QWidget *parent,
                                const QString &caption,
@@ -1621,54 +1624,53 @@ QString QFileDialog::getOpenFileName(QWidget *parent,
 }
 
 /*!
-  This is a convenience static function that will return one or more
-  existing files selected by the user.
+    This is a convenience static function that will return one or more existing
+    files selected by the user.
 
-  \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 9
+    \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 9
 
-  This function creates a modal file dialog with the given \a parent
-  widget. If the parent is not 0, the dialog will be shown centered
-  over the parent widget.
+    This function creates a modal file dialog with the given \a parent widget.
+    If \a parent is not 0, the dialog will be shown centered over the parent
+    widget.
 
-  The file dialog's working directory will be set to \a dir. If \a
-  dir includes a file name, the file will be selected. The filter
-  is set to \a filter so that only those files which match the filter
-  are shown. The filter selected is set to \a selectedFilter. The parameters
-  \a dir, \a selectedFilter and \a filter may be empty strings. If you
-  need multiple filters, separate them with ';;', for instance:
+    The file dialog's working directory will be set to \a dir. If \a dir
+    includes a file name, the file will be selected. The filter is set to
+    \a filter so that only those files which match the filter are shown. The
+    filter selected is set to \a selectedFilter. The parameters \a dir,
+    \a selectedFilter and \a filter may be empty strings. If you need multiple
+    filters, separate them with ';;', for instance:
 
-  \code
+    \code
     "Images (*.png *.xpm *.jpg);;Text files (*.txt);;XML files (*.xml)"
-  \endcode
+    \endcode
 
-  The dialog's caption is set to \a caption. If \a caption is not
-  specified then a default caption will be used.
+    The dialog's caption is set to \a caption. If \a caption is not specified
+    then a default caption will be used.
 
-  Under Windows and Mac OS X, this static function will use the native
-  file dialog and not a QFileDialog. On Mac OS X, the \a dir argument
-  is ignored, the native dialog always displays the last visited directory.
+    On Windows and Mac OS X, this static function will use the native file
+    dialog and not a QFileDialog.
 
-  Note that on Windows the dialog will spin a blocking modal event loop
-  that will not dispatch any QTimers, and if parent is not 0 then it will
-  position the dialog just under the parent's title bar.
+    On Windows the dialog will spin a blocking modal event loop that will not
+    dispatch any QTimers, and if \a parent is not 0 then it will position the
+    dialog just below the parent's title bar.
 
-  Under Unix/X11, the normal behavior of the file dialog is to resolve
-  and follow symlinks. For example, if \c{/usr/tmp} is a symlink to
-  \c{/var/tmp}, the file dialog will change to \c{/var/tmp} after
-  entering \c{/usr/tmp}. The \a options argument holds various
-  options about how to run the dialog, see the QFileDialog::Option enum for
-  more information on the flags you can pass.
+    On Unix/X11, the normal behavior of the file dialog is to resolve and
+    follow symlinks. For example, if \c{/usr/tmp} is a symlink to \c{/var/tmp},
+    the file dialog will change to \c{/var/tmp} after entering \c{/usr/tmp}.
+    The \a options argument holds various options about how to run the dialog,
+    see the QFileDialog::Option enum for more information on the flags you can
+    pass.
 
-  Note that if you want to iterate over the list of files, you should
-  iterate over a copy. For example:
+    \note If you want to iterate over the list of files, you should iterate
+    over a copy. For example:
 
     \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 10
 
-  \warning Do not delete \a parent during the execution of the dialog.
-           If you want to do this, you should create the dialog
-           yourself using one of the QFileDialog constructors.
+    \warning Do not delete \a parent during the execution of the dialog. If you
+    want to do this, you should create the dialog yourself using one of the
+    QFileDialog constructors.
 
-  \sa getOpenFileName(), getSaveFileName(), getExistingDirectory()
+    \sa getOpenFileName(), getSaveFileName(), getExistingDirectory()
 */
 QStringList QFileDialog::getOpenFileNames(QWidget *parent,
                                           const QString &caption,
@@ -1712,54 +1714,54 @@ QStringList QFileDialog::getOpenFileNames(QWidget *parent,
 }
 
 /*!
-  This is a convenience static function that will return a file name
-  selected by the user. The file does not have to exist.
+    This is a convenience static function that will return a file name selected
+    by the user. The file does not have to exist.
 
-  It creates a modal file dialog with the given \a parent widget. If the
-  parent is not 0, the dialog will be shown centered over the parent
-  widget.
+    It creates a modal file dialog with the given \a parent widget. If
+    \a parent is not 0, the dialog will be shown centered over the parent
+    widget.
 
-  \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 11
+    \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 11
 
-  The file dialog's working directory will be set to \a dir. If \a
-  dir includes a file name, the file will be selected. Only files that
-  match the \a filter are shown. The filter selected is set to
-  \a selectedFilter. The parameters \a dir, \a selectedFilter, and
-  \a filter may be empty strings. Multiple filters are separated with ';;'.
-  For instance:
+    The file dialog's working directory will be set to \a dir. If \a dir
+    includes a file name, the file will be selected. Only files that match the
+    \a filter are shown. The filter selected is set to \a selectedFilter. The
+    parameters \a dir, \a selectedFilter, and \a filter may be empty strings.
+    Multiple filters are separated with ';;'. For instance:
 
-  \code
+    \code
     "Images (*.png *.xpm *.jpg);;Text files (*.txt);;XML files (*.xml)"
-  \endcode
+    \endcode
 
-  The \a options argument holds various
-  options about how to run the dialog, see the QFileDialog::Option enum for
-  more information on the flags you can pass.
+    The \a options argument holds various options about how to run the dialog,
+    see the QFileDialog::Option enum for more information on the flags you can
+    pass.
 
-  The default filter can be chosen by setting \a selectedFilter to the desired value.
+    The default filter can be chosen by setting \a selectedFilter to the
+    desired value.
 
-  The dialog's caption is set to \a caption. If \a caption is not
-  specified then a default caption will be used.
+    The dialog's caption is set to \a caption. If \a caption is not specified,
+    a default caption will be used.
 
-  Under Windows and Mac OS X, this static function will use the native
-  file dialog and not a QFileDialog.
+    On Windows and Mac OS X, this static function will use the native file
+    dialog and not a QFileDialog.
 
-  Note that on Windows the dialog will spin a blocking modal event loop
-  that will not dispatch any QTimers, and if parent is not 0 then it will
-  position the dialog just under the parent's title bar.
-  On Mac OS X, the filter argument is ignored.
+    On Windows the dialog will spin a blocking modal event loop that will not
+    dispatch any QTimers, and if \a parent is not 0 then it will position the
+    dialog just below the parent's title bar. On Mac OS X, with its native file
+    dialog, the filter argument is ignored.
 
-  Under Unix/X11, the normal behavior of the file dialog is to resolve
-  and follow symlinks. For example, if \c{/usr/tmp} is a symlink to
-  \c{/var/tmp}, the file dialog will change to \c{/var/tmp} after
-  entering \c{/usr/tmp}. If \a options includes DontResolveSymlinks,
-  the file dialog will treat symlinks as regular directories.
+    On Unix/X11, the normal behavior of the file dialog is to resolve and
+    follow symlinks. For example, if \c{/usr/tmp} is a symlink to \c{/var/tmp},
+    the file dialog will change to \c{/var/tmp} after entering \c{/usr/tmp}. If
+    \a options includes DontResolveSymlinks the file dialog will treat symlinks
+    as regular directories.
 
-  \warning Do not delete \a parent during the execution of the dialog.
-           If you want to do this, you should create the dialog
-           yourself using one of the QFileDialog constructors.
+    \warning Do not delete \a parent during the execution of the dialog. If you
+    want to do this, you should create the dialog yourself using one of the
+    QFileDialog constructors.
 
-  \sa getOpenFileName(), getOpenFileNames(), getExistingDirectory()
+    \sa getOpenFileName(), getOpenFileNames(), getExistingDirectory()
 */
 QString QFileDialog::getSaveFileName(QWidget *parent,
                                      const QString &caption,
@@ -1805,46 +1807,43 @@ QString QFileDialog::getSaveFileName(QWidget *parent,
 }
 
 /*!
-  This is a convenience static function that will return an existing
-  directory selected by the user.
+    This is a convenience static function that will return an existing
+    directory selected by the user.
 
-  \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 12
+    \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 12
 
-  This function creates a modal file dialog with the given \a parent
-  widget. If the parent is not 0, the dialog will be shown centered over
-  the parent widget.
+    This function creates a modal file dialog with the given \a parent widget.
+    If \a parent is not 0, the dialog will be shown centered over the parent
+    widget.
 
-  The dialog's working directory is set to \a dir, and the caption is
-  set to \a caption. Either of these may be an empty string in which case
-  the current directory and a default caption will be used
-  respectively.
+    The dialog's working directory is set to \a dir, and the caption is set to
+    \a caption. Either of these may be an empty string in which case the
+    current directory and a default caption will be used respectively.
 
-  The \a options argument holds various
-  options about how to run the dialog, see the QFileDialog::Option enum for
-  more information on the flags you can pass. Note that \l{QFileDialog::}{ShowDirsOnly}
-  must be set to ensure a native file dialog.
+    The \a options argument holds various options about how to run the dialog,
+    see the QFileDialog::Option enum for more information on the flags you can
+    pass. To ensure a native file dialog, \l{QFileDialog::}{ShowDirsOnly} must
+    be set.
 
-  Under Windows and Mac OS X, this static function will use the native
-  file dialog and not a QFileDialog. On Mac OS X, the \a dir argument
-  is ignored, the native dialog always displays the last visited directory.
-  On Windows CE, if the device has no native file dialog, a QFileDialog
-  will be used.
+    On Windows and Mac OS X, this static function will use the native file
+    dialog and not a QFileDialog. On Windows CE, if the device has no native
+    file dialog, a QFileDialog will be used.
 
-  Under Unix/X11, the normal behavior of the file dialog is to resolve
-  and follow symlinks. For example, if \c{/usr/tmp} is a symlink to
-  \c{/var/tmp}, the file dialog will change to \c{/var/tmp} after
-  entering \c{/usr/tmp}. If \a options includes DontResolveSymlinks,
-  the file dialog will treat symlinks as regular directories.
+    On Unix/X11, the normal behavior of the file dialog is to resolve and
+    follow symlinks. For example, if \c{/usr/tmp} is a symlink to \c{/var/tmp},
+    the file dialog will change to \c{/var/tmp} after entering \c{/usr/tmp}. If
+    \a options includes DontResolveSymlinks, the file dialog will treat
+    symlinks as regular directories.
 
-  Note that on Windows the dialog will spin a blocking modal event loop
-  that will not dispatch any QTimers, and if parent is not 0 then it will
-  position the dialog just under the parent's title bar.
+    On Windows the dialog will spin a blocking modal event loop that will not
+    dispatch any QTimers, and if \a parent is not 0 then it will position the
+    dialog just below the parent's title bar.
 
-  \warning Do not delete \a parent during the execution of the dialog.
-           If you want to do this, you should create the dialog
-           yourself using one of the QFileDialog constructors.
+    \warning Do not delete \a parent during the execution of the dialog. If you
+    want to do this, you should create the dialog yourself using one of the
+    QFileDialog constructors.
 
-  \sa getOpenFileName(), getOpenFileNames(), getSaveFileName()
+    \sa getOpenFileName(), getOpenFileNames(), getSaveFileName()
 */
 QString QFileDialog::getExistingDirectory(QWidget *parent,
                                           const QString &caption,
@@ -2143,7 +2142,6 @@ void QFileDialogPrivate::createWidgets()
 #ifndef QT_NO_COMPLETER
     completer = new QFSCompletor(model, q);
     qFileDialogUi->fileNameEdit->setCompleter(completer);
-    completer->sourceModel = model;
     QObject::connect(qFileDialogUi->fileNameEdit, SIGNAL(textChanged(QString)),
             q, SLOT(_q_autoCompleteFileName(QString)));
 #endif // QT_NO_COMPLETER
@@ -2793,7 +2791,7 @@ void QFileDialogPrivate::_q_enterDirectory(const QModelIndex &index)
 {
     Q_Q(QFileDialog);
     // My Computer or a directory
-    QModelIndex sourceIndex = mapToSource(index);
+    QModelIndex sourceIndex = index.model() == proxyModel ? mapToSource(index) : index;
     QString path = sourceIndex.data(QFileSystemModel::FilePathRole).toString();
     if (path.isEmpty() || model->isDir(sourceIndex)) {
         q->setDirectory(path);
diff --git a/src/gui/dialogs/qfiledialog_p.h b/src/gui/dialogs/qfiledialog_p.h
index dc24390..ab4199e 100644
--- a/src/gui/dialogs/qfiledialog_p.h
+++ b/src/gui/dialogs/qfiledialog_p.h
@@ -97,7 +97,7 @@ class Ui_QFileDialog;
   */
 class QFSCompletor :  public QCompleter {
 public:
-    QFSCompletor(QAbstractItemModel *model, QObject *parent = 0) : QCompleter(model, parent), proxyModel(0), sourceModel(0)
+    QFSCompletor(QFileSystemModel *model, QObject *parent = 0) : QCompleter(model, parent), proxyModel(0), sourceModel(model)
     {
 #ifdef Q_OS_WIN
         setCaseSensitivity(Qt::CaseInsensitive);
diff --git a/src/gui/dialogs/qfilesystemmodel.h b/src/gui/dialogs/qfilesystemmodel.h
index 52ecaf9..995268b 100644
--- a/src/gui/dialogs/qfilesystemmodel.h
+++ b/src/gui/dialogs/qfilesystemmodel.h
@@ -158,6 +158,8 @@ private:
     Q_PRIVATE_SLOT(d_func(), void _q_performDelayedSort())
     Q_PRIVATE_SLOT(d_func(), void _q_fileSystemChanged(const QString &path, const QList<QPair<QString, QFileInfo> > &))
     Q_PRIVATE_SLOT(d_func(), void _q_resolvedName(const QString &fileName, const QString &resolvedName))
+
+    friend class QFileDialogPrivate;
 };
 
 inline bool QFileSystemModel::rmdir(const QModelIndex &aindex) const
diff --git a/src/gui/dialogs/qfilesystemmodel_p.h b/src/gui/dialogs/qfilesystemmodel_p.h
index 77c35a2..0a1265a 100644
--- a/src/gui/dialogs/qfilesystemmodel_p.h
+++ b/src/gui/dialogs/qfilesystemmodel_p.h
@@ -163,7 +163,11 @@ public:
                 info->icon = iconProvider->icon(QFileInfo(path));
             QHash<QString, QFileSystemNode *>::const_iterator iterator;
             for(iterator = children.constBegin() ; iterator != children.constEnd() ; ++iterator) {
-                iterator.value()->updateIcon(iconProvider, path + QLatin1Char('/') + iterator.value()->fileName);
+                //On windows the root (My computer) has no path so we don't want to add a / for nothing (e.g. /C:/)
+                if (!path.isEmpty())
+                    iterator.value()->updateIcon(iconProvider, path + QLatin1Char('/') + iterator.value()->fileName);
+                else
+                    iterator.value()->updateIcon(iconProvider, iterator.value()->fileName);
             }
         }
 
@@ -172,7 +176,11 @@ public:
                 info->displayType = iconProvider->type(QFileInfo(path));
             QHash<QString, QFileSystemNode *>::const_iterator iterator;
             for(iterator = children.constBegin() ; iterator != children.constEnd() ; ++iterator) {
-                 iterator.value()->retranslateStrings(iconProvider, path + QLatin1Char('/') + iterator.value()->fileName);
+                //On windows the root (My computer) has no path so we don't want to add a / for nothing (e.g. /C:/)
+                if (!path.isEmpty())
+                    iterator.value()->retranslateStrings(iconProvider, path + QLatin1Char('/') + iterator.value()->fileName);
+                else
+                    iterator.value()->retranslateStrings(iconProvider, iterator.value()->fileName);
             }
         }
 
diff --git a/src/gui/dialogs/qfontdialog_mac.mm b/src/gui/dialogs/qfontdialog_mac.mm
index d6ddfa3..50917a1 100644
--- a/src/gui/dialogs/qfontdialog_mac.mm
+++ b/src/gui/dialogs/qfontdialog_mac.mm
@@ -87,7 +87,6 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
     NSButton *mOkButton;
     NSButton *mCancelButton;
     QFontDialogPrivate *mPriv;
-    NSFont *mCocoaFont;
     QFont *mQtFont;
     BOOL mPanelHackedWithButtons;
     CGFloat mDialogExtraWidth;
@@ -119,6 +118,29 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
 - (void)cleanUpAfterMyself;
 @end
 
+static QFont qfontForCocoaFont(NSFont *cocoaFont, const QFont &resolveFont)
+{
+    QFont newFont;
+    if (cocoaFont) {
+        int pSize = qRound([cocoaFont pointSize]);
+        QString family(QCFString::toQString(reinterpret_cast<CFStringRef>([cocoaFont familyName])));
+        QString typeface(QCFString::toQString(reinterpret_cast<CFStringRef>([cocoaFont fontName])));
+//        qDebug() << "original family" << family << "typeface" << typeface << "psize" << pSize;
+        int hyphenPos = typeface.indexOf(QLatin1Char('-'));
+        if (hyphenPos != -1) {
+            typeface.remove(0, hyphenPos + 1);
+        } else {
+            typeface = QLatin1String("Normal");
+        }
+//        qDebug() << " massaged family" << family << "typeface" << typeface << "psize" << pSize;
+        newFont = QFontDatabase().font(family, typeface, pSize);
+        newFont.setUnderline(resolveFont.underline());
+        newFont.setStrikeOut(resolveFont.strikeOut());
+
+    }
+    return newFont;
+}
+
 @implementation QCocoaFontPanelDelegate
 - (id)initWithFontPanel:(NSFontPanel *)panel
        stolenContentView:(NSView *)stolenContentView
@@ -134,7 +156,6 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
     mOkButton = okButton;
     mCancelButton = cancelButton;
     mPriv = priv;
-    mCocoaFont = 0;
     mPanelHackedWithButtons = (okButton != 0);
     mDialogExtraWidth = extraWidth;
     mDialogExtraHeight = extraHeight;
@@ -155,42 +176,14 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
 
 - (void)dealloc
 {
-    if (mCocoaFont)
-        [mCocoaFont release];
     delete mQtFont;
     [super dealloc];
 }
 
 - (void)changeFont:(id)sender
 {
-    Q_UNUSED(sender);
-
-    QFont newFont;
-
-    if (mCocoaFont)
-        [mCocoaFont autorelease];
     NSFont *dummyFont = [NSFont userFontOfSize:12.0];
-    mCocoaFont = [sender convertFont:dummyFont];
-    if (mCocoaFont) {
-        [mCocoaFont retain];
-
-        int pSize = qRound([mCocoaFont pointSize]);
-        QString family(QCFString::toQString(reinterpret_cast<CFStringRef>([mCocoaFont familyName])));
-        QString typeface(QCFString::toQString(reinterpret_cast<CFStringRef>([mCocoaFont fontName])));
-//        qDebug() << "original family" << family << "typeface" << typeface << "psize" << pSize;
-        int hyphenPos = typeface.indexOf(QLatin1Char('-'));
-        if (hyphenPos != -1) {
-            typeface.remove(0, hyphenPos + 1);
-        } else {
-            typeface = QLatin1String("Normal");
-        }
-//        qDebug() << " massaged family" << family << "typeface" << typeface << "psize" << pSize;
-        newFont = QFontDatabase().font(family, typeface, pSize);
-        newFont.setUnderline(mQtFont->underline());
-        newFont.setStrikeOut(mQtFont->strikeOut());
-    }
-
-	[self setQtFont:newFont];
+    [self setQtFont:qfontForCocoaFont([sender convertFont:dummyFont], *mQtFont)];
     if (mPriv)
         mPriv->updateSampleFont(*mQtFont);
 }
@@ -317,6 +310,9 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
 - (void)onOkClicked
 {
     Q_ASSERT(mPanelHackedWithButtons);
+    NSFontManager *fontManager = [NSFontManager sharedFontManager];
+    [self setQtFont:qfontForCocoaFont([fontManager convertFont:[fontManager selectedFont]],
+                                      *mQtFont)];
     [[mStolenContentView window] close];
     [self finishOffWithCode:NSOKButton];
 }
@@ -357,8 +353,8 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
 
 - (void)setQtFont:(const QFont &)newFont
 {
-	delete mQtFont;
-	mQtFont = new QFont(newFont);
+    delete mQtFont;
+    mQtFont = new QFont(newFont);
 }
 
 - (QFont)qtFont
@@ -374,16 +370,7 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
             mModalSession = 0;
         }
 
-        // temporary hack to work around bug in deleteLater() in Qt/Mac Cocoa
-#if 1
-        bool deleteDialog = mPriv->fontDialog()->testAttribute(Qt::WA_DeleteOnClose);
-        mPriv->fontDialog()->setAttribute(Qt::WA_DeleteOnClose, false);
-#endif
         mPriv->done((code == NSOKButton) ? QDialog::Accepted : QDialog::Rejected);
-#if 1
-        if (deleteDialog)
-            delete mPriv->fontDialog();
-#endif
     } else {
         [NSApp stopModalWithCode:code];
     }
@@ -404,6 +391,7 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
     }
     [mFontPanel setDelegate:nil];
     [[NSFontManager sharedFontManager] setDelegate:nil];
+    [[NSFontManager sharedFontManager] setTarget:nil];
 }
 @end
 
@@ -527,6 +515,7 @@ void *QFontDialogPrivate::openCocoaFontPanel(const QFont &initial,
                                                    extraHeight:dialogExtraHeight];
     [ourPanel setDelegate:delegate];
     [[NSFontManager sharedFontManager] setDelegate:delegate];
+    [[NSFontManager sharedFontManager] setTarget:delegate];
     setFont(delegate, initial);
 
     // hack to get correct initial layout
diff --git a/src/gui/dialogs/qmessagebox.cpp b/src/gui/dialogs/qmessagebox.cpp
index 1967837..5e59501 100644
--- a/src/gui/dialogs/qmessagebox.cpp
+++ b/src/gui/dialogs/qmessagebox.cpp
@@ -280,6 +280,9 @@ void QMessageBoxPrivate::updateSize()
     int hardLimit = screenSize.width() - (q->frameGeometry().width() - q->geometry().width());
 #else
     int hardLimit = qMin(screenSize.width() - 480, 1000); // can never get bigger than this
+    // on small screens allows the messagebox be the same size as the screen
+    if (screenSize.width() <= 1024)
+        hardLimit = screenSize.width();
 #endif
 #ifdef Q_WS_MAC
     int softLimit = qMin(screenSize.width()/2, 420);
@@ -1680,7 +1683,7 @@ void QMessageBox::aboutQt(QWidget *parent, const QString &title)
 {
 #ifdef Q_WS_MAC
     static QPointer<QMessageBox> oldMsgBox;
-  
+
     if (oldMsgBox) {
         oldMsgBox->show();
         oldMsgBox->raise();
@@ -1692,29 +1695,35 @@ void QMessageBox::aboutQt(QWidget *parent, const QString &title)
     QString translatedTextAboutQt;
     translatedTextAboutQt = QMessageBox::tr(
         "<h3>About Qt</h3>"
-        "%1<p>Qt is a C++ toolkit for cross-platform "
-        "application development.</p>"
-        "<p>Qt provides single-source "
-        "portability across MS&nbsp;Windows, Mac&nbsp;OS&nbsp;X, "
-        "Linux, and all major commercial Unix variants. Qt is also"
-        " available for embedded devices as Qt for Embedded Linux"
-        " and Qt for Windows CE.</p>"
-        "<p>Qt is a Nokia product. See "
-        "<a href=\"http://qtsoftware.com/qt/\">qtsoftware.com/qt/</a> for more information.</p>"
-       )
-#if QT_EDITION != QT_EDITION_OPENSOURCE
-       .arg(QMessageBox::tr("<p>This program uses Qt version %1.</p>"))
-#else
-       .arg(QMessageBox::tr("<p>This program uses Qt Open Source Edition version %1.</p>"
-               "<p>Qt Open Source Edition is intended for the development "
-               "of Open Source applications. You need a commercial Qt "
-               "license for development of proprietary (closed source) "
-               "applications.</p>"
-               "<p>Please see <a href=\"http://qtsoftware.com/company/model/\">qtsoftware.com/company/model/</a> "
-               "for an overview of Qt licensing.</p>"))
-#endif
-
-    .arg(QLatin1String(QT_VERSION_STR));
+        "<p>This program uses Qt version %1.</p>"
+        "<p>Qt is a C++ toolkit for cross-platform application "
+        "development.</p>"
+        "<p>Qt provides single-source portability across MS&nbsp;Windows, "
+        "Mac&nbsp;OS&nbsp;X, Linux, and all major commercial Unix variants. "
+        "Qt is also available for embedded devices as Qt for Embedded Linux "
+        "and Qt for Windows CE.</p>"
+        "<p>Qt is available under three different licensing options designed "
+        "to accommodate the needs of our various users.</p>"
+        "Qt licensed under our commercial license agreement is appropriate "
+        "for development of proprietary/commercial software where you do not "
+        "want to share any source code with third parties or otherwise cannot "
+        "comply with the terms of the GNU LGPL version 2.1 or GNU GPL version "
+        "3.0.</p>"
+        "<p>Qt licensed under the GNU LGPL version 2.1 is appropriate for the "
+        "development of Qt applications (proprietary or open source) provided "
+        "you can comply with the terms and conditions of the GNU LGPL version "
+        "2.1.</p>"
+        "<p>Qt licensed under the GNU General Public License version 3.0 is "
+        "appropriate for the development of Qt applications where you wish to "
+        "use such applications in combination with software subject to the "
+        "terms of the GNU GPL version 3.0 or where you are otherwise willing "
+        "to comply with the terms of the GNU GPL version 3.0.</p>"
+        "<p>Please see <a href=\"http://www.qtsoftware.com/products/licensing\">www.qtsoftware.com/products/licensing</a> "
+        "for an overview of Qt licensing.</p>"
+        "<p>Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).</p>"
+        "<p>Qt is a Nokia product. See <a href=\"http://www.qtsoftware.com/qt/\">www.qtsoftware.com/qt</a> "
+        "for more information.</p>"
+       ).arg(QLatin1String(QT_VERSION_STR));
 
     QMessageBox *msgBox = new QMessageBox(parent);
     msgBox->setAttribute(Qt::WA_DeleteOnClose);
diff --git a/src/gui/dialogs/qprintdialog_unix.cpp b/src/gui/dialogs/qprintdialog_unix.cpp
index 76c22d0..87a4e65 100644
--- a/src/gui/dialogs/qprintdialog_unix.cpp
+++ b/src/gui/dialogs/qprintdialog_unix.cpp
@@ -727,7 +727,9 @@ void QUnixPrintWidgetPrivate::updateWidget()
             widget.printers->removeItem(widget.printers->count()-1); // remove separator
         filePrintersAdded = false;
     }
-    if (printer && filePrintersAdded && printer->printerName().isEmpty()) {
+    if (printer && filePrintersAdded && (printer->outputFormat() != QPrinter::NativeFormat
+                                         || printer->printerName().isEmpty()))
+    {
         if (printer->outputFormat() == QPrinter::PdfFormat)
             widget.printers->setCurrentIndex(widget.printers->count() - 2);
         else if (printer->outputFormat() == QPrinter::PostScriptFormat)
diff --git a/src/gui/dialogs/qsidebar.cpp b/src/gui/dialogs/qsidebar.cpp
index 1bd2b7d..26108d7 100644
--- a/src/gui/dialogs/qsidebar.cpp
+++ b/src/gui/dialogs/qsidebar.cpp
@@ -55,6 +55,18 @@
 
 QT_BEGIN_NAMESPACE
 
+void QSideBarDelegate::initStyleOption(QStyleOptionViewItem *option,
+                                         const QModelIndex &index) const
+{
+    QStyledItemDelegate::initStyleOption(option,index);
+    QVariant value = index.data(QUrlModel::EnabledRole);
+    if (value.isValid()) {
+        //If the bookmark/entry is not enabled then we paint it in gray
+        if (!qvariant_cast<bool>(value))
+            option->state &= ~QStyle::State_Enabled;
+    }
+}
+
 /*!
     QUrlModel lets you have indexes from a QFileSystemModel to a list.  When QFileSystemModel
     changes them QUrlModel will automatically update.
@@ -88,9 +100,6 @@ Qt::ItemFlags QUrlModel::flags(const QModelIndex &index) const
     if (index.data(Qt::DecorationRole).isNull())
         flags &= ~Qt::ItemIsEnabled;
 
-    if (invalidUrls.contains(index.data(UrlRole).toUrl()))
-        flags &= ~Qt::ItemIsEnabled;
-
     return flags;
 }
 
@@ -193,6 +202,11 @@ void QUrlModel::setUrl(const QModelIndex &index, const QUrl &url, const QModelIn
             newName = QFileInfo(url.toLocalFile()).fileName();
             if (!invalidUrls.contains(url))
                 invalidUrls.append(url);
+            //The bookmark is invalid then we set to false the EnabledRole
+            setData(index, false, EnabledRole);
+        } else {
+            //The bookmark is valid then we set to true the EnabledRole
+            setData(index, true, EnabledRole);
         }
 
         // Make sure that we have at least 32x32 images
@@ -234,7 +248,11 @@ void QUrlModel::addUrls(const QList<QUrl> &list, int row, bool move)
         if (!url.isValid() || url.scheme() != QLatin1String("file"))
             continue;
         for (int j = 0; move && j < rowCount(); ++j) {
+#if defined(Q_OS_WIN)
+            if (index(j, 0).data(UrlRole).toUrl().toLocalFile().toLower() == url.toLocalFile().toLower()) {
+#else
             if (index(j, 0).data(UrlRole) == url) {
+#endif
                 removeRow(j);
                 if (j <= row)
                     row--;
@@ -356,6 +374,7 @@ void QSidebar::init(QFileSystemModel *model, const QList<QUrl> &newUrls)
     urlModel = new QUrlModel(this);
     urlModel->setFileSystemModel(model);
     setModel(urlModel);
+    setItemDelegate(new QSideBarDelegate(this));
 
     connect(selectionModel(), SIGNAL(currentChanged(const QModelIndex &, const QModelIndex &)),
             this, SLOT(clicked(const QModelIndex &)));
diff --git a/src/gui/dialogs/qsidebar_p.h b/src/gui/dialogs/qsidebar_p.h
index ecbbb37..56fd6d4 100644
--- a/src/gui/dialogs/qsidebar_p.h
+++ b/src/gui/dialogs/qsidebar_p.h
@@ -55,6 +55,7 @@
 
 #include <qlistwidget.h>
 #include <qstandarditemmodel.h>
+#include <qstyleditemdelegate.h>
 #include <qurl.h>
 
 #ifndef QT_NO_FILEDIALOG
@@ -62,13 +63,23 @@
 QT_BEGIN_NAMESPACE
 
 class QFileSystemModel;
+
+class QSideBarDelegate : public QStyledItemDelegate
+{
+ public:
+     QSideBarDelegate(QWidget *parent = 0) : QStyledItemDelegate(parent) {}
+     void initStyleOption(QStyleOptionViewItem *option,
+                          const QModelIndex &index) const;
+};
+
 class Q_AUTOTEST_EXPORT QUrlModel : public QStandardItemModel
 {
     Q_OBJECT
 
 public:
     enum Roles {
-        UrlRole = Qt::UserRole + 1
+        UrlRole = Qt::UserRole + 1,
+        EnabledRole = Qt::UserRole + 2
     };
 
     QUrlModel(QObject *parent = 0);
diff --git a/src/gui/embedded/qscreentransformed_qws.cpp b/src/gui/embedded/qscreentransformed_qws.cpp
index f988789..e22ea1f 100644
--- a/src/gui/embedded/qscreentransformed_qws.cpp
+++ b/src/gui/embedded/qscreentransformed_qws.cpp
@@ -400,7 +400,19 @@ void QTransformedScreen::blit(const QImage &image, const QPoint &topLeft,
 #endif
 #if defined(QT_QWS_DEPTH_16) || defined(QT_QWS_DEPTH_15) || defined(QT_QWS_DEPTH_12)
     case 16:
+#if defined QT_QWS_ROTATE_BGR
+        if (pixelType() == BGRPixel && image.depth() == 16) {
+            SET_BLIT_FUNC(qbgr565, quint16, trans, func);
+            break;
+        } //fall-through here!!!
+#endif
     case 15:
+#if defined QT_QWS_ROTATE_BGR
+        if (pixelType() == BGRPixel && image.format() == QImage::Format_RGB555) {
+            SET_BLIT_FUNC(qbgr555, qrgb555, trans, func);
+            break;
+        } //fall-through here!!!
+#endif
     case 12:
         if (image.depth() == 16)
             SET_BLIT_FUNC(quint16, quint16, trans, func);
@@ -410,7 +422,9 @@ void QTransformedScreen::blit(const QImage &image, const QPoint &topLeft,
 #endif
 #ifdef QT_QWS_DEPTH_8
     case 8:
-        if (image.depth() == 16)
+        if (image.format() == QImage::Format_RGB444)
+            SET_BLIT_FUNC(quint8, qrgb444, trans, func);
+        else if (image.depth() == 16)
             SET_BLIT_FUNC(quint8, quint16, trans, func);
         else
             SET_BLIT_FUNC(quint8, quint32, trans, func);
diff --git a/src/gui/embedded/qscreenvfb_qws.cpp b/src/gui/embedded/qscreenvfb_qws.cpp
index abbe73b..accfe1f 100644
--- a/src/gui/embedded/qscreenvfb_qws.cpp
+++ b/src/gui/embedded/qscreenvfb_qws.cpp
@@ -310,6 +310,9 @@ bool QVFbScreen::connect(const QString &displaySpec)
 
     connected = this;
 
+    if (qgetenv("QT_QVFB_BGR").toInt())
+        pixeltype = BGRPixel;
+
     return true;
 }
 
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/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index df140e3..ce4b443 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -1230,8 +1230,8 @@ void QGraphicsItem::setFlags(GraphicsItemFlags flags)
         return;
 
     // Flags that alter the geometry of the item (or its children).
-    int geomChangeFlagsMask = (ItemClipsChildrenToShape | ItemClipsToShape | ItemIgnoresTransformations);
-    bool fullUpdate = (flags & geomChangeFlagsMask) != (d_ptr->flags & geomChangeFlagsMask);
+    const quint32 geomChangeFlagsMask = (ItemClipsChildrenToShape | ItemClipsToShape | ItemIgnoresTransformations);
+    bool fullUpdate = (quint32(flags) & geomChangeFlagsMask) != (d_ptr->flags & geomChangeFlagsMask);
     if (fullUpdate)
         d_ptr->fullUpdateHelper(false, true);
 
@@ -1926,7 +1926,7 @@ void QGraphicsItem::setOpacity(qreal opacity)
     itemChange(ItemOpacityHasChanged, newOpacity);
 
     // Update.
-    d_ptr->fullUpdateHelper();
+    d_ptr->fullUpdateHelper(/*childrenOnly=*/false, /*maybeDirtyClipPath=*/false, /*ignoreOpacity=*/true);
 }
 
 /*!
@@ -3472,10 +3472,16 @@ bool QGraphicsItem::contains(const QPointF &point) const
 }
 
 /*!
-    Returns true if this item collides with \a other; otherwise returns false.
-    The ways items collide is determined by \a mode. The default value for \a
-    mode is Qt::IntersectsItemShape; \a other collides with this item if it
-    either intersects, contains, or is contained by this item's shape.
+
+    Returns true if this item collides with \a other; otherwise
+    returns false.
+
+    The \a mode is applied to \a other, and the resulting shape or
+    bounding rectangle is then compared to this item's shape. The
+    default value for \a mode is Qt::IntersectsItemShape; \a other
+    collides with this item if it either intersects, contains, or is
+    contained by this item's shape (see Qt::ItemSelectionMode for
+    details).
 
     The default implementation is based on shape intersection, and it calls
     shape() on both items. Because the complexity of arbitrary shape-shape
@@ -3530,6 +3536,11 @@ bool QGraphicsItem::collidesWithItem(const QGraphicsItem *other, Qt::ItemSelecti
     Qt::IntersectsItemShape; \a path collides with this item if it either
     intersects, contains, or is contained by this item's shape.
 
+    Note that this function checks whether the item's shape or
+    bounding rectangle (depending on \a mode) is contained within \a
+    path, and not whether \a path is contained within the items shape
+    or bounding rectangle. 
+
     \sa collidesWithItem(), contains(), shape()
 */
 bool QGraphicsItem::collidesWithPath(const QPainterPath &path, Qt::ItemSelectionMode mode) const
@@ -3570,11 +3581,12 @@ bool QGraphicsItem::collidesWithPath(const QPainterPath &path, Qt::ItemSelection
 /*!
     Returns a list of all items that collide with this item.
 
-    The way collisions are detected is determined by \a mode. The default
-    value for \a mode is Qt::IntersectsItemShape; All items whose shape
-    intersects or is contained by this item's shape are returned.
+    The way collisions are detected is determined by applying \a mode
+    to items that are compared to this item, i.e., each item's shape
+    or bounding rectangle is checked against this item's shape. The
+    default value for \a mode is Qt::IntersectsItemShape.
 
-    \sa QGraphicsScene::collidingItems(), collidesWithItem()
+    \sa collidesWithItem()
 */
 QList<QGraphicsItem *> QGraphicsItem::collidingItems(Qt::ItemSelectionMode mode) const
 {
@@ -3858,9 +3870,8 @@ void QGraphicsItem::setBoundingRegionGranularity(qreal granularity)
     \internal
     Returns true if we can discard an update request; otherwise false.
 */
-bool QGraphicsItemPrivate::discardUpdateRequest(bool ignoreClipping,
-                                                bool ignoreVisibleBit,
-                                                bool ignoreDirtyBit) const
+bool QGraphicsItemPrivate::discardUpdateRequest(bool ignoreClipping, bool ignoreVisibleBit,
+                                                bool ignoreDirtyBit, bool ignoreOpacity) const
 {
     // No scene, or if the scene is updating everything, means we have nothing
     // to do. The only exception is if the scene tracks the growing scene rect.
@@ -3869,7 +3880,7 @@ bool QGraphicsItemPrivate::discardUpdateRequest(bool ignoreClipping,
            || !scene
            || (scene->d_func()->updateAll && scene->d_func()->hasSceneRect)
            || (!ignoreClipping && (childrenClippedToShape() && isClippedAway()))
-           || (childrenCombineOpacity() && isFullyTransparent());
+           || (!ignoreOpacity && childrenCombineOpacity() && isFullyTransparent());
 }
 
 /*!
@@ -3899,11 +3910,10 @@ void QGraphicsItemPrivate::updateHelper(const QRectF &rect, bool force, bool may
 
     Propagates updates to \a item and all its children.
 */
-void QGraphicsItemPrivate::fullUpdateHelper(bool childrenOnly, bool maybeDirtyClipPath)
+void QGraphicsItemPrivate::fullUpdateHelper(bool childrenOnly, bool maybeDirtyClipPath, bool ignoreOpacity)
 {
-    if (discardUpdateRequest(/*ignoreClipping=*/maybeDirtyClipPath,
-                             /*ignoreVisibleBit=*/false,
-                             /*ignoreDirtyBit=*/true)) {
+    if (discardUpdateRequest(/*ignoreClipping=*/maybeDirtyClipPath, /*ignoreVisibleBit=*/false,
+                             /*ignoreDirtyBit=*/true, ignoreOpacity)) {
         return;
     }
 
@@ -4187,17 +4197,29 @@ bool QGraphicsItemPrivate::isProxyWidget() const
 */
 void QGraphicsItem::update(const QRectF &rect)
 {
-    if ((rect.isEmpty() && !rect.isNull()) || d_ptr->discardUpdateRequest())
+    if (rect.isEmpty() && !rect.isNull())
         return;
 
     if (CacheMode(d_ptr->cacheMode) != NoCache) {
         QGraphicsItemCache *cache = d_ptr->extraItemCache();
+        if (d_ptr->discardUpdateRequest(/* ignoreVisibleBit = */ false,
+                                        /* ignoreClipping = */ false,
+                                        /* ignoreDirtyBit = */ true)) {
+            return;
+        }
+
+        // Invalidate cache.
         if (rect.isNull()) {
             cache->allExposed = true;
             cache->exposed.clear();
         } else {
             cache->exposed.append(rect);
         }
+        // Only invalidate cache; item is already dirty.
+        if (d_ptr->dirty)
+            return;
+    } else if (d_ptr->discardUpdateRequest()) {
+        return;
     }
 
     // Effectively the same as updateHelper(rect);
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index d2cbf25..e8ab63d 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -174,11 +174,10 @@ public:
     void setPosHelper(const QPointF &pos);
     void setVisibleHelper(bool newVisible, bool explicitly, bool update = true);
     void setEnabledHelper(bool newEnabled, bool explicitly, bool update = true);
-    bool discardUpdateRequest(bool ignoreClipping = false,
-                              bool ignoreVisibleBit = false,
-                              bool ignoreDirtyBit = false) const;
+    bool discardUpdateRequest(bool ignoreClipping = false, bool ignoreVisibleBit = false,
+                              bool ignoreDirtyBit = false, bool ignoreOpacity = false) const;
     void updateHelper(const QRectF &rect = QRectF(), bool force = false, bool maybeDirtyClipPath = false);
-    void fullUpdateHelper(bool childrenOnly = false, bool maybeDirtyClipPath = false);
+    void fullUpdateHelper(bool childrenOnly = false, bool maybeDirtyClipPath = false, bool ignoreOpacity = false);
     void updateEffectiveOpacity();
     void resolveEffectiveOpacity(qreal effectiveParentOpacity);
     void resolveDepth(int parentDepth);
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index 9881960..13f70e5 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -697,12 +697,6 @@ void QGraphicsScenePrivate::_q_removeItemLater(QGraphicsItem *item)
 {
     Q_Q(QGraphicsScene);
 
-    if (QGraphicsItem *parent = item->d_func()->parent) {
-        parent->itemChange(QGraphicsItem::ItemChildRemovedChange,
-                           qVariantFromValue<QGraphicsItem *>(item));
-        parent->d_func()->children.removeAll(item);
-    }
-
     // Clear focus on the item to remove any reference in the focusWidget
     // chain.
     item->clearFocus();
@@ -4896,9 +4890,11 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
             if (newCacheIndent != deviceData->cacheIndent || deviceRect.size() != pix.size()) {
                 QPoint diff = newCacheIndent - deviceData->cacheIndent;
                 QPixmap newPix(deviceRect.size());
+                // ### Investigate removing this fill (test with Plasma and
+                // graphicssystem raster).
+                newPix.fill(Qt::transparent);
                 if (!pix.isNull()) {
                     QPainter newPixPainter(&newPix);
-                    newPixPainter.setCompositionMode(QPainter::CompositionMode_Source);
                     newPixPainter.drawPixmap(-diff, pix);
                     newPixPainter.end();
                 }
diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp
index b5a1bdf..05e4907 100644
--- a/src/gui/graphicsview/qgraphicsview.cpp
+++ b/src/gui/graphicsview/qgraphicsview.cpp
@@ -1071,8 +1071,12 @@ QList<QGraphicsItem *> QGraphicsViewPrivate::findItems(const QRegion &exposedReg
         QList<QGraphicsItem *> itemList(scene->items());
         int i = 0;
         while (i < itemList.size()) {
+            const QGraphicsItem *item = itemList.at(i);
             // But we only want to include items that are visible
-            if (!itemList.at(i)->isVisible())
+            // The following check is basically the same as item->d_ptr->isInvisible(), except
+            // that we don't check whether the item clips children to shape or propagates its
+            // opacity (we loop through all items, so those checks are wrong in this context).
+            if (!item->isVisible() || item->d_ptr->isClippedAway() || item->d_ptr->isFullyTransparent())
                 itemList.removeAt(i);
             else
                 ++i;
diff --git a/src/gui/image/qimagereader.cpp b/src/gui/image/qimagereader.cpp
index 5de39d9..7f36be9 100644
--- a/src/gui/image/qimagereader.cpp
+++ b/src/gui/image/qimagereader.cpp
@@ -1337,6 +1337,7 @@ QByteArray QImageReader::imageFormat(QIODevice *device)
     \row    \o TIFF   \o Tagged Image File Format
     \row    \o XBM    \o X11 Bitmap
     \row    \o XPM    \o X11 Pixmap
+    \row    \o SVG    \o Scalable Vector Graphics
     \endtable
 
     Reading and writing SVG files is supported through Qt's
diff --git a/src/gui/image/qpixmap_x11.cpp b/src/gui/image/qpixmap_x11.cpp
index ff7c1b6..38916c7 100644
--- a/src/gui/image/qpixmap_x11.cpp
+++ b/src/gui/image/qpixmap_x11.cpp
@@ -1437,7 +1437,7 @@ QImage QX11PixmapData::toImage() const
 
         // we may have to swap the byte order
         if ((QSysInfo::ByteOrder == QSysInfo::LittleEndian && xi->byte_order == MSBFirst)
-            || (QSysInfo::ByteOrder == QSysInfo::BigEndian))
+            || (QSysInfo::ByteOrder == QSysInfo::BigEndian && xi->byte_order == LSBFirst))
         {
             for (int i=0; i < image.height(); i++) {
                 uint *p = (uint*)image.scanLine(i);
diff --git a/src/gui/image/qpixmapcache.cpp b/src/gui/image/qpixmapcache.cpp
index 4253f8d..458d6b9 100644
--- a/src/gui/image/qpixmapcache.cpp
+++ b/src/gui/image/qpixmapcache.cpp
@@ -187,6 +187,11 @@ bool QPMCache::insert(const QString& key, const QPixmap &pixmap, int cost)
         cacheKeys.insert(key, cacheKey);
         return true;
     }
+    qint64 oldCacheKey = cacheKeys.value(key, -1);
+    //If for the same key we add already a pixmap we should delete it
+    if (oldCacheKey != -1)
+        QCache<qint64, QDetachedPixmap>::remove(oldCacheKey);
+
     bool success = QCache<qint64, QDetachedPixmap>::insert(cacheKey, new QDetachedPixmap(pixmap), cost);
     if (success) {
         cacheKeys.insert(key, cacheKey);
@@ -275,7 +280,8 @@ bool QPixmapCache::insert(const QString &key, const QPixmap &pm)
 /*!
     Returns the cache limit (in kilobytes).
 
-    The default cache limit is 2048 KB for Embedded, 10240 KB for Desktops.
+    The default cache limit is 2048 KB for Embedded, 10240 KB for
+    Desktops.
 
     \sa setCacheLimit()
 */
@@ -288,7 +294,8 @@ int QPixmapCache::cacheLimit()
 /*!
     Sets the cache limit to \a n kilobytes.
 
-    The default setting is 1024 kilobytes.
+    The default setting is 2048 KB for Embedded, 10240 KB for
+    Desktops.
 
     \sa cacheLimit()
 */
diff --git a/src/gui/itemviews/qabstractitemview.cpp b/src/gui/itemviews/qabstractitemview.cpp
index 55b3a03..83e05b4 100644
--- a/src/gui/itemviews/qabstractitemview.cpp
+++ b/src/gui/itemviews/qabstractitemview.cpp
@@ -88,6 +88,7 @@ QAbstractItemViewPrivate::QAbstractItemViewPrivate()
         autoScroll(true),
         autoScrollMargin(16),
         autoScrollCount(0),
+        shouldScrollToCurrentOnShow(false),
         alternatingColors(false),
         textElideMode(Qt::ElideRight),
         verticalScrollMode(QAbstractItemView::ScrollPerItem),
@@ -1380,8 +1381,9 @@ bool QAbstractItemView::event(QEvent *event)
         d->executePostedLayout(); //make sure we set the layout properly
         break;
     case QEvent::Show:
-        {
-            d->executePostedLayout(); //make sure we set the layout properly
+        d->executePostedLayout(); //make sure we set the layout properly
+        if (d->shouldScrollToCurrentOnShow) {
+            d->shouldScrollToCurrentOnShow = false;
             const QModelIndex current = currentIndex();
             if (current.isValid() && (d->state == QAbstractItemView::EditingState || d->autoScroll))
                 scrollTo(current);
@@ -3163,14 +3165,18 @@ void QAbstractItemView::currentChanged(const QModelIndex &current, const QModelI
             d->updateDirtyRegion();
         }
     }
-    if (isVisible() && current.isValid() && !d->autoScrollTimer.isActive()) {
-        if (d->autoScroll)
-            scrollTo(current);
-        d->setDirtyRegion(visualRect(current));
-        d->updateDirtyRegion();
-        edit(current, CurrentChanged, 0);
-        if (current.row() == (d->model->rowCount(d->root) - 1))
-            d->_q_fetchMore();
+    if (current.isValid() && !d->autoScrollTimer.isActive()) {
+        if (isVisible()) {
+            if (d->autoScroll)
+                scrollTo(current);
+            d->setDirtyRegion(visualRect(current));
+            d->updateDirtyRegion();
+            edit(current, CurrentChanged, 0);
+            if (current.row() == (d->model->rowCount(d->root) - 1))
+                d->_q_fetchMore();
+        } else {
+            d->shouldScrollToCurrentOnShow = d->autoScroll;
+        }
     }
 }
 
diff --git a/src/gui/itemviews/qabstractitemview_p.h b/src/gui/itemviews/qabstractitemview_p.h
index 37fe4a2..16bd1ab 100644
--- a/src/gui/itemviews/qabstractitemview_p.h
+++ b/src/gui/itemviews/qabstractitemview_p.h
@@ -359,6 +359,7 @@ public:
     QBasicTimer autoScrollTimer;
     int autoScrollMargin;
     int autoScrollCount;
+    bool shouldScrollToCurrentOnShow; //used to know if we should scroll to current on show event
 
     bool alternatingColors;
 
diff --git a/src/gui/itemviews/qheaderview.cpp b/src/gui/itemviews/qheaderview.cpp
index 5bd82d4..dc63b25 100644
--- a/src/gui/itemviews/qheaderview.cpp
+++ b/src/gui/itemviews/qheaderview.cpp
@@ -1388,8 +1388,7 @@ int QHeaderView::defaultSectionSize() const
 void QHeaderView::setDefaultSectionSize(int size)
 {
     Q_D(QHeaderView);
-    d->defaultSectionSize = size;
-    d->forceInitializing = true;
+    d->setDefaultSectionSize(size);
 }
 
 /*!
@@ -1894,9 +1893,6 @@ void QHeaderView::initializeSections()
         //make sure we update the hidden sections
         if (newCount < oldCount)
             d->updateHiddenSections(0, newCount-1);
-    } else if (d->forceInitializing) {
-        initializeSections(0, newCount - 1);
-        d->forceInitializing = false;
     }
 }
 
@@ -1952,7 +1948,7 @@ void QHeaderView::initializeSections(int start, int end)
     if (!d->sectionHidden.isEmpty())
         d->sectionHidden.resize(d->sectionCount);
 
-    if (d->sectionCount > oldCount || d->forceInitializing)
+    if (d->sectionCount > oldCount)
         d->createSectionSpan(start, end, (end - start + 1) * d->defaultSectionSize, d->globalResizeMode);
     //Q_ASSERT(d->headerLength() == d->length);
 
@@ -3364,6 +3360,29 @@ void QHeaderViewPrivate::cascadingResize(int visual, int newSize)
     viewport->update();
 }
 
+void QHeaderViewPrivate::setDefaultSectionSize(int size)
+{
+    Q_Q(QHeaderView);
+    defaultSectionSize = size;
+    int currentVisualIndex = 0;
+    for (int i = 0; i < sectionSpans.count(); ++i) {
+        QHeaderViewPrivate::SectionSpan &span = sectionSpans[i];
+        if (span.size > 0) {
+            //we resize it if it is not hidden (ie size > 0)
+            const int newSize = span.count * size;
+            if (newSize != span.size) {
+                length += newSize - span.size; //the whole length is changed
+                const int oldSectionSize = span.sectionSize();
+                span.size = span.count * size;
+                for (int i = currentVisualIndex; i < currentVisualIndex + span.count; ++i) {
+                    emit q->sectionResized(logicalIndex(i), oldSectionSize, size);
+                }
+            }
+        }
+        currentVisualIndex += span.count;
+    }
+}
+
 void QHeaderViewPrivate::resizeSectionSpan(int visualIndex, int oldSize, int newSize)
 {
     Q_Q(QHeaderView);
diff --git a/src/gui/itemviews/qheaderview_p.h b/src/gui/itemviews/qheaderview_p.h
index fbba69a..2889f08 100644
--- a/src/gui/itemviews/qheaderview_p.h
+++ b/src/gui/itemviews/qheaderview_p.h
@@ -90,7 +90,6 @@ public:
           highlightSelected(false),
           stretchLastSection(false),
           cascadingResizing(false),
-          forceInitializing(false),
           stretchSections(0),
           contentsSections(0),
           minimumSectionSize(-1),
@@ -275,7 +274,6 @@ public:
     bool highlightSelected;
     bool stretchLastSection;
     bool cascadingResizing;
-    bool forceInitializing;
     int stretchSections;
     int contentsSections;
     int defaultSectionSize;
@@ -310,6 +308,7 @@ public:
     void createSectionSpan(int start, int end, int size, QHeaderView::ResizeMode mode);
     void removeSectionsFromSpans(int start, int end);
     void resizeSectionSpan(int visualIndex, int oldSize, int newSize);
+    void setDefaultSectionSize(int size);
 
     inline int headerSectionCount() const { // for debugging
         int count = 0;
diff --git a/src/gui/itemviews/qitemselectionmodel.cpp b/src/gui/itemviews/qitemselectionmodel.cpp
index 1a3ae2d..8baefdf 100644
--- a/src/gui/itemviews/qitemselectionmodel.cpp
+++ b/src/gui/itemviews/qitemselectionmodel.cpp
@@ -1313,11 +1313,11 @@ bool QItemSelectionModel::rowIntersectsSelection(int row, const QModelIndex &par
         int left = sel.at(i).left();
         int right = sel.at(i).right();
         if (top <= row && bottom >= row) {
-            Qt::ItemFlags leftFlags = d->model->index(row, left, parent).flags();
-            Qt::ItemFlags rightFlags = d->model->index(row, right, parent).flags();
-            if ((leftFlags & Qt::ItemIsSelectable) && (leftFlags & Qt::ItemIsEnabled)
-                && (rightFlags & Qt::ItemIsSelectable) && (rightFlags & Qt::ItemIsEnabled))
-                return true;
+            for (int j = left; j <= right; j++) {
+                const Qt::ItemFlags flags = d->model->index(row, j, parent).flags();
+                if ((flags & Qt::ItemIsSelectable) && (flags & Qt::ItemIsEnabled))
+                    return true;
+            }
         }
     }
 
@@ -1342,11 +1342,11 @@ bool QItemSelectionModel::columnIntersectsSelection(int column, const QModelInde
         int top =  sel.at(i).top();
         int bottom =  sel.at(i).bottom();
         if (left <= column && right >= column) {
-            Qt::ItemFlags topFlags = d->model->index(top, column, parent).flags();
-            Qt::ItemFlags bottomFlags = d->model->index(bottom, column, parent).flags();
-            if ((topFlags & Qt::ItemIsSelectable) && (topFlags & Qt::ItemIsEnabled)
-                && (bottomFlags & Qt::ItemIsSelectable) && (bottomFlags & Qt::ItemIsEnabled))
-                return true;
+            for (int j = top; j <= bottom; j++) {
+                const Qt::ItemFlags flags = d->model->index(j, column, parent).flags();
+                if ((flags & Qt::ItemIsSelectable) && (flags & Qt::ItemIsEnabled))
+                    return true;
+            }
         }
     }
 
diff --git a/src/gui/itemviews/qlistview.cpp b/src/gui/itemviews/qlistview.cpp
index 07f0a38..48f53a0 100644
--- a/src/gui/itemviews/qlistview.cpp
+++ b/src/gui/itemviews/qlistview.cpp
@@ -1997,14 +1997,15 @@ bool QListViewPrivate::doItemsLayout(int delta)
     int first = batchStartRow();
     int last = qMin(first + delta - 1, max);
 
-    if (max < 0 || last < first)
-        return true; // nothing to do
-
     if (first == 0) {
         layoutChildren(); // make sure the viewport has the right size
         prepareItemsLayout();
     }
 
+    if (max < 0 || last < first) {
+        return true; // nothing to do
+    }
+
     QListViewLayoutInfo info;
     info.bounds = layoutBounds;
     info.grid = gridSize();
diff --git a/src/gui/itemviews/qsortfilterproxymodel.cpp b/src/gui/itemviews/qsortfilterproxymodel.cpp
index 91431c4..43feda8 100644
--- a/src/gui/itemviews/qsortfilterproxymodel.cpp
+++ b/src/gui/itemviews/qsortfilterproxymodel.cpp
@@ -144,6 +144,7 @@ public:
         const QModelIndex &proxy_index) const
     {
         Q_ASSERT(proxy_index.isValid());
+        Q_ASSERT(proxy_index.model() == q_func());
         const void *p = proxy_index.internalPointer();
         Q_ASSERT(p);
         QMap<QModelIndex, Mapping *>::const_iterator it =
@@ -311,6 +312,10 @@ QModelIndex QSortFilterProxyModelPrivate::proxy_to_source(const QModelIndex &pro
 {
     if (!proxy_index.isValid())
         return QModelIndex(); // for now; we may want to be able to set a root index later
+    if (proxy_index.model() != q_func()) {
+        qWarning() << "QSortFilterProxyModel: index from wrong model passed to mapToSource";
+        return QModelIndex();
+    }
     IndexMap::const_iterator it = index_to_iterator(proxy_index);
     Mapping *m = it.value();
     if ((proxy_index.row() >= m->source_rows.size()) || (proxy_index.column() >= m->source_columns.size()))
@@ -324,6 +329,10 @@ QModelIndex QSortFilterProxyModelPrivate::source_to_proxy(const QModelIndex &sou
 {
     if (!source_index.isValid())
         return QModelIndex(); // for now; we may want to be able to set a root index later
+    if (source_index.model() != model) {
+        qWarning() << "QSortFilterProxyModel: index from wrong model passed to mapFromSource";
+        return QModelIndex();
+    }
     QModelIndex source_parent = source_index.parent();
     IndexMap::const_iterator it = create_mapping(source_parent);
     Mapping *m = it.value();
diff --git a/src/gui/kernel/qapplication.cpp b/src/gui/kernel/qapplication.cpp
index 185fae2..b04d5bf 100644
--- a/src/gui/kernel/qapplication.cpp
+++ b/src/gui/kernel/qapplication.cpp
@@ -832,12 +832,13 @@ QApplication::QApplication(Display *dpy, int &argc, char **argv,
 
 #endif // Q_WS_X11
 
+extern void qInitDrawhelperAsm();
 
 /*!
+  \fn void QApplicationPrivate::initialize()
+
   Initializes the QApplication object, called from the constructors.
 */
-extern void qInitDrawhelperAsm();
-
 void QApplicationPrivate::initialize()
 {
     QWidgetPrivate::mapper = new QWidgetMapper;
@@ -2105,8 +2106,8 @@ void QApplicationPrivate::setFocusWidget(QWidget *focus, Qt::FocusReason reason)
                 if (that)
                     QApplication::sendEvent(that->style(), &in);
             }
+            emit qApp->focusChanged(prev, focus_widget);
         }
-        emit qApp->focusChanged(prev, focus_widget);
     }
 }
 
@@ -5003,6 +5004,137 @@ bool QApplicationPrivate::shouldSetFocus(QWidget *w, Qt::FocusPolicy policy)
     return true;
 }
 
+/*! \fn QDecoration &QApplication::qwsDecoration()
+    Return the QWSDecoration used for decorating windows.
+
+    \warning This method is non-portable. It is only available in
+    Qt for Embedded Linux.
+
+    \sa QDecoration
+*/
+
+/*!
+    \fn void QApplication::qwsSetDecoration(QDecoration *decoration)
+
+    Sets the QDecoration derived class to use for decorating the
+    windows used by Qt for Embedded Linux to the \a decoration
+    specified.
+
+    This method is non-portable. It is only available in Qt for Embedded Linux.
+
+    \sa QDecoration
+*/
+
+/*! \fn QDecoration* QApplication::qwsSetDecoration(const QString &decoration)
+  \overload
+
+  Requests a QDecoration object for \a decoration from the QDecorationFactory.
+
+  The string must be one of the QDecorationFactory::keys(). Keys are
+  case insensitive.
+
+  A later call to the QApplication constructor will override the
+  requested style when a "-style" option is passed in as a commandline
+  parameter.
+
+  Returns 0 if an unknown \a decoration is passed, otherwise the QStyle object
+  returned is set as the application's GUI style.
+*/
+
+/*!
+    \fn bool QApplication::qwsEventFilter(QWSEvent *event)
+
+    This virtual function is only implemented under Qt for Embedded Linux.
+
+    If you create an application that inherits QApplication and
+    reimplement this function, you get direct access to all QWS (Q
+    Window System) events that the are received from the QWS master
+    process. The events are passed in the \a event parameter.
+
+    Return true if you want to stop the event from being processed.
+    Return false for normal event dispatching. The default
+    implementation returns false.
+*/
+
+/*! \fn void QApplication::qwsSetCustomColors(QRgb *colorTable, int start, int numColors)
+    Set Qt for Embedded Linux custom color table.
+
+    Qt for Embedded Linux on 8-bpp displays allocates a standard 216 color cube.
+    The remaining 40 colors may be used by setting a custom color
+    table in the QWS master process before any clients connect.
+
+    \a colorTable is an array of up to 40 custom colors. \a start is
+    the starting index (0-39) and \a numColors is the number of colors
+    to be set (1-40).
+
+    This method is non-portable. It is available \e only in
+    Qt for Embedded Linux.
+
+    \note The custom colors will not be used by the default screen
+    driver. To make use of the new colors, implement a custom screen
+    driver, or use QDirectPainter.
+*/
+
+/*! \fn int QApplication::qwsProcessEvent(QWSEvent* event)
+    \internal
+*/
+
+/*! \fn int QApplication::x11ClientMessage(QWidget* w, XEvent* event, bool passive_only)
+    \internal
+*/
+
+/*! \fn int QApplication::x11ProcessEvent(XEvent* event)
+    This function does the core processing of individual X
+    \a{event}s, normally by dispatching Qt events to the right
+    destination.
+
+    It returns 1 if the event was consumed by special handling, 0 if
+    the \a event was consumed by normal handling, and -1 if the \a
+    event was for an unrecognized widget.
+
+    \sa x11EventFilter()
+*/
+
+/*!
+    \fn bool QApplication::x11EventFilter(XEvent *event)
+
+    \warning This virtual function is only implemented under X11.
+
+    If you create an application that inherits QApplication and
+    reimplement this function, you get direct access to all X events
+    that the are received from the X server. The events are passed in
+    the \a event parameter.
+
+    Return true if you want to stop the event from being processed.
+    Return false for normal event dispatching. The default
+    implementation returns false.
+
+    It is only the directly addressed messages that are filtered.
+    You must install an event filter directly on the event
+    dispatcher, which is returned by
+    QAbstractEventDispatcher::instance(), to handle system wide
+    messages.
+
+    \sa x11ProcessEvent()
+*/
+
+/*! \fn void QApplication::winFocus(QWidget *widget, bool gotFocus)
+    \internal
+    \since 4.1
+
+    If \a gotFocus is true, \a widget will become the active window.
+    Otherwise the active window is reset to 0.
+*/
+
+/*! \fn void QApplication::winMouseButtonUp()
+  \internal
+ */
+
+/*! \fn void QApplication::syncX()
+  Synchronizes with the X server in the X11 implementation.
+  This normally takes some time. Does nothing on other platforms.
+*/
+
 QT_END_NAMESPACE
 
 #include "moc_qapplication.cpp"
diff --git a/src/gui/kernel/qapplication_mac.mm b/src/gui/kernel/qapplication_mac.mm
index 5f8c572..69302ec 100644
--- a/src/gui/kernel/qapplication_mac.mm
+++ b/src/gui/kernel/qapplication_mac.mm
@@ -194,8 +194,8 @@ static bool        appNoGrab        = false;        // mouse/keyboard grabbing
 #ifndef QT_MAC_USE_COCOA
 static EventHandlerRef app_proc_handler = 0;
 static EventHandlerUPP app_proc_handlerUPP = 0;
-static AEEventHandlerUPP app_proc_ae_handlerUPP = NULL;
 #endif
+static AEEventHandlerUPP app_proc_ae_handlerUPP = NULL;
 static EventHandlerRef tablet_proximity_handler = 0;
 static EventHandlerUPP tablet_proximity_UPP = 0;
 bool QApplicationPrivate::native_modal_dialog_active;
@@ -951,7 +951,6 @@ void qt_mac_event_release(QWidget *w)
     }
 }
 
-#ifndef QT_MAC_USE_COCOA
 struct QMacAppleEventTypeSpec {
     AEEventClass mac_class;
     AEEventID mac_id;
@@ -959,6 +958,7 @@ struct QMacAppleEventTypeSpec {
     { kCoreEventClass, kAEQuitApplication },
     { kCoreEventClass, kAEOpenDocuments }
 };
+#ifndef QT_MAC_USE_COCOA
 /* watched events */
 static EventTypeSpec app_events[] = {
     { kEventClassQt, kEventQtRequestWindowChange },
@@ -1156,13 +1156,13 @@ void qt_init(QApplicationPrivate *priv, int)
             qt_init_app_proc_handler();
         }
 
+#endif
         if (!app_proc_ae_handlerUPP) {
             app_proc_ae_handlerUPP = AEEventHandlerUPP(QApplicationPrivate::globalAppleEventProcessor);
             for(uint i = 0; i < sizeof(app_apple_events) / sizeof(QMacAppleEventTypeSpec); ++i)
                 AEInstallEventHandler(app_apple_events[i].mac_class, app_apple_events[i].mac_id,
                         app_proc_ae_handlerUPP, SRefCon(qApp), true);
         }
-#endif
 
         if (QApplicationPrivate::app_style) {
             QEvent ev(QEvent::Style);
@@ -1210,6 +1210,17 @@ void qt_init(QApplicationPrivate *priv, int)
 
 }
 
+void qt_release_apple_event_handler()
+{
+    if(app_proc_ae_handlerUPP) {
+        for(uint i = 0; i < sizeof(app_apple_events) / sizeof(QMacAppleEventTypeSpec); ++i)
+            AERemoveEventHandler(app_apple_events[i].mac_class, app_apple_events[i].mac_id,
+                    app_proc_ae_handlerUPP, true);
+        DisposeAEEventHandlerUPP(app_proc_ae_handlerUPP);
+        app_proc_ae_handlerUPP = 0;
+    }
+}
+
 /*****************************************************************************
   qt_cleanup() - cleans up when the application is finished
  *****************************************************************************/
@@ -1223,15 +1234,8 @@ void qt_cleanup()
         DisposeEventHandlerUPP(app_proc_handlerUPP);
         app_proc_handlerUPP = 0;
     }
-    if(app_proc_ae_handlerUPP) {
-        for(uint i = 0; i < sizeof(app_apple_events) / sizeof(QMacAppleEventTypeSpec); ++i)
-            AERemoveEventHandler(app_apple_events[i].mac_class, app_apple_events[i].mac_id,
-                    app_proc_ae_handlerUPP, true);
-        DisposeAEEventHandlerUPP(app_proc_ae_handlerUPP);
-        app_proc_ae_handlerUPP = NULL;
-    }
 #endif
-
+    qt_release_apple_event_handler();
     qt_release_tablet_proximity_handler();
     if (tablet_proximity_UPP)
         DisposeEventHandlerUPP(tablet_proximity_UPP);
@@ -2367,6 +2371,12 @@ QApplicationPrivate::globalEventProcessor(EventHandlerCallRef er, EventRef event
 #endif
 }
 
+// In Carbon this is your one stop for apple events.
+// In Cocoa, it ISN'T. This is the catch-all Apple Event handler that exists
+// for the time between instantiating the NSApplication, but before the
+// NSApplication has installed it's OWN Apple Event handler. When Cocoa has
+// that set up, we remove this.  So, if you are debugging problems, you likely
+// want to check out QCocoaApplicationDelegate instead.
 OSStatus QApplicationPrivate::globalAppleEventProcessor(const AppleEvent *ae, AppleEvent *, long handlerRefcon)
 {
     QApplication *app = (QApplication *)handlerRefcon;
diff --git a/src/gui/kernel/qapplication_qws.cpp b/src/gui/kernel/qapplication_qws.cpp
index 2deda8e..018440f 100644
--- a/src/gui/kernel/qapplication_qws.cpp
+++ b/src/gui/kernel/qapplication_qws.cpp
@@ -2675,9 +2675,6 @@ void QApplication::alert(QWidget *, int)
 {
 }
 
-/*!
-    \internal
-*/
 int QApplication::qwsProcessEvent(QWSEvent* event)
 {
     Q_D(QApplication);
@@ -3056,43 +3053,11 @@ int QApplication::qwsProcessEvent(QWSEvent* event)
     return 0;
 }
 
-/*!
-    \fn bool QApplication::qwsEventFilter(QWSEvent *event)
-
-    This virtual function is only implemented under Qt for Embedded Linux.
-
-    If you create an application that inherits QApplication and
-    reimplement this function, you get direct access to all QWS (Q
-    Window System) events that the are received from the QWS master
-    process. The events are passed in the \a event parameter.
-
-    Return true if you want to stop the event from being processed.
-    Return false for normal event dispatching. The default
-    implementation returns false.
-*/
 bool QApplication::qwsEventFilter(QWSEvent *)
 {
     return false;
 }
 
-/*!
-    Set Qt for Embedded Linux custom color table.
-
-    Qt for Embedded Linux on 8-bpp displays allocates a standard 216 color cube.
-    The remaining 40 colors may be used by setting a custom color
-    table in the QWS master process before any clients connect.
-
-    \a colorTable is an array of up to 40 custom colors. \a start is
-    the starting index (0-39) and \a numColors is the number of colors
-    to be set (1-40).
-
-    This method is non-portable. It is available \e only in
-    Qt for Embedded Linux.
-
-    \note The custom colors will not be used by the default screen
-    driver. To make use of the new colors, implement a custom screen
-    driver, or use QDirectPainter.
-*/
 void QApplication::qwsSetCustomColors(QRgb *colorTable, int start, int numColors)
 {
     if (start < 0 || start > 39) {
@@ -3111,30 +3076,11 @@ void QApplication::qwsSetCustomColors(QRgb *colorTable, int start, int numColors
 }
 
 #ifndef QT_NO_QWS_MANAGER
-/*!
-    Return the QWSDecoration used for decorating windows.
-
-    \warning This method is non-portable. It is only available in
-    Qt for Embedded Linux.
-
-    \sa QDecoration
-*/
 QDecoration &QApplication::qwsDecoration()
 {
     return *qws_decoration;
 }
 
-/*!
-    \fn void QApplication::qwsSetDecoration(QDecoration *decoration)
-
-    Sets the QDecoration derived class to use for decorating the
-    windows used by Qt for Embedded Linux to the \a decoration
-    specified.
-
-    This method is non-portable. It is only available in Qt for Embedded Linux.
-
-    \sa QDecoration
-*/
 void QApplication::qwsSetDecoration(QDecoration *dec)
 {
     if (dec) {
@@ -3153,21 +3099,6 @@ void QApplication::qwsSetDecoration(QDecoration *dec)
     }
 }
 
-/*!
-  \overload
-
-  Requests a QDecoration object for \a decoration from the QDecorationFactory.
-
-  The string must be one of the QDecorationFactory::keys(). Keys are
-  case insensitive.
-
-  A later call to the QApplication constructor will override the
-  requested style when a "-style" option is passed in as a commandline
-  parameter.
-
-  Returns 0 if an unknown \a decoration is passed, otherwise the QStyle object
-  returned is set as the application's GUI style.
-*/
 QDecoration* QApplication::qwsSetDecoration(const QString &decoration)
 {
     QDecoration *decore = QDecorationFactory::create(decoration);
diff --git a/src/gui/kernel/qapplication_win.cpp b/src/gui/kernel/qapplication_win.cpp
index fae0335..f14ad6f 100644
--- a/src/gui/kernel/qapplication_win.cpp
+++ b/src/gui/kernel/qapplication_win.cpp
@@ -1371,13 +1371,6 @@ QString QApplicationPrivate::appName() const
 
 extern uint qGlobalPostedEventsCount();
 
-/*!
-    \internal
-    \since 4.1
-
-    If \a gotFocus is true, \a widget will become the active window.
-    Otherwise the active window is reset to 0.
-*/
 void QApplication::winFocus(QWidget *widget, bool gotFocus)
 {
     if (d_func()->inPopupMode()) // some delayed focus event to ignore
@@ -1732,6 +1725,21 @@ LRESULT CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam
             // fall-through intended
         case WM_KEYUP:
         case WM_SYSKEYUP:
+#if Q_OS_WINCE_WM
+        case WM_HOTKEY:
+            if(HIWORD(msg.lParam) == VK_TBACK) {
+                const bool hotKeyDown = !(LOWORD(msg.lParam) & MOD_KEYUP);
+                msg.lParam = 0x69 << 16;
+                msg.wParam = VK_BACK;
+                if (hotKeyDown) {
+                    msg.message = WM_KEYDOWN;
+                    qt_keymapper_private()->updateKeyMap(msg);
+                } else {
+                    msg.message = WM_KEYUP;
+                }
+            }
+            // fall-through intended
+#endif
         case WM_IME_CHAR:
         case WM_IME_KEYDOWN:
         case WM_CHAR: {
@@ -2432,10 +2440,12 @@ LRESULT CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam
                     widget = (QETWidget*)qApp->focusWidget();
                 HWND focus = ::GetFocus();
                 //if there is a current widget and the new widget belongs to the same toplevel window
+                //or if the current widget was embedded into non-qt window (i.e. we won't get WM_ACTIVATEAPP)
                 //then we clear the focus on the widget
                 //in case the new widget belongs to a different widget hierarchy, clearing the focus
                 //will be handled because the active window will change
-                if (widget && ::IsChild(widget->window()->internalWinId(), focus)) {
+                const bool embedded = widget && ((QETWidget*)widget->window())->topData()->embedded;
+                if (widget && (embedded || ::IsChild(widget->window()->internalWinId(), focus))) {
                     widget->clearFocus();
                     result = true;
                 } else {
@@ -2919,7 +2929,6 @@ void qt_win_eatMouseMove()
 
 // In DnD, the mouse release event never appears, so the
 // mouse button state machine must be manually reset
-/*! \internal */
 void QApplication::winMouseButtonUp()
 {
     qt_button_down = 0;
diff --git a/src/gui/kernel/qapplication_x11.cpp b/src/gui/kernel/qapplication_x11.cpp
index b1270bc..a3c9406 100644
--- a/src/gui/kernel/qapplication_x11.cpp
+++ b/src/gui/kernel/qapplication_x11.cpp
@@ -398,7 +398,7 @@ extern bool qt_xdnd_dragging;
 // gui or non-gui from qapplication.cpp
 extern bool qt_is_gui_used;
 
-/*! 
+/*!
     \internal
     Try to resolve a \a symbol from \a library with the version specified
     by \a vernum.
@@ -836,7 +836,7 @@ bool QApplicationPrivate::x11_apply_settings()
     }
 
     int kdeSessionVersion = QString::fromLocal8Bit(qgetenv("KDE_SESSION_VERSION")).toInt();
- 
+
     if (!appFont) {
         QFont font(QApplication::font());
         QString fontDescription;
@@ -1948,11 +1948,17 @@ void qt_init(QApplicationPrivate *priv, int,
         {
             QString displayName = QLatin1String(XDisplayName(NULL));
 
-            // apparently MITSHM only works for local displays, so do a quick check here
-            // to determine whether the display is local or not (not 100 % accurate)
+            // MITSHM only works for local displays, so do a quick check here
+            // to determine whether the display is local or not (not 100 % accurate).
+            // BGR server layouts are not supported either, since it requires the raster
+            // engine to work on a QImage with BGR layout.
             bool local = displayName.isEmpty() || displayName.lastIndexOf(QLatin1Char(':')) == 0;
-            if (local && (qgetenv("QT_X11_NO_MITSHM").toInt() == 0))
-                X11->use_mitshm = mitshm_pixmaps;
+            if (local && (qgetenv("QT_X11_NO_MITSHM").toInt() == 0)) {
+                Visual *defaultVisual = DefaultVisual(X11->display, DefaultScreen(X11->display));
+                X11->use_mitshm = mitshm_pixmaps && (defaultVisual->red_mask == 0xff0000
+                                                     && defaultVisual->green_mask == 0xff00
+                                                     && defaultVisual->blue_mask == 0xff);
+            }
         }
 #endif // QT_NO_MITSHM
 
@@ -2970,11 +2976,6 @@ QWidget *QApplication::topLevelAt(const QPoint &p)
 #endif
 }
 
-/*!
-    Synchronizes with the X server in the X11 implementation. This
-    normally takes some time. Does nothing on other platforms.
-*/
-
 void QApplication::syncX()
 {
     if (X11->display)
@@ -3080,9 +3081,6 @@ static QETWidget *qPRFindWidget(Window oldwin)
     return wPRmapper ? (QETWidget*)wPRmapper->value((int)oldwin, 0) : 0;
 }
 
-/*!
-    \internal
-*/
 int QApplication::x11ClientMessage(QWidget* w, XEvent* event, bool passive_only)
 {
     if (w && !w->internalWinId())
@@ -3145,17 +3143,6 @@ int QApplication::x11ClientMessage(QWidget* w, XEvent* event, bool passive_only)
     return 0;
 }
 
-/*!
-    This function does the core processing of individual X
-    \a{event}s, normally by dispatching Qt events to the right
-    destination.
-
-    It returns 1 if the event was consumed by special handling, 0 if
-    the \a event was consumed by normal handling, and -1 if the \a
-    event was for an unrecognized widget.
-
-    \sa x11EventFilter()
-*/
 int QApplication::x11ProcessEvent(XEvent* event)
 {
     Q_D(QApplication);
@@ -3163,43 +3150,48 @@ int QApplication::x11ProcessEvent(XEvent* event)
 #ifdef ALIEN_DEBUG
     //qDebug() << "QApplication::x11ProcessEvent:" << event->type;
 #endif
+    Time time = 0, userTime = 0;
     switch (event->type) {
     case ButtonPress:
         pressed_window = event->xbutton.window;
-        X11->userTime = event->xbutton.time;
+        userTime = event->xbutton.time;
         // fallthrough intended
     case ButtonRelease:
-        X11->time = event->xbutton.time;
+        time = event->xbutton.time;
         break;
     case MotionNotify:
-        X11->time = event->xmotion.time;
+        time = event->xmotion.time;
         break;
     case XKeyPress:
-        X11->userTime = event->xkey.time;
+        userTime = event->xkey.time;
         // fallthrough intended
     case XKeyRelease:
-        X11->time = event->xkey.time;
+        time = event->xkey.time;
         break;
     case PropertyNotify:
-        X11->time = event->xproperty.time;
+        time = event->xproperty.time;
         break;
     case EnterNotify:
     case LeaveNotify:
-        X11->time = event->xcrossing.time;
+        time = event->xcrossing.time;
         break;
     case SelectionClear:
-        X11->time = event->xselectionclear.time;
+        time = event->xselectionclear.time;
         break;
     default:
-        break;
-    }
 #ifndef QT_NO_XFIXES
-    if (X11->use_xfixes && event->type == (X11->xfixes_eventbase + XFixesSelectionNotify)) {
-        XFixesSelectionNotifyEvent *req =
-            reinterpret_cast<XFixesSelectionNotifyEvent *>(event);
-        X11->time = req->selection_timestamp;
-    }
+        if (X11->use_xfixes && event->type == (X11->xfixes_eventbase + XFixesSelectionNotify)) {
+            XFixesSelectionNotifyEvent *req =
+                reinterpret_cast<XFixesSelectionNotifyEvent *>(event);
+            time = req->selection_timestamp;
+        }
 #endif
+        break;
+    }
+    if (time > X11->time)
+        X11->time = time;
+    if (userTime > X11->userTime)
+        X11->userTime = userTime;
 
     QETWidget *widget = (QETWidget*)QWidget::find((WId)event->xany.window);
 
@@ -3832,29 +3824,6 @@ int QApplication::x11ProcessEvent(XEvent* event)
     return 0;
 }
 
-/*!
-    \fn bool QApplication::x11EventFilter(XEvent *event)
-
-    \warning This virtual function is only implemented under X11.
-
-    If you create an application that inherits QApplication and
-    reimplement this function, you get direct access to all X events
-    that the are received from the X server. The events are passed in
-    the \a event parameter.
-
-    Return true if you want to stop the event from being processed.
-    Return false for normal event dispatching. The default
-    implementation returns false.
-
-    It is only the directly addressed messages that are filtered.
-    You must install an event filter directly on the event
-    dispatcher, which is returned by
-    QAbstractEventDispatcher::instance(), to handle system wide
-    messages.
-
-    \sa x11ProcessEvent()
-*/
-
 bool QApplication::x11EventFilter(XEvent *)
 {
     return false;
diff --git a/src/gui/kernel/qcocoaapplicationdelegate_mac.mm b/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
index 6571068..9a24645 100644
--- a/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
+++ b/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
@@ -183,27 +183,32 @@ 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
 {
     Q_UNUSED(aNotification);
     inLaunch = false;
+    extern void qt_release_apple_event_handler(); //qapplication_mac.mm
+    qt_release_apple_event_handler();
 }
 
 - (void)application:(NSApplication *)sender openFiles:(NSArray *)filenames
diff --git a/src/gui/kernel/qcocoaview_mac.mm b/src/gui/kernel/qcocoaview_mac.mm
index e84af90..4ceae3f 100644
--- a/src/gui/kernel/qcocoaview_mac.mm
+++ b/src/gui/kernel/qcocoaview_mac.mm
@@ -198,6 +198,7 @@ extern "C" {
     }
     composing = false;
     sendKeyEvents = true;
+    currentCustomTypes = 0;
     [self setHidden:YES];
     return self;
 }
@@ -212,10 +213,16 @@ extern "C" {
                                                object:self];
 }
 
--(void)registerDragTypes:(bool)accept
+-(void)registerDragTypes
 {
     QMacCocoaAutoReleasePool pool;
-    if (accept) {
+    // Calling registerForDraggedTypes is slow, so only do it once for each widget
+    // or when the custom types change.
+    const QStringList& customTypes = qEnabledDraggedTypes();
+    if (currentCustomTypes == 0 || *currentCustomTypes != customTypes) {
+        if (currentCustomTypes == 0)
+            currentCustomTypes = new QStringList();
+        *currentCustomTypes = customTypes;
         const NSString* mimeTypeGeneric = @"com.trolltech.qt.MimeTypeName";
 	NSMutableArray *supportedTypes = [NSMutableArray arrayWithObjects:NSColorPboardType, 
                                    NSFilenamesPboardType, NSStringPboardType, 
@@ -227,13 +234,10 @@ extern "C" {
                                    NSFilesPromisePboardType, NSInkTextPboardType, 
                                    NSMultipleTextSelectionPboardType, mimeTypeGeneric, nil];
         // Add custom types supported by the application.
-        const QStringList& customTypes = qEnabledDraggedTypes();
         for (int i = 0; i < customTypes.size(); i++) {
            [supportedTypes addObject:reinterpret_cast<const NSString *>(QCFString::toCFStringRef(customTypes[i]))];
         }
         [self registerForDraggedTypes:supportedTypes];
-    } else {
-        [self unregisterDraggedTypes];
     }
 }
 
@@ -282,6 +286,8 @@ extern "C" {
 
 - (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender 
 { 
+    if (qwidget->testAttribute(Qt::WA_DropSiteRegistered) == false)
+        return NSDragOperationNone;
     [self addDropData:sender];
     QMimeData *mimeData = dropData;
     if (QDragManager::self()->source())
@@ -292,9 +298,18 @@ extern "C" {
     QPoint posDrag(localPoint.x, localPoint.y);
     NSDragOperation nsActions = [sender draggingSourceOperationMask]; 
     Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations(nsActions);
+    QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) = nsActions;
+    Qt::KeyboardModifiers modifiers  = Qt::NoModifier;
+    if ([sender draggingSource] != nil) {
+        // modifier flags might have changed, update it here since we don't send any input events.
+        QApplicationPrivate::modifier_buttons = qt_cocoaModifiers2QtModifiers([[NSApp currentEvent] modifierFlags]);
+        modifiers = QApplication::keyboardModifiers();
+    } else {
+        // when the source is from another application the above technique will not work.
+        modifiers = qt_cocoaDragOperation2QtModifiers(nsActions);
+    }
     // send the drag enter event to the widget.
-    QDragEnterEvent qDEEvent(posDrag, qtAllowed, mimeData,
-            QApplication::mouseButtons(), QApplication::keyboardModifiers());
+    QDragEnterEvent qDEEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
     QApplication::sendEvent(qwidget, &qDEEvent);
     if (!qDEEvent.isAccepted()) {
         // widget is not interested in this drag, so ignore this drop data.
@@ -302,24 +317,23 @@ extern "C" {
         return NSDragOperationNone;
     } else {
         // send a drag move event immediately after a drag enter event (as per documentation).
-        QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData,
-                QApplication::mouseButtons(), QApplication::keyboardModifiers());
+        QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
         qDMEvent.setDropAction(qDEEvent.dropAction());
         qDMEvent.accept(); // accept by default, since enter event was accepted.
         QApplication::sendEvent(qwidget, &qDMEvent);
         if (!qDMEvent.isAccepted() || qDMEvent.dropAction() == Qt::IgnoreAction) {
             // since we accepted the drag enter event, the widget expects 
             // future drage move events.  
-	    // ### check if we need to treat this like the drag enter event.
+            // ### check if we need to treat this like the drag enter event.
             nsActions = QT_PREPEND_NAMESPACE(qt_mac_mapDropAction)(qDEEvent.dropAction());
         } else {
             nsActions = QT_PREPEND_NAMESPACE(qt_mac_mapDropAction)(qDMEvent.dropAction());
-	}
+        }
         QT_PREPEND_NAMESPACE(qt_mac_copy_answer_rect)(qDMEvent);
-	return nsActions;
+        return nsActions;
     } 
  }
- 
+
 - (NSDragOperation)draggingUpdated:(id < NSDraggingInfo >)sender
 {
     // drag enter event was rejected, so ignore the move event. 
@@ -337,11 +351,19 @@ extern "C" {
     // send drag move event to the widget    
     QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) = nsActions;
     Qt::DropActions qtAllowed = QT_PREPEND_NAMESPACE(qt_mac_mapNSDragOperations)(nsActions);
+    Qt::KeyboardModifiers modifiers  = Qt::NoModifier;
+    if ([sender draggingSource] != nil) {
+        // modifier flags might have changed, update it here since we don't send any input events.
+        QApplicationPrivate::modifier_buttons = qt_cocoaModifiers2QtModifiers([[NSApp currentEvent] modifierFlags]);
+        modifiers = QApplication::keyboardModifiers();
+    } else {
+        // when the source is from another application the above technique will not work.
+        modifiers = qt_cocoaDragOperation2QtModifiers(nsActions);
+    }
     QMimeData *mimeData = dropData;
     if (QDragManager::self()->source())
         mimeData = QDragManager::self()->dragPrivate()->data;
-    QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData,
-            QApplication::mouseButtons(), QApplication::keyboardModifiers());
+    QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
     qDMEvent.setDropAction(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).lastAction);
     qDMEvent.accept();
     QApplication::sendEvent(qwidget, &qDMEvent);
@@ -370,12 +392,12 @@ extern "C" {
 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
 {
     [self addDropData:sender];
-    
+
     NSPoint windowPoint = [sender draggingLocation];
     NSPoint globalPoint = [[sender draggingDestinationWindow] convertBaseToScreen:windowPoint];
     NSPoint localPoint = [self convertPoint:windowPoint fromView:nil];
     QPoint posDrop(localPoint.x, localPoint.y);
-    
+
     NSDragOperation nsActions = [sender draggingSourceOperationMask]; 
     Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations(nsActions);
     QMimeData *mimeData = dropData;
@@ -387,6 +409,8 @@ extern "C" {
     if (QDragManager::self()->object)
         QDragManager::self()->dragPrivate()->target = qwidget;
     QApplication::sendEvent(qwidget, &de);
+    if (QDragManager::self()->object)
+        QDragManager::self()->dragPrivate()->executed_action = de.dropAction();
     if (!de.isAccepted())
         return NO;
     else
@@ -396,6 +420,8 @@ extern "C" {
 - (void)dealloc
 {
     [[NSNotificationCenter defaultCenter] removeObserver:self];
+    delete currentCustomTypes;
+    [self unregisterDraggedTypes];
     [super dealloc];
 }
 
@@ -417,10 +443,9 @@ extern "C" {
 - (void) setFrameSize:(NSSize)newSize
 {
     [super setFrameSize:newSize];
- 
+
     // A change in size has required the view to be invalidated.
-    if ([self inLiveResize])
-    {
+    if ([self inLiveResize]) {
         NSRect rects[4];
         NSInteger count;
         [self getRectsExposedDuringLiveResize:rects count:&count];
@@ -428,9 +453,7 @@ extern "C" {
         {
             [self setNeedsDisplayInRect:rects[count]];
         }
-    }
-    else
-    {
+    } else {
         [self setNeedsDisplay:YES];
     }
 }
@@ -565,7 +588,7 @@ extern "C" {
     if (!qAppInstance()->activeModalWidget() || QApplicationPrivate::tryModalHelper(qwidget, 0)) {
         QApplication::sendEvent(qwidget, &enterEvent);
         qt_mouseover = qwidget;
-        
+
         // Update cursor and dispatch hover events.
         qt_mac_update_cursor_at_global_pos(flipPoint(globalPoint).toPoint());
         if (qwidget->testAttribute(Qt::WA_Hover) &&
@@ -620,7 +643,7 @@ extern "C" {
         [viewsToLookAt addObject:qt_mac_nativeview_for(parentWidget)];
         parentWidget = parentWidget->parentWidget();
     }
-    
+
     // Now walk through the subviews of each view and determine which subview should
     // get the event. We look through all the subviews at a given level with
     // the assumption that the last item to be found the candidate has a higher z-order.
@@ -756,7 +779,7 @@ extern "C" {
     if (currentIManager && [currentIManager wantsToHandleMouseEvents]) {
         [currentIManager handleMouseEvent:theEvent];
     }
-    
+
     NSPoint windowPoint = [theEvent locationInWindow];
     NSPoint globalPoint = [[theEvent window] convertBaseToScreen:windowPoint];
     NSPoint localPoint = [self convertPoint:windowPoint fromView:nil];
@@ -765,7 +788,7 @@ extern "C" {
     Qt::MouseButton buttons = cocoaButton2QtButton([theEvent buttonNumber]);
     bool wheelOK = false;
     Qt::KeyboardModifiers keyMods = qt_cocoaModifiers2QtModifiers([theEvent modifierFlags]);
-    
+
     // Mouse wheel deltas seem to tick in at increments of 0.1. Qt widgets
     // expect the delta to be a multiple of 120. 
     const int ScrollFactor = 10 * 120;
@@ -787,20 +810,20 @@ extern "C" {
             wheelOK = qwe2.isAccepted();
         }
     }
-    
+
     if (deltaY) {
         QWheelEvent qwe(qlocal, qglobal, deltaY, buttons, keyMods, Qt::Vertical);
         qt_sendSpontaneousEvent(qwidget, &qwe);
         wheelOK = qwe.isAccepted();
-        if (wheelOK && QApplicationPrivate::focus_widget
+        if (!wheelOK && QApplicationPrivate::focus_widget
             && QApplicationPrivate::focus_widget != qwidget) {
             QWheelEvent qwe2(QApplicationPrivate::focus_widget->mapFromGlobal(qglobal), qglobal,
-                             deltaZ, buttons, keyMods, Qt::Vertical);
+                             deltaY, buttons, keyMods, Qt::Vertical);
             qt_sendSpontaneousEvent(QApplicationPrivate::focus_widget, &qwe2);
             wheelOK = qwe2.isAccepted();
         }
     }
-    
+
     if (deltaZ) {
         // Qt doesn't explicitly support wheels with a Z component. In a misguided attempt to
         // try to be ahead of the pack, I'm adding this extra value.
@@ -889,6 +912,11 @@ extern "C" {
     Q_UNUSED(anImage);
     Q_UNUSED(aPoint);
     qMacDnDParams()->performedAction = operation;
+    if (QDragManager::self()->object
+        && QDragManager::self()->dragPrivate()->executed_action != Qt::ActionMask) {
+        qMacDnDParams()->performedAction =
+                qt_mac_mapDropAction(QDragManager::self()->dragPrivate()->executed_action);
+    }
 }
 
 - (QWidget *)qt_qwidget
@@ -1202,13 +1230,13 @@ Qt::DropAction QDragManager::drag(QDrag *o)
      so we just bail early to prevent it */
     if(!(GetCurrentEventButtonState() & kEventMouseButtonPrimary))
         return Qt::IgnoreAction;
-    
+
     if(object) {
         dragPrivate()->source->removeEventFilter(this);
         cancel();
         beingCancelled = false;
     }
-    
+
     object = o;
     dragPrivate()->target = 0;
 
@@ -1220,7 +1248,7 @@ Qt::DropAction QDragManager::drag(QDrag *o)
     QMacPasteboard dragBoard((CFStringRef) NSDragPboard, QMacPasteboardMime::MIME_DND);
     dragPrivate()->data->setData(QLatin1String("application/x-qt-mime-type-name"), QByteArray());
     dragBoard.setMimeData(dragPrivate()->data);
-    
+
     // create the image
     QPoint hotspot;
     QPixmap pix = dragPrivate()->pixmap;
@@ -1266,6 +1294,7 @@ Qt::DropAction QDragManager::drag(QDrag *o)
     NSSize mouseOffset = {0.0, 0.0};
     NSPasteboard *pboard = [NSPasteboard pasteboardWithName:NSDragPboard];
     NSPoint windowPoint = [dndParams->theEvent locationInWindow];
+    dragPrivate()->executed_action = Qt::ActionMask;
     // do the drag
     [dndParams->view retain];
     [dndParams->view dragImage:image
@@ -1277,6 +1306,7 @@ Qt::DropAction QDragManager::drag(QDrag *o)
                      slideBack:YES];
     [dndParams->view release];
     [image release];
+    dragPrivate()->executed_action = Qt::IgnoreAction;
     object = 0;
     Qt::DropAction performedAction(qt_mac_mapNSDragOperation(dndParams->performedAction));
     // do post drag processing, if required.
diff --git a/src/gui/kernel/qcocoaview_mac_p.h b/src/gui/kernel/qcocoaview_mac_p.h
index 9de94d5..983c762 100644
--- a/src/gui/kernel/qcocoaview_mac_p.h
+++ b/src/gui/kernel/qcocoaview_mac_p.h
@@ -83,6 +83,7 @@ Q_GUI_EXPORT
     bool composing;
     int composingLength;
     bool sendKeyEvents;
+    QStringList *currentCustomTypes;
 }
 - (id)initWithQWidget:(QWidget *)widget widgetPrivate:(QWidgetPrivate *)widgetprivate;
 - (void) finishInitWithQWidget:(QWidget *)widget widgetPrivate:(QWidgetPrivate *)widgetprivate;
@@ -91,7 +92,7 @@ Q_GUI_EXPORT
 - (NSDragOperation)draggingUpdated:(id < NSDraggingInfo >)sender;
 - (void)draggingExited:(id < NSDraggingInfo >)sender;
 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender;
-- (void)registerDragTypes:(bool)accept;
+- (void)registerDragTypes;
 - (void)removeDropData;
 - (void)addDropData:(id <NSDraggingInfo>)sender;
 - (void)setSupportedActions:(NSDragOperation)actions;
diff --git a/src/gui/kernel/qcocoawindowdelegate_mac.mm b/src/gui/kernel/qcocoawindowdelegate_mac.mm
index 03b2fce..fa325f4 100644
--- a/src/gui/kernel/qcocoawindowdelegate_mac.mm
+++ b/src/gui/kernel/qcocoawindowdelegate_mac.mm
@@ -194,7 +194,6 @@ static void cleanupCocoaWindowDelegate()
 {
     NSWindow *window = [notification object];
     QWidget *qwidget = m_windowHash->value(window);
-    // Just here to handle the is zoomed method.
     QWidgetData *widgetData = qt_qwidget_data(qwidget);
     if (!(qwidget->windowState() & (Qt::WindowMaximized | Qt::WindowFullScreen)) && [window isZoomed]) {
         widgetData->window_state = widgetData->window_state | Qt::WindowMaximized;
@@ -202,7 +201,6 @@ static void cleanupCocoaWindowDelegate()
                                                    & ~Qt::WindowMaximized));
         qt_sendSpontaneousEvent(qwidget, &e);
     }
-    [self checkForMove:[window frame] forWidget:qwidget];
     NSRect rect = [[window contentView] frame];
     const QSize newSize(rect.size.width, rect.size.height);
     const QSize &oldSize = widgetData->crect.size();
@@ -212,12 +210,18 @@ static void cleanupCocoaWindowDelegate()
     }
 }
 
-- (void)checkForMove:(const NSRect &)newRect forWidget:(QWidget *)qwidget
+- (void)windowDidMove:(NSNotification *)notification
 {
-    // newRect's origin is bottom left.
+    // The code underneath needs to translate the window location
+    // from bottom left (which is the origin used by Cocoa) to
+    // upper left (which is the origin used by Qt):
+    NSWindow *window = [notification object];
+    NSRect newRect = [window frame];
+    QWidget *qwidget = m_windowHash->value(window);
     QPoint qtPoint = flipPoint(NSMakePoint(newRect.origin.x,
                                            newRect.origin.y + newRect.size.height)).toPoint();
     const QRect &oldRect = qwidget->frameGeometry();
+
     if (qtPoint.x() != oldRect.x() || qtPoint.y() != oldRect.y()) {
         QWidgetData *widgetData = qt_qwidget_data(qwidget);
         QRect oldCRect = widgetData->crect;
@@ -233,11 +237,6 @@ static void cleanupCocoaWindowDelegate()
     }
 }
 
-- (void)windowDidMove:(NSNotification *)notification
-{
-    [self windowDidResize:notification];
-}
-
 -(BOOL)windowShouldClose:(id)windowThatWantsToClose
 {
     QWidget *qwidget = m_windowHash->value(windowThatWantsToClose);
diff --git a/src/gui/kernel/qevent.cpp b/src/gui/kernel/qevent.cpp
index 8c7e47d..2aed287 100644
--- a/src/gui/kernel/qevent.cpp
+++ b/src/gui/kernel/qevent.cpp
@@ -675,12 +675,13 @@ QWheelEvent::QWheelEvent(const QPoint &pos, const QPoint& globalPos, int delta,
     The \a type parameter must be QEvent::KeyPress, QEvent::KeyRelease,
     or QEvent::ShortcutOverride.
 
-    If \a key is 0, the event is not a result of
-    a known key; for example, it may be the result of a compose
-    sequence or keyboard macro. The \a modifiers holds the keyboard
-    modifiers, and the given \a text is the Unicode text that the
-    key generated. If \a autorep is true, isAutoRepeat() will be
-    true. \a count is the number of keys involved in the event.
+    Int \a key is the code for the Qt::Key that the event loop should listen 
+    for. If \a key is 0, the event is not a result of a known key; for 
+    example, it may be the result of a compose sequence or keyboard macro.
+    The \a modifiers holds the keyboard modifiers, and the given \a text 
+    is the Unicode text that the key generated. If \a autorep is true, 
+    isAutoRepeat() will be true. \a count is the number of keys involved 
+    in the event.
 */
 QKeyEvent::QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text,
                      bool autorep, ushort count)
diff --git a/src/gui/kernel/qlayout.cpp b/src/gui/kernel/qlayout.cpp
index aa46249..4463aab 100644
--- a/src/gui/kernel/qlayout.cpp
+++ b/src/gui/kernel/qlayout.cpp
@@ -1028,8 +1028,13 @@ void QLayout::freeze(int w, int h)
 void QLayout::setMenuBar(QWidget *widget)
 {
     Q_D(QLayout);
-    if (widget)
-        addChildWidget(widget);
+
+#ifdef Q_OS_WINCE_WM
+    if (widget && widget->size().height() > 0)
+#else
+        if (widget)
+#endif
+            addChildWidget(widget);
     d->menubar = widget;
 }
 
@@ -1239,7 +1244,7 @@ bool QLayout::activate()
     Must be implemented in subclasses to remove the layout item at \a
     index from the layout, and return the item. If there is no such
     item, the function must do nothing and return 0.  Items are numbered
-    consecutively from 0. If an item is deleted, other items will be
+    consecutively from 0. If an item is removed, other items will be
     renumbered.
 
     The following code fragment shows a safe way to remove all items
diff --git a/src/gui/kernel/qshortcutmap.cpp b/src/gui/kernel/qshortcutmap.cpp
index ed9654b..86894b4 100644
--- a/src/gui/kernel/qshortcutmap.cpp
+++ b/src/gui/kernel/qshortcutmap.cpp
@@ -753,6 +753,7 @@ bool QShortcutMap::correctGraphicsWidgetContext(Qt::ShortcutContext context, QGr
                 tw = tw->parentWidget();
             return tw == w;
         }
+        return false;
     }
 
     // Below is Qt::WindowShortcut context
diff --git a/src/gui/kernel/qt_cocoa_helpers_mac.mm b/src/gui/kernel/qt_cocoa_helpers_mac.mm
index 52e76d8..9165836 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac.mm
+++ b/src/gui/kernel/qt_cocoa_helpers_mac.mm
@@ -515,6 +515,18 @@ Qt::KeyboardModifiers qt_cocoaModifiers2QtModifiers(ulong modifierFlags)
     return qtMods;
 }
 
+Qt::KeyboardModifiers qt_cocoaDragOperation2QtModifiers(uint dragOperations)
+{
+    Qt::KeyboardModifiers qtMods =Qt::NoModifier;
+    if (dragOperations &  NSDragOperationLink)
+        qtMods |= Qt::MetaModifier;
+    if (dragOperations & NSDragOperationGeneric)
+        qtMods |= Qt::ControlModifier;
+    if (dragOperations & NSDragOperationCopy)
+        qtMods |= Qt::AltModifier;
+    return qtMods;
+}
+
 static inline QEvent::Type cocoaEvent2QtEvent(NSUInteger eventType)
 {
     // Handle the trivial cases that can be determined from the type.
@@ -814,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/qt_cocoa_helpers_mac_p.h b/src/gui/kernel/qt_cocoa_helpers_mac_p.h
index ef55aa4..63a301c 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac_p.h
+++ b/src/gui/kernel/qt_cocoa_helpers_mac_p.h
@@ -141,6 +141,7 @@ inline QApplication *qAppInstance() { return static_cast<QApplication *>(QCoreAp
 struct ::TabletProximityRec;
 void qt_dispatchTabletProximityEvent(const ::TabletProximityRec &proxRec);
 Qt::KeyboardModifiers qt_cocoaModifiers2QtModifiers(ulong modifierFlags);
+Qt::KeyboardModifiers qt_cocoaDragOperation2QtModifiers(uint dragOperations);
 inline int flipYCoordinate(int y)
 {
     return QApplication::desktop()->screenGeometry(0).height() - y;    
diff --git a/src/gui/kernel/qt_mac.cpp b/src/gui/kernel/qt_mac.cpp
index b1247e8..44e10a8 100644
--- a/src/gui/kernel/qt_mac.cpp
+++ b/src/gui/kernel/qt_mac.cpp
@@ -131,7 +131,7 @@ QColor qcolorForTheme(ThemeBrush brush)
 
 QColor qcolorForThemeTextColor(ThemeTextColor themeColor)
 {
-#ifdef QT_OS_MAC32
+#ifdef Q_OS_MAC32
     RGBColor c;
     GetThemeTextColor(themeColor, 32, true, &c);
     QColor color = QColor(c.red / 265, c.green / 256, c.blue / 256);
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index 31fed5e..d911b48 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -183,6 +183,7 @@ QWidgetPrivate::QWidgetPrivate(int version) :
         ,inDirtyList(0)
         ,isScrolled(0)
         ,isMoved(0)
+        ,usesDoubleBufferedGLContext(0)
 #ifdef Q_WS_WIN
         ,noPaintOnScreen(0)
 #endif
@@ -2132,6 +2133,10 @@ QWidget *QWidget::find(WId id)
     If a widget is non-native (alien) and winId() is invoked on it, that widget
     will be provided a native handle.
 
+    On Mac OS X, the type returned depends on which framework Qt was linked
+    against. If Qt is using Carbon, the {WId} is actually an HIViewRef. If Qt
+    is using Cocoa, {WId} is a pointer to an NSView.
+
     \note We recommend that you do not store this value as it is likely to
     change at run-time.
 
@@ -2234,9 +2239,10 @@ WId QWidget::effectiveWinId() const
     The style sheet contains a textual description of customizations to the
     widget's style, as described in the \l{Qt Style Sheets} document.
 
-    \note Qt style sheets are currently not supported for QMacStyle
-    (the default style on Mac OS X). We plan to address this in some future
-    release.
+    Since Qt 4.5, Qt style sheets fully supports Mac OS X.
+
+    \warning Qt style sheets are currently not supported for custom QStyle
+    subclasses. We plan to address this in some future release.
 
     \sa setStyle(), QApplication::styleSheet, {Qt Style Sheets}
 */
@@ -4708,10 +4714,13 @@ void QWidget::render(QPaintDevice *target, const QPoint &targetOffset,
     if (redirected) {
         target = redirected;
         offset -= redirectionOffset;
-        if (!inRenderWithPainter) { // Clip handled by shared painter (in qpainter.cpp).
-            const QRegion redirectedSystemClip = redirected->paintEngine()->systemClip();
-            if (!redirectedSystemClip.isEmpty())
-                paintRegion &= redirectedSystemClip.translated(-offset);
+    }
+
+    if (!inRenderWithPainter) { // Clip handled by shared painter (in qpainter.cpp).
+        if (QPaintEngine *targetEngine = target->paintEngine()) {
+            const QRegion targetSystemClip = targetEngine->systemClip();
+            if (!targetSystemClip.isEmpty())
+                paintRegion &= targetSystemClip.translated(-offset);
         }
     }
 
@@ -4796,7 +4805,7 @@ void QWidget::render(QPainter *painter, const QPoint &targetOffset,
     Q_ASSERT(engine);
     QPaintEnginePrivate *enginePriv = engine->d_func();
     Q_ASSERT(enginePriv);
-    QPaintDevice *target = painter->worldMatrixEnabled() ? engine->paintDevice() : painter->device();
+    QPaintDevice *target = engine->paintDevice();
     Q_ASSERT(target);
 
     // Render via a pixmap when dealing with non-opaque painters or printers.
@@ -4815,8 +4824,13 @@ void QWidget::render(QPainter *painter, const QPoint &targetOffset,
     const QRegion oldSystemClip = enginePriv->systemClip;
     const QRegion oldSystemViewport = enginePriv->systemViewport;
 
-    // This ensures that transformed system clips are inside the current system clip.
-    enginePriv->setSystemViewport(oldSystemClip);
+    // This ensures that all painting triggered by render() is clipped to the current engine clip.
+    if (painter->hasClipping()) {
+        const QRegion painterClip = painter->deviceTransform().map(painter->clipRegion());
+        enginePriv->setSystemViewport(oldSystemClip.isEmpty() ? painterClip : oldSystemClip & painterClip);
+    } else {
+        enginePriv->setSystemViewport(oldSystemClip);
+    }
 
     render(target, targetOffset, toBePainted, renderFlags);
 
@@ -11418,3 +11432,17 @@ void QWidget::clearMask()
     setMask(QRegion());
 }
 
+/*! \fn const QX11Info &QWidget::x11Info() const
+    Returns information about the configuration of the X display used to display
+    the widget.
+
+    \warning This function is only available on X11.
+*/
+
+/*! \fn Qt::HANDLE QWidget::x11PictureHandle() const
+    Returns the X11 Picture handle of the widget for XRender
+    support. Use of this function is not portable. This function will
+    return 0 if XRender support is not compiled into Qt, if the
+    XRender extension is not supported on the X11 display, or if the
+    handle could not be created.
+*/
diff --git a/src/gui/kernel/qwidget_mac.mm b/src/gui/kernel/qwidget_mac.mm
index 2c3f7f1..b315eaf 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,6 +4003,53 @@ void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
     }
 }
 
+void QWidgetPrivate::adjustWithinMaxAndMinSize(int &w, int &h)
+{
+    if (QWExtra *extra = extraData()) {
+        w = qMin(w, extra->maxw);
+        h = qMin(h, extra->maxh);
+        w = qMax(w, extra->minw);
+        h = qMax(h, extra->minh);
+
+        // Deal with size increment
+        if (QTLWExtra *top = topData()) {
+            if(top->incw) {
+                w = w/top->incw;
+                w *= top->incw;
+            }
+            if(top->inch) {
+                h = h/top->inch;
+                h *= top->inch;
+            }
+        }
+    }
+
+    if (isRealWindow()) {
+        w = qMax(0, w);
+        h = qMax(0, 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);
@@ -4011,12 +4060,19 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
 
     QMacCocoaAutoReleasePool pool;
     bool realWindow = isRealWindow();
-    if (realWindow && !(w == 0 && h == 0) && !q->testAttribute(Qt::WA_DontShowOnScreen)) {
-        topData()->isSetGeometry = 1;
-        topData()->isMove = isMove;
+
+    if (realWindow && !q->testAttribute(Qt::WA_DontShowOnScreen)){
+        adjustWithinMaxAndMinSize(w, h);
 #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();
@@ -4025,9 +4081,25 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
                                     fStrut.top() + fStrut.bottom() + h));
         NSRect cocoaFrameRect = NSMakeRect(frameRect.x(), flipYCoordinate(frameRect.bottom() + 1),
                                            frameRect.width(), frameRect.height());
-        [window setFrame:cocoaFrameRect display:NO];
+
+        QPoint currTopLeft = data.crect.topLeft();
+        if (currTopLeft.x() == x && currTopLeft.y() == y
+                && cocoaFrameRect.size.width != 0
+                && cocoaFrameRect.size.height != 0) {
+            [window setFrame:cocoaFrameRect display:NO];
+        } else {
+            // The window is moved and resized (or resized to zero).
+            // Since Cocoa usually only sends us a resize callback after
+            // setting a window frame, we issue an explicit move as
+            // well. To stop Cocoa from optimize away the move (since the move
+            // would have the same origin as the setFrame call) we shift the
+            // window back and forth inbetween.
+            cocoaFrameRect.origin.y += 1;
+            [window setFrame:cocoaFrameRect display:NO];
+            cocoaFrameRect.origin.y -= 1;
+            [window setFrameOrigin:cocoaFrameRect.origin];
+        }
 #endif
-        topData()->isSetGeometry = 0;
     } else {
         setGeometry_sys_helper(x, y, w, h, isMove);
     }
@@ -4037,74 +4109,34 @@ void QWidgetPrivate::setGeometry_sys_helper(int x, int y, int w, int h, bool isM
 {
     Q_Q(QWidget);
     bool realWindow = isRealWindow();
-    if(QWExtra *extra = extraData()) {        // any size restrictions?
-        if(realWindow) {
-            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
-            }
-        }
-
-        w = qMin(w,extra->maxw);
-        h = qMin(h,extra->maxh);
-        w = qMax(w,extra->minw);
-        h = qMax(h,extra->minh);
-
-        // Deal with size increment
-        if(QTLWExtra *top = topData()) {
-            if(top->incw) {
-                w = w/top->incw;
-                w *= top->incw;
-            }
-            if(top->inch) {
-                h = h/top->inch;
-                h *= top->inch;
-            }
-        }
-    }
-
-    if (realWindow) {
-        w = qMax(0, w);
-        h = qMax(0, h);
-    }
 
     QPoint oldp = q->pos();
     QSize  olds = q->size();
     const bool isResize = (olds != QSize(w, h));
-    if(!realWindow && !isResize && QPoint(x, y) == oldp)
+
+    if (!realWindow && !isResize && QPoint(x, y) == oldp)
         return;
-    if(isResize && q->isMaximized())
+
+    if (isResize)
         data.window_state = data.window_state & ~Qt::WindowMaximized;
+
     const bool visible = q->isVisible();
     data.crect = QRect(x, y, w, h);
 
-    if(realWindow) {
-        if(QWExtra *extra = extraData()) { //set constraints
-            const float max_f(20000);
+    if (realWindow) {
+        adjustWithinMaxAndMinSize(w, h);
+        qt_mac_update_sizer(q);
+
 #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
+        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);
+            }
         }
-#ifndef QT_MAC_USE_COCOA
         HIRect bounds = CGRectMake(0, 0, w, h);
         HIViewSetFrame(qt_mac_nativeview_for(q), &bounds);
 #else
@@ -4150,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()
@@ -4464,8 +4497,8 @@ void QWidgetPrivate::registerDropSite(bool on)
     SetControlDragTrackingEnabled(qt_mac_nativeview_for(q), on);
 #else
     NSView *view = qt_mac_nativeview_for(q);
-    if ([view isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaView) class]]) {
-        [static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(view) registerDragTypes:on];
+    if (on && [view isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaView) class]]) {
+        [static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(view) registerDragTypes];
     }
 #endif
 }
@@ -4627,8 +4660,11 @@ void QWidgetPrivate::setModal_sys()
 
     if (windowParent && q->windowModality() == Qt::WindowModal){
         // Window should be window-modal, which implies a sheet.
-        if (!alreadySheet)
+        if (!alreadySheet) {
+            // NB: the following call will call setModal_sys recursivly:
             recreateMacWindow();
+            windowRef = qt_mac_window_for(q);
+        }
         if ([windowRef isKindOfClass:[NSPanel class]]){
             // If the primary window of the sheet parent is a child of a modal dialog,
             // the sheet parent should not be modally shaddowed.
diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h
index 9e93f66..2461820 100644
--- a/src/gui/kernel/qwidget_p.h
+++ b/src/gui/kernel/qwidget_p.h
@@ -257,6 +257,8 @@ public:
     void macUpdateIsOpaque();
     void setEnabled_helper_sys(bool enable);
     bool isRealWindow() const;
+    void adjustWithinMaxAndMinSize(int &w, int &h);
+    void applyMaxAndMinSizeOnWindow();
 #endif
 
     void raise_sys();
@@ -535,6 +537,7 @@ public:
     uint inDirtyList : 1;
     uint isScrolled : 1;
     uint isMoved : 1;
+    uint usesDoubleBufferedGLContext : 1;
 
 #ifdef Q_WS_WIN
     uint noPaintOnScreen : 1; // see qwidget_win.cpp ::paintEngine()
diff --git a/src/gui/kernel/qwidget_x11.cpp b/src/gui/kernel/qwidget_x11.cpp
index 76734d4..6202b35 100644
--- a/src/gui/kernel/qwidget_x11.cpp
+++ b/src/gui/kernel/qwidget_x11.cpp
@@ -2747,12 +2747,6 @@ void QWidgetPrivate::setWindowOpacity_sys(qreal opacity)
                     32, PropModeReplace, (uchar*)&value, 1);
 }
 
-/*!
-    Returns information about the configuration of the X display used to display
-    the widget.
-
-    \warning This function is only available on X11.
-*/
 const QX11Info &QWidget::x11Info() const
 {
     Q_D(const QWidget);
@@ -2789,13 +2783,6 @@ QWindowSurface *QWidgetPrivate::createDefaultWindowSurface_sys()
     return new QX11WindowSurface(q_func());
 }
 
-/*!
-    Returns the X11 Picture handle of the widget for XRender
-    support. Use of this function is not portable. This function will
-    return 0 if XRender support is not compiled into Qt, if the
-    XRender extension is not supported on the X11 display, or if the
-    handle could not be created.
-*/
 Qt::HANDLE QWidget::x11PictureHandle() const
 {
 #ifndef QT_NO_XRENDER
diff --git a/src/gui/painting/qbackingstore.cpp b/src/gui/painting/qbackingstore.cpp
index fbac811a..0a3a8dd 100644
--- a/src/gui/painting/qbackingstore.cpp
+++ b/src/gui/painting/qbackingstore.cpp
@@ -492,7 +492,8 @@ static inline void sendUpdateRequest(QWidget *widget, bool updateImmediately)
         return;
 
 #if defined(Q_WS_WIN) && !defined(Q_OS_WINCE)
-    if (QApplicationPrivate::inSizeMove && widget->internalWinId() && !updateImmediately) {
+    if (QApplicationPrivate::inSizeMove && widget->internalWinId() && !updateImmediately
+        && !widget->testAttribute(Qt::WA_DontShowOnScreen)) {
         // Tell Windows to send us a paint event if we're in WM_SIZE/WM_MOVE; posted events
         // are blocked until the mouse button is released. See task 146849.
         const QRegion rgn(qt_dirtyRegion(widget));
@@ -1510,6 +1511,9 @@ void QWidgetPrivate::invalidateBuffer(const QRect &rect)
 
 void QWidgetPrivate::repaint_sys(const QRegion &rgn)
 {
+    if (data.in_destructor)
+        return;
+
     Q_Q(QWidget);
     if (q->testAttribute(Qt::WA_StaticContents)) {
         if (!extra)
@@ -1517,13 +1521,20 @@ void QWidgetPrivate::repaint_sys(const QRegion &rgn)
         extra->staticContentsSize = data.crect.size();
     }
 
+    QPaintEngine *engine = q->paintEngine();
+    // QGLWidget does not support partial updates if:
+    // 1) The context is double buffered
+    // 2) The context is single buffered and auto-fill background is enabled.
+    const bool noPartialUpdateSupport = (engine && engine->type() == QPaintEngine::OpenGL)
+                                        && (usesDoubleBufferedGLContext || q->autoFillBackground());
+    QRegion toBePainted(noPartialUpdateSupport ? q->rect() : rgn);
+
 #ifdef Q_WS_MAC
     // No difference between update() and repaint() on the Mac.
-    update_sys(rgn);
+    update_sys(toBePainted);
     return;
 #endif
 
-    QRegion toBePainted(rgn);
     toBePainted &= clipRect();
     clipToEffectiveMask(toBePainted);
     if (toBePainted.isEmpty())
diff --git a/src/gui/painting/qblendfunctions.cpp b/src/gui/painting/qblendfunctions.cpp
index 6589439..93f11e1 100644
--- a/src/gui/painting/qblendfunctions.cpp
+++ b/src/gui/painting/qblendfunctions.cpp
@@ -44,21 +44,6 @@
 
 QT_BEGIN_NAMESPACE
 
-
-// This ifdef is made with the best of intention. GCC fails to
-// optimzie the code properly so the bytemul approach is the fastest
-// it gets. Both on ARM and on MSVC the code is optimized to be better
-// than the bytemul approach...  On the other hand... This code is
-// almost never run on i386 so it may be downright silly to have this
-// piece of code here...
-#if defined (Q_CC_GNU) && (defined (QT_ARCH_I386) || defined (QT_ARCH_X86_64))
-#  define QT_BLEND_USE_BYTEMUL
-#endif
-
-// #define QT_DEBUG_DRAW
-
-static const qreal aliasedCoordinateDelta = 0.5 - 0.015625;
-
 struct SourceOnlyAlpha
 {
     inline uchar alpha(uchar src) const { return src; }
@@ -153,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();
 
@@ -286,7 +268,7 @@ static void qt_blend_rgb16_on_rgb16(uchar *dst, int dbpl,
                                     int const_alpha)
 {
 #ifdef QT_DEBUG_DRAW
-    printf("qt_blend_argb16_on_rgb16: dst=(%p, %d), src=(%p, %d), dim=(%d, %d) alpha=%d\n",
+    printf("qt_blend_rgb16_on_rgb16: dst=(%p, %d), src=(%p, %d), dim=(%d, %d) alpha=%d\n",
            dst, dbpl, src, sbpl, w, h, const_alpha);
 #endif
 
@@ -347,11 +329,6 @@ template <typename T> void qt_blend_argb24_on_rgb16(uchar *destPixels, int dbpl,
             if (alpha == 255) {
                 *dst = spix;
             } else if (alpha != 0) {
-#ifdef QT_BLEND_USE_BYTEMUL
-                // truncate green channel to avoid overflow
-                *dst = (alphaFunc.bytemul(spix) & 0xffdf)
-                       + (quint16) qrgb565(*dst).byte_mul(qrgb565::ialpha(alpha));
-#else
                 quint16 dpix = *dst;
                 quint32 sia = 255 - alpha;
 
@@ -363,12 +340,11 @@ template <typename T> void qt_blend_argb24_on_rgb16(uchar *destPixels, int dbpl,
                 quint32 siag = dg * sia;
                 quint32 siab = db * sia;
 
-                quint32 rr = ((siar + (siar>>8) + (0x80 << 11)) >> 8) & 0xf800;
-                quint32 rg = ((siag + (siag>>8) + (0x80 <<  5)) >> 8) & 0x07e0;
-                quint32 rb = ((siab + (siab>>8) + (0x80 >>  3)) >> 8);
+                quint32 rr = ((siar + (siar>>8) + (0x80 <<  8)) >> 8) & 0xf800;
+                quint32 rg = ((siag + (siag>>8) + (0x80 <<  3)) >> 8) & 0x07e0;
+                quint32 rb = ((siab + (siab>>8) + (0x80 >>  3)) >> 8) & 0x001f;
 
                 *dst = alphaFunc.bytemul(spix) + rr + rg + rb;
-#endif
             }
 
             ++dst;
@@ -435,113 +411,45 @@ static void qt_blend_argb32_on_rgb16(uchar *destPixels, int dbpl,
     }
 
     quint16 *dst = (quint16 *) destPixels;
-    int dstExtraStride = dbpl / 2 - w;
-
-    const quint32 *src = (const quint32 *) srcPixels;
-    int srcExtraStride = sbpl / 4 - w;
+    quint32 *src = (quint32 *) srcPixels;
 
     for (int y=0; y<h; ++y) {
-        int length = w;
-        const int dstAlign = ((quintptr)dst) & 0x3;
-        if (dstAlign) {
-            const quint8 alpha = qAlpha(*src);
-            if (alpha) {
-                quint16 s = convert_argb32_to_rgb16(*src);
-                if (alpha < 255)
-                    s += BYTE_MUL_RGB16(*dst, 255 - alpha);
-                *dst = s;
-            }
-            ++dst;
-            ++src;
-            --length;
-        }
+        for (int x=0; x<w; ++x) {
 
-        const int length32 = length >> 1;
-        const int srcAlign = ((quintptr)src) & 0x3;
-        if (length32) {
-            if (srcAlign) {
-                for (int i = 0; i < length32; ++i) {
-                    quint32 *dest32 = reinterpret_cast<quint32*>(dst);
-                    const quint8 a1 = qAlpha(src[0]);
-                    const quint8 a2 = qAlpha(src[1]);
-                    quint32 s;
-
-                    if (!a1 && !a2) {
-                        src += 2;
-                        dst +=2;
-                        continue;
-                    }
-
-                    s = convert_argb32_to_rgb16(src[0])
-                        | (convert_argb32_to_rgb16(src[1]) << 16);
-
-                    if (a1 == a2) {
-                        if (a1 < 255) {
-                            const quint8 sa = ((255 - a1)+1) >> 3;
-                            s += BYTE_MUL_RGB16_32(*dest32, sa);
-                        }
-                    } else {
-                        if (a1 < 255)
-                            s += BYTE_MUL_RGB16(dst[0], 255 - a1);
-                        if (a2 < 255)
-                            s += BYTE_MUL_RGB16(dst[1], 255 - a2) << 16;
-                    }
-
-                    *dest32 = s;
-                    src += 2;
-                    dst += 2;
-                }
-            } else {
-                for (int i = 0; i < length32; ++i) {
-                    quint32 *dest32 = reinterpret_cast<quint32*>(dst);
-                    const quint8 a1 = qAlpha(src[0]);
-                    const quint8 a2 = qAlpha(src[1]);
-                    quint32 s;
-
-                    if (!a1 && !a2) {
-                        src += 2;
-                        dst +=2;
-                        continue;
-                    }
-
-                    const quint64 *src64 =
-                        reinterpret_cast<const quint64*>(src);
-                    s = qConvertRgb32To16x2(*src64);
-
-                    if (a1 == a2) {
-                        if (a1 < 255) {
-                            const quint8 sa = ((255 - a1)+1) >> 3;
-                            s += BYTE_MUL_RGB16_32(*dest32, sa);
-                        }
-                    } else {
-                        if (a1 < 255)
-                            s += BYTE_MUL_RGB16(dst[0], 255 - a1);
-                        if (a2 < 255)
-                            s += BYTE_MUL_RGB16(dst[1], 255 - a2) << 16;
-                    }
-
-                    *dest32 = s;
-                    src += 2;
-                    dst += 2;
-                }
-            }
-        }
-        const int tail = length & 0x1;
-        if (tail) {
-            const quint8 alpha = qAlpha(*src);
-            if (alpha) {
-                quint16 s = convert_argb32_to_rgb16(*src);
-                if (alpha < 255)
-                    s += BYTE_MUL_RGB16(*dst, 255 - alpha);
-                *dst = s;
+            quint32 spix = src[x];
+            quint32 alpha = spix >> 24;
+
+            if (alpha == 255) {
+                dst[x] = convert_argb32_to_rgb16(spix);
+            } else if (alpha != 0) {
+                quint32 dpix = dst[x];
+
+                quint32 sia = 255 - alpha;
+
+                quint32 sr = (spix >> 8) & 0xf800;
+                quint32 sg = (spix >> 5) & 0x07e0;
+                quint32 sb = (spix >> 3) & 0x001f;
+
+                quint32 dr = (dpix & 0x0000f800);
+                quint32 dg = (dpix & 0x000007e0);
+                quint32 db = (dpix & 0x0000001f);
+
+                quint32 siar = dr * sia;
+                quint32 siag = dg * sia;
+                quint32 siab = db * sia;
+
+                quint32 rr = sr + ((siar + (siar>>8) + (0x80 << 8)) >> 8);
+                quint32 rg = sg + ((siag + (siag>>8) + (0x80 << 3)) >> 8);
+                quint32 rb = sb + ((siab + (siab>>8) + (0x80 >> 3)) >> 8);
+
+                dst[x] = (rr & 0xf800)
+                         | (rg & 0x07e0)
+                         | (rb);
             }
-            ++dst;
-            ++src;
         }
-        dst += dstExtraStride;
-        src += srcExtraStride;
+        dst = (quint16 *) (((uchar *) dst) + dbpl);
+        src = (quint32 *) (((uchar *) src) + sbpl);
     }
-
 }
 
 
@@ -705,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/qcolormap_win.cpp b/src/gui/painting/qcolormap_win.cpp
index d61b933..7d36582 100644
--- a/src/gui/painting/qcolormap_win.cpp
+++ b/src/gui/painting/qcolormap_win.cpp
@@ -138,7 +138,11 @@ void QColormap::cleanup()
 }
 
 QColormap QColormap::instance(int)
-{ return QColormap(); }
+{
+    Q_ASSERT_X(screenMap, "QColormap",
+               "A QApplication object needs to be constructed before QColormap is used.");
+    return QColormap();
+}
 
 QColormap::QColormap()
     : d(screenMap)
diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
index 018aff5..35d0b52 100644
--- a/src/gui/painting/qdrawhelper.cpp
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -370,7 +370,7 @@ Q_STATIC_TEMPLATE_FUNCTION void QT_FASTCALL destStore(QRasterBuffer *rasterBuffe
                                   Q_TEMPLATE_FIX(DST))
 {
     DST *dest = reinterpret_cast<DST*>(rasterBuffer->scanLine(y)) + x;
-    const quint32 *src = reinterpret_cast<const quint32*>(buffer);
+    const quint32p *src = reinterpret_cast<const quint32p*>(buffer);
     while (length--)
         *dest++ = DST(*src++);
 }
@@ -2400,8 +2400,7 @@ static inline int color_burn_op(int dst, int src, int da, int sa)
 
     if (src == 0 || src_da + dst_sa <= sa_da)
         return qt_div_255(temp);
-    else
-        return qt_div_255(sa * (src_da + dst_sa - sa_da) / src + temp);
+    return qt_div_255(sa * (src_da + dst_sa - sa_da) / src + temp);
 }
 
 template <typename T>
@@ -4763,7 +4762,7 @@ void QT_FASTCALL blendUntransformed(int count, const QSpan *spans, void *userDat
 static void blend_untransformed_rgb888(int count, const QSpan *spans,
                                        void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_24)
+#if defined(QT_QWS_DEPTH_24)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_RGB888)
@@ -4777,7 +4776,7 @@ static void blend_untransformed_rgb888(int count, const QSpan *spans,
 static void blend_untransformed_argb6666(int count, const QSpan *spans,
                                          void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+#if defined(QT_QWS_DEPTH_18)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
@@ -4793,7 +4792,7 @@ static void blend_untransformed_argb6666(int count, const QSpan *spans,
 static void blend_untransformed_rgb666(int count, const QSpan *spans,
                                        void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+#if defined(QT_QWS_DEPTH_18)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
@@ -4809,7 +4808,7 @@ static void blend_untransformed_rgb666(int count, const QSpan *spans,
 static void blend_untransformed_argb8565(int count, const QSpan *spans,
                                          void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+#if defined(QT_QWS_DEPTH_16)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
@@ -4825,7 +4824,7 @@ static void blend_untransformed_argb8565(int count, const QSpan *spans,
 static void blend_untransformed_rgb565(int count, const QSpan *spans,
                                        void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+#if defined(QT_QWS_DEPTH_16)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
@@ -4841,7 +4840,7 @@ static void blend_untransformed_rgb565(int count, const QSpan *spans,
 static void blend_untransformed_argb8555(int count, const QSpan *spans,
                                          void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+#if defined(QT_QWS_DEPTH_15)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
@@ -4857,7 +4856,7 @@ static void blend_untransformed_argb8555(int count, const QSpan *spans,
 static void blend_untransformed_rgb555(int count, const QSpan *spans,
                                        void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+#if defined(QT_QWS_DEPTH_15)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
@@ -4873,7 +4872,7 @@ static void blend_untransformed_rgb555(int count, const QSpan *spans,
 static void blend_untransformed_argb4444(int count, const QSpan *spans,
                                          void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+#if defined(QT_QWS_DEPTH_12)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
@@ -4889,7 +4888,7 @@ static void blend_untransformed_argb4444(int count, const QSpan *spans,
 static void blend_untransformed_rgb444(int count, const QSpan *spans,
                                        void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+#if defined(QT_QWS_DEPTH_12)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
@@ -5084,7 +5083,7 @@ Q_STATIC_TEMPLATE_FUNCTION void blendTiled(int count, const QSpan *spans, void *
 
 static void blend_tiled_rgb888(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_24)
+#if defined(QT_QWS_DEPTH_24)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_RGB888)
@@ -5097,7 +5096,7 @@ static void blend_tiled_rgb888(int count, const QSpan *spans, void *userData)
 
 static void blend_tiled_argb6666(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+#if defined(QT_QWS_DEPTH_18)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
@@ -5112,7 +5111,7 @@ static void blend_tiled_argb6666(int count, const QSpan *spans, void *userData)
 
 static void blend_tiled_rgb666(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+#if defined(QT_QWS_DEPTH_18)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
@@ -5127,7 +5126,7 @@ static void blend_tiled_rgb666(int count, const QSpan *spans, void *userData)
 
 static void blend_tiled_argb8565(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+#if defined(QT_QWS_DEPTH_16)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
@@ -5142,7 +5141,7 @@ static void blend_tiled_argb8565(int count, const QSpan *spans, void *userData)
 
 static void blend_tiled_rgb565(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+#if defined(QT_QWS_DEPTH_16)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
@@ -5157,7 +5156,7 @@ static void blend_tiled_rgb565(int count, const QSpan *spans, void *userData)
 
 static void blend_tiled_argb8555(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+#if defined(QT_QWS_DEPTH_15)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
@@ -5172,7 +5171,7 @@ static void blend_tiled_argb8555(int count, const QSpan *spans, void *userData)
 
 static void blend_tiled_rgb555(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+#if defined(QT_QWS_DEPTH_15)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
@@ -5187,7 +5186,7 @@ static void blend_tiled_rgb555(int count, const QSpan *spans, void *userData)
 
 static void blend_tiled_argb4444(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+#if defined(QT_QWS_DEPTH_12)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
@@ -5202,7 +5201,7 @@ static void blend_tiled_argb4444(int count, const QSpan *spans, void *userData)
 
 static void blend_tiled_rgb444(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+#if defined(QT_QWS_DEPTH_12)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
@@ -5599,7 +5598,7 @@ Q_STATIC_TEMPLATE_FUNCTION void blendTransformedBilinear(int count, const QSpan
 
 static void blend_transformed_bilinear_rgb888(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_24)
+#if defined(QT_QWS_DEPTH_24)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_RGB888)
@@ -5612,7 +5611,7 @@ static void blend_transformed_bilinear_rgb888(int count, const QSpan *spans, voi
 
 static void blend_transformed_bilinear_argb6666(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+#if defined(QT_QWS_DEPTH_18)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
@@ -5627,7 +5626,7 @@ static void blend_transformed_bilinear_argb6666(int count, const QSpan *spans, v
 
 static void blend_transformed_bilinear_rgb666(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+#if defined(QT_QWS_DEPTH_18)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
@@ -5642,7 +5641,7 @@ static void blend_transformed_bilinear_rgb666(int count, const QSpan *spans, voi
 
 static void blend_transformed_bilinear_argb8565(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+#if defined(QT_QWS_DEPTH_16)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
@@ -5658,7 +5657,7 @@ static void blend_transformed_bilinear_argb8565(int count, const QSpan *spans, v
 static void blend_transformed_bilinear_rgb565(int count, const QSpan *spans,
                                               void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+#if defined(QT_QWS_DEPTH_16)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_RGB16)
@@ -5673,7 +5672,7 @@ static void blend_transformed_bilinear_rgb565(int count, const QSpan *spans,
 
 static void blend_transformed_bilinear_argb8555(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+#if defined(QT_QWS_DEPTH_15)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
@@ -5688,7 +5687,7 @@ static void blend_transformed_bilinear_argb8555(int count, const QSpan *spans, v
 
 static void blend_transformed_bilinear_rgb555(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+#if defined(QT_QWS_DEPTH_15)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
@@ -5703,7 +5702,7 @@ static void blend_transformed_bilinear_rgb555(int count, const QSpan *spans, voi
 
 static void blend_transformed_bilinear_argb4444(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+#if defined(QT_QWS_DEPTH_12)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
@@ -5718,7 +5717,7 @@ static void blend_transformed_bilinear_argb4444(int count, const QSpan *spans, v
 
 static void blend_transformed_bilinear_rgb444(int count, const QSpan *spans, void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+#if defined(QT_QWS_DEPTH_12)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
@@ -6195,7 +6194,7 @@ Q_STATIC_TEMPLATE_FUNCTION void blendTransformed(int count, const QSpan *spans,
 static void blend_transformed_rgb888(int count, const QSpan *spans,
                                      void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_24)
+#if defined(QT_QWS_DEPTH_24)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_RGB888)
@@ -6209,7 +6208,7 @@ static void blend_transformed_rgb888(int count, const QSpan *spans,
 static void blend_transformed_argb6666(int count, const QSpan *spans,
                                        void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+#if defined(QT_QWS_DEPTH_18)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
@@ -6225,7 +6224,7 @@ static void blend_transformed_argb6666(int count, const QSpan *spans,
 static void blend_transformed_rgb666(int count, const QSpan *spans,
                                        void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+#if defined(QT_QWS_DEPTH_18)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
@@ -6241,7 +6240,7 @@ static void blend_transformed_rgb666(int count, const QSpan *spans,
 static void blend_transformed_argb8565(int count, const QSpan *spans,
                                          void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+#if defined(QT_QWS_DEPTH_16)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
@@ -6257,7 +6256,7 @@ static void blend_transformed_argb8565(int count, const QSpan *spans,
 static void blend_transformed_rgb565(int count, const QSpan *spans,
                                        void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+#if defined(QT_QWS_DEPTH_16)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
@@ -6273,7 +6272,7 @@ static void blend_transformed_rgb565(int count, const QSpan *spans,
 static void blend_transformed_argb8555(int count, const QSpan *spans,
                                          void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+#if defined(QT_QWS_DEPTH_15)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
@@ -6289,7 +6288,7 @@ static void blend_transformed_argb8555(int count, const QSpan *spans,
 static void blend_transformed_rgb555(int count, const QSpan *spans,
                                        void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+#if defined(QT_QWS_DEPTH_15)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
@@ -6305,7 +6304,7 @@ static void blend_transformed_rgb555(int count, const QSpan *spans,
 static void blend_transformed_argb4444(int count, const QSpan *spans,
                                          void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+#if defined(QT_QWS_DEPTH_12)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
@@ -6321,7 +6320,7 @@ static void blend_transformed_argb4444(int count, const QSpan *spans,
 static void blend_transformed_rgb444(int count, const QSpan *spans,
                                        void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+#if defined(QT_QWS_DEPTH_12)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
@@ -6619,7 +6618,7 @@ Q_STATIC_TEMPLATE_FUNCTION void blendTransformedTiled(int count, const QSpan *sp
 static void blend_transformed_tiled_rgb888(int count, const QSpan *spans,
                                            void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_24)
+#if defined(QT_QWS_DEPTH_24)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_RGB888)
@@ -6633,7 +6632,7 @@ static void blend_transformed_tiled_rgb888(int count, const QSpan *spans,
 static void blend_transformed_tiled_argb6666(int count, const QSpan *spans,
                                              void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+#if defined(QT_QWS_DEPTH_18)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
@@ -6649,7 +6648,7 @@ static void blend_transformed_tiled_argb6666(int count, const QSpan *spans,
 static void blend_transformed_tiled_rgb666(int count, const QSpan *spans,
                                            void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+#if defined(QT_QWS_DEPTH_18)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
@@ -6665,7 +6664,7 @@ static void blend_transformed_tiled_rgb666(int count, const QSpan *spans,
 static void blend_transformed_tiled_argb8565(int count, const QSpan *spans,
                                              void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+#if defined(QT_QWS_DEPTH_16)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
@@ -6681,7 +6680,7 @@ static void blend_transformed_tiled_argb8565(int count, const QSpan *spans,
 static void blend_transformed_tiled_rgb565(int count, const QSpan *spans,
                                            void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+#if defined(QT_QWS_DEPTH_16)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
@@ -6697,7 +6696,7 @@ static void blend_transformed_tiled_rgb565(int count, const QSpan *spans,
 static void blend_transformed_tiled_argb8555(int count, const QSpan *spans,
                                              void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+#if defined(QT_QWS_DEPTH_15)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
@@ -6713,7 +6712,7 @@ static void blend_transformed_tiled_argb8555(int count, const QSpan *spans,
 static void blend_transformed_tiled_rgb555(int count, const QSpan *spans,
                                            void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+#if defined(QT_QWS_DEPTH_15)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
@@ -6729,7 +6728,7 @@ static void blend_transformed_tiled_rgb555(int count, const QSpan *spans,
 static void blend_transformed_tiled_argb4444(int count, const QSpan *spans,
                                              void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+#if defined(QT_QWS_DEPTH_12)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
@@ -6745,7 +6744,7 @@ static void blend_transformed_tiled_argb4444(int count, const QSpan *spans,
 static void blend_transformed_tiled_rgb444(int count, const QSpan *spans,
                                            void *userData)
 {
-#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+#if defined(QT_QWS_DEPTH_12)
     QSpanData *data = reinterpret_cast<QSpanData *>(userData);
 
     if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
diff --git a/src/gui/painting/qemulationpaintengine.cpp b/src/gui/painting/qemulationpaintengine.cpp
index 3397c45..175f1ab 100644
--- a/src/gui/painting/qemulationpaintengine.cpp
+++ b/src/gui/painting/qemulationpaintengine.cpp
@@ -123,14 +123,30 @@ void QEmulationPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
         real_engine->stroke(path, bgPen);
     }
 
-
     QBrush brush = pen.brush();
+    QPen copy = pen;
     Qt::BrushStyle style = qbrush_style(brush);
     if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) {
         const QGradient *g = brush.gradient();
+
         if (g->coordinateMode() > QGradient::LogicalMode) {
-            QPaintEngineEx::stroke(path, pen);
-            return;
+            if (g->coordinateMode() == QGradient::StretchToDeviceMode) {
+                QTransform mat = brush.transform();
+                mat.scale(real_engine->painter()->device()->width(), real_engine->painter()->device()->height());
+                brush.setTransform(mat);
+                copy.setBrush(brush);
+                real_engine->stroke(path, copy);
+                return;
+            } else if (g->coordinateMode() == QGradient::ObjectBoundingMode) {
+                QTransform mat = brush.transform();
+                QRealRect r = path.controlPointRect();
+                mat.translate(r.x1, r.y1);
+                mat.scale(r.x2 - r.x1, r.y2 - r.y1);
+                brush.setTransform(mat);
+                copy.setBrush(brush);
+                real_engine->stroke(path, copy);
+                return;
+            }
         }
     }
 
diff --git a/src/gui/painting/qmemrotate.cpp b/src/gui/painting/qmemrotate.cpp
index 7ad0e42..471f544 100644
--- a/src/gui/painting/qmemrotate.cpp
+++ b/src/gui/painting/qmemrotate.cpp
@@ -528,6 +528,26 @@ void qt_memrotate270(const srctype *src, int w, int h, int sstride, \
     qt_memrotate270_template(src, w, h, sstride, dest, dstride);    \
 }
 
+#define QT_IMPL_SIMPLE_MEMROTATE(srctype, desttype)                 \
+void qt_memrotate90(const srctype *src, int w, int h, int sstride,  \
+                    desttype *dest, int dstride)                    \
+{                                                                   \
+    qt_memrotate90_tiled_unpacked<desttype,srctype>(src, w, h, sstride, dest, dstride); \
+}                                                                   \
+void qt_memrotate180(const srctype *src, int w, int h, int sstride, \
+                     desttype *dest, int dstride)                   \
+{                                                                   \
+    qt_memrotate180_template(src, w, h, sstride, dest, dstride);    \
+}                                                                   \
+void qt_memrotate270(const srctype *src, int w, int h, int sstride, \
+                     desttype *dest, int dstride)                   \
+{                                                                   \
+    qt_memrotate270_tiled_unpacked<desttype,srctype>(src, w, h, sstride, dest, dstride); \
+}
+
+
+
+
 QT_IMPL_MEMROTATE(quint32, quint32)
 QT_IMPL_MEMROTATE(quint32, quint16)
 QT_IMPL_MEMROTATE(quint16, quint32)
@@ -537,7 +557,16 @@ QT_IMPL_MEMROTATE(quint32, quint24)
 QT_IMPL_MEMROTATE(quint32, quint18)
 QT_IMPL_MEMROTATE(quint32, quint8)
 QT_IMPL_MEMROTATE(quint16, quint8)
+QT_IMPL_MEMROTATE(qrgb444, quint8)
 QT_IMPL_MEMROTATE(quint8, quint8)
+
+#if defined(QT_QWS_ROTATE_BGR)
+QT_IMPL_SIMPLE_MEMROTATE(quint16, qbgr565)
+QT_IMPL_SIMPLE_MEMROTATE(quint32, qbgr565)
+QT_IMPL_SIMPLE_MEMROTATE(qrgb555, qbgr555)
+QT_IMPL_SIMPLE_MEMROTATE(quint32, qbgr555)
+#endif
+
 #ifdef QT_QWS_DEPTH_GENERIC
 QT_IMPL_MEMROTATE(quint32, qrgb_generic16)
 QT_IMPL_MEMROTATE(quint16, qrgb_generic16)
diff --git a/src/gui/painting/qmemrotate_p.h b/src/gui/painting/qmemrotate_p.h
index bd6006b..87cfb1a 100644
--- a/src/gui/painting/qmemrotate_p.h
+++ b/src/gui/painting/qmemrotate_p.h
@@ -90,7 +90,16 @@ QT_DECL_MEMROTATE(quint32, quint24);
 QT_DECL_MEMROTATE(quint32, quint18);
 QT_DECL_MEMROTATE(quint32, quint8);
 QT_DECL_MEMROTATE(quint16, quint8);
+QT_DECL_MEMROTATE(qrgb444, quint8);
 QT_DECL_MEMROTATE(quint8, quint8);
+
+#ifdef QT_QWS_ROTATE_BGR
+QT_DECL_MEMROTATE(quint16, qbgr565);
+QT_DECL_MEMROTATE(quint32, qbgr565);
+QT_DECL_MEMROTATE(qrgb555, qbgr555);
+QT_DECL_MEMROTATE(quint32, qbgr555);
+#endif
+
 #ifdef QT_QWS_DEPTH_GENERIC
 QT_DECL_MEMROTATE(quint32, qrgb_generic16);
 QT_DECL_MEMROTATE(quint16, qrgb_generic16);
diff --git a/src/gui/painting/qpaintdevice_qws.cpp b/src/gui/painting/qpaintdevice_qws.cpp
index 6a68d28..c67be86 100644
--- a/src/gui/painting/qpaintdevice_qws.cpp
+++ b/src/gui/painting/qpaintdevice_qws.cpp
@@ -81,9 +81,6 @@ int QPaintDevice::metric(PaintDeviceMetric m) const
     }
 }
 
-/*!
-    \internal
-*/
 QWSDisplay *QPaintDevice::qwsDisplay()
 {
     return qt_fbdpy;
diff --git a/src/gui/painting/qpaintdevice_win.cpp b/src/gui/painting/qpaintdevice_win.cpp
index 6cae744..7cd3392 100644
--- a/src/gui/painting/qpaintdevice_win.cpp
+++ b/src/gui/painting/qpaintdevice_win.cpp
@@ -71,16 +71,11 @@ int QPaintDevice::metric(PaintDeviceMetric) const
     return 0;
 }
 
-
-/*! \internal
-*/
 HDC QPaintDevice::getDC() const
 {
     return 0;
 }
 
-/*! \internal
-*/
 void QPaintDevice::releaseDC(HDC) const
 {
 }
diff --git a/src/gui/painting/qpaintdevice_x11.cpp b/src/gui/painting/qpaintdevice_x11.cpp
index 4ea9f57..95cb115 100644
--- a/src/gui/painting/qpaintdevice_x11.cpp
+++ b/src/gui/painting/qpaintdevice_x11.cpp
@@ -106,33 +106,11 @@ int QPaintDevice::metric(PaintDeviceMetric) const
 
 #ifdef QT3_SUPPORT
 
-/*!
-    Use QX11Info::display() instead.
-
-    \oldcode
-        Display *display = widget->x11Display();
-    \newcode
-        Display *display = QX11Info::display();
-    \endcode
-
-    \sa QWidget::x11Info(), QX11Info::display()
-*/
 Display *QPaintDevice::x11Display() const
 {
     return X11->display;
 }
 
-/*!
-    Use QX11Info::screen() instead.
-
-    \oldcode
-        int screen = widget->x11Screen();
-    \newcode
-        int screen = widget->x11Info().screen();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 int QPaintDevice::x11Screen() const
 {
     const QX11Info *info = qt_x11Info(this);
@@ -141,17 +119,6 @@ int QPaintDevice::x11Screen() const
     return QX11Info::appScreen();
 }
 
-/*!
-    Use QX11Info::visual() instead.
-
-    \oldcode
-        void *visual = widget->x11Visual();
-    \newcode
-        void *visual = widget->x11Info().visual();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 void *QPaintDevice::x11Visual() const
 {
     const QX11Info *info = qt_x11Info(this);
@@ -160,17 +127,6 @@ void *QPaintDevice::x11Visual() const
     return QX11Info::appVisual();
 }
 
-/*!
-    Use QX11Info::depth() instead.
-
-    \oldcode
-        int depth = widget->x11Depth();
-    \newcode
-        int depth = widget->x11Info().depth();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 int QPaintDevice::x11Depth() const
 {
     const QX11Info *info = qt_x11Info(this);
@@ -179,17 +135,6 @@ int QPaintDevice::x11Depth() const
     return QX11Info::appDepth();
 }
 
-/*!
-    Use QX11Info::cells() instead.
-
-    \oldcode
-        int cells = widget->x11Cells();
-    \newcode
-        int cells = widget->x11Info().cells();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 int QPaintDevice::x11Cells() const
 {
     const QX11Info *info = qt_x11Info(this);
@@ -198,17 +143,6 @@ int QPaintDevice::x11Cells() const
     return QX11Info::appCells();
 }
 
-/*!
-    Use QX11Info::colormap() instead.
-
-    \oldcode
-        unsigned long screen = widget->x11Colormap();
-    \newcode
-        unsigned long screen = widget->x11Info().colormap();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 Qt::HANDLE QPaintDevice::x11Colormap() const
 {
     const QX11Info *info = qt_x11Info(this);
@@ -217,17 +151,6 @@ Qt::HANDLE QPaintDevice::x11Colormap() const
     return QX11Info::appColormap();
 }
 
-/*!
-    Use QX11Info::defaultColormap() instead.
-
-    \oldcode
-        bool isDefault = widget->x11DefaultColormap();
-    \newcode
-        bool isDefault = widget->x11Info().defaultColormap();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 bool QPaintDevice::x11DefaultColormap() const
 {
     const QX11Info *info = qt_x11Info(this);
@@ -236,17 +159,6 @@ bool QPaintDevice::x11DefaultColormap() const
     return QX11Info::appDefaultColormap();
 }
 
-/*!
-    Use QX11Info::defaultVisual() instead.
-
-    \oldcode
-        bool isDefault = widget->x11DefaultVisual();
-    \newcode
-        bool isDefault = widget->x11Info().defaultVisual();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 bool QPaintDevice::x11DefaultVisual() const
 {
     const QX11Info *info = qt_x11Info(this);
@@ -255,176 +167,48 @@ bool QPaintDevice::x11DefaultVisual() const
     return QX11Info::appDefaultVisual();
 }
 
-/*!
-    Use QX11Info::visual() instead.
-
-    \oldcode
-        void *visual = QPaintDevice::x11AppVisual(screen);
-    \newcode
-        void *visual = qApp->x11Info(screen).visual();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 void *QPaintDevice::x11AppVisual(int screen)
 { return QX11Info::appVisual(screen); }
 
-/*!
-    Use QX11Info::colormap() instead.
-
-    \oldcode
-        unsigned long colormap = QPaintDevice::x11AppColormap(screen);
-    \newcode
-        unsigned long colormap = qApp->x11Info(screen).colormap();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 Qt::HANDLE QPaintDevice::x11AppColormap(int screen)
 { return QX11Info::appColormap(screen); }
 
-/*!
-    Use QX11Info::display() instead.
-
-    \oldcode
-        Display *display = QPaintDevice::x11AppDisplay();
-    \newcode
-        Display *display = qApp->x11Info().display();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 Display *QPaintDevice::x11AppDisplay()
 { return QX11Info::display(); }
 
-/*!
-    Use QX11Info::screen() instead.
-
-    \oldcode
-        int screen = QPaintDevice::x11AppScreen();
-    \newcode
-        int screen = qApp->x11Info().screen();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 int QPaintDevice::x11AppScreen()
 { return QX11Info::appScreen(); }
 
-/*!
-    Use QX11Info::depth() instead.
-
-    \oldcode
-        int depth = QPaintDevice::x11AppDepth(screen);
-    \newcode
-        int depth = qApp->x11Info(screen).depth();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 int QPaintDevice::x11AppDepth(int screen)
 { return QX11Info::appDepth(screen); }
 
-/*!
-    Use QX11Info::cells() instead.
-
-    \oldcode
-        int cells = QPaintDevice::x11AppCells(screen);
-    \newcode
-        int cells = qApp->x11Info(screen).cells();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 int QPaintDevice::x11AppCells(int screen)
 { return QX11Info::appCells(screen); }
 
-/*!
-    Use QX11Info::appRootWindow() instead.
-
-    \oldcode
-        unsigned long window = QPaintDevice::x11AppRootWindow(screen);
-    \newcode
-        unsigned long window = qApp->x11Info(screen).appRootWindow();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 Qt::HANDLE QPaintDevice::x11AppRootWindow(int screen)
 { return QX11Info::appRootWindow(screen); }
 
-/*!
-    Use QX11Info::defaultColormap() instead.
-
-    \oldcode
-        bool isDefault = QPaintDevice::x11AppDefaultColormap(screen);
-    \newcode
-        bool isDefault = qApp->x11Info(screen).defaultColormap();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 bool QPaintDevice::x11AppDefaultColormap(int screen)
 { return QX11Info::appDefaultColormap(screen); }
 
-/*!
-    Use QX11Info::defaultVisual() instead.
-
-    \oldcode
-        bool isDefault = QPaintDevice::x11AppDefaultVisual(screen);
-    \newcode
-        bool isDefault = qApp->x11Info(screen).defaultVisual();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 bool QPaintDevice::x11AppDefaultVisual(int screen)
 { return QX11Info::appDefaultVisual(screen); }
 
-/*!
-    Use QX11Info::setAppDpiX() instead.
-*/
 void QPaintDevice::x11SetAppDpiX(int dpi, int screen)
 {
     QX11Info::setAppDpiX(dpi, screen);
 }
 
-/*!
-    Use QX11Info::setAppDpiY() instead.
-*/
 void QPaintDevice::x11SetAppDpiY(int dpi, int screen)
 {
     QX11Info::setAppDpiY(dpi, screen);
 }
 
-
-/*!
-    Use QX11Info::appDpiX() instead.
-
-    \oldcode
-        bool isDefault = QPaintDevice::x11AppDpiX(screen);
-    \newcode
-        bool isDefault = qApp->x11Info(screen).appDpiX();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 int QPaintDevice::x11AppDpiX(int screen)
 {
     return QX11Info::appDpiX(screen);
 }
 
-/*!
-    Use QX11Info::appDpiY() instead.
-
-    \oldcode
-        bool isDefault = QPaintDevice::x11AppDpiY(screen);
-    \newcode
-        bool isDefault = qApp->x11Info(screen).appDpiY();
-    \endcode
-
-    \sa QWidget::x11Info(), QPixmap::x11Info()
-*/
 int QPaintDevice::x11AppDpiY(int screen)
 {
     return QX11Info::appDpiY(screen);
diff --git a/src/gui/painting/qpaintengine.cpp b/src/gui/painting/qpaintengine.cpp
index ad09060..7de1ec4 100644
--- a/src/gui/painting/qpaintengine.cpp
+++ b/src/gui/painting/qpaintengine.cpp
@@ -949,8 +949,8 @@ void QPaintEngine::setSystemClip(const QRegion &region)
     Q_D(QPaintEngine);
     d->systemClip = region;
     // Be backward compatible and only call d->systemStateChanged()
-    // if we currently have a system transform set.
-    if (d->hasSystemTransform) {
+    // if we currently have a system transform/viewport set.
+    if (d->hasSystemTransform || d->hasSystemViewport) {
         d->transformSystemClip();
         d->systemStateChanged();
     }
diff --git a/src/gui/painting/qpaintengine_mac.cpp b/src/gui/painting/qpaintengine_mac.cpp
index 0644a02..5889388 100644
--- a/src/gui/painting/qpaintengine_mac.cpp
+++ b/src/gui/painting/qpaintengine_mac.cpp
@@ -996,15 +996,14 @@ void QCoreGraphicsPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, co
     } else if (differentSize) {
 #if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
         if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
-            CGImageRef img = (CGImageRef)pm.macCGHandle();
+            QCFType<CGImageRef> img = pm.toMacCGImageRef();
             image = CGImageCreateWithImageInRect(img, CGRectMake(qRound(sr.x()), qRound(sr.y()), qRound(sr.width()), qRound(sr.height())));
-            CGImageRelease(img);
         } else
 #endif
         {
             const int sx = qRound(sr.x()), sy = qRound(sr.y()), sw = qRound(sr.width()), sh = qRound(sr.height());
             const QMacPixmapData *pmData = static_cast<const QMacPixmapData*>(pm.data);
-            quint32 *pantherData = pmData->pixels + (sy * pm.width() + sx);
+            quint32 *pantherData = pmData->pixels + sy * (pmData->bytesPerRow / 4) + sx;
             QCFType<CGDataProviderRef> provider = CGDataProviderCreateWithData(0, pantherData, sw*sh*pmData->bytesPerRow, 0);
             image = CGImageCreate(sw, sh, 8, 32, pmData->bytesPerRow,
                                   macGenericColorSpace(),
diff --git a/src/gui/painting/qpaintengine_p.h b/src/gui/painting/qpaintengine_p.h
index eeba7ec..0b5e175 100644
--- a/src/gui/painting/qpaintengine_p.h
+++ b/src/gui/painting/qpaintengine_p.h
@@ -83,10 +83,12 @@ public:
         if (systemClip.isEmpty())
             return;
 
-        if (systemTransform.type() <= QTransform::TxTranslate)
-            systemClip.translate(qRound(systemTransform.dx()), qRound(systemTransform.dy()));
-        else
-            systemClip = systemTransform.map(systemClip);
+        if (hasSystemTransform) {
+            if (systemTransform.type() <= QTransform::TxTranslate)
+                systemClip.translate(qRound(systemTransform.dx()), qRound(systemTransform.dy()));
+            else
+                systemClip = systemTransform.map(systemClip);
+        }
 
         // Make sure we're inside the viewport.
         if (hasSystemViewport) {
@@ -101,7 +103,7 @@ public:
     inline void setSystemTransform(const QTransform &xform)
     {
         systemTransform = xform;
-        if ((hasSystemTransform = !xform.isIdentity()))
+        if ((hasSystemTransform = !xform.isIdentity()) || hasSystemViewport)
             transformSystemClip();
         systemStateChanged();
     }
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index addd63d..847904b 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -1022,7 +1022,7 @@ void QRasterPaintEnginePrivate::drawImage(const QPointF &pt,
                                           int alpha,
                                           const QRect &sr)
 {
-    if (!clip.isValid())
+    if (alpha == 0 || !clip.isValid())
         return;
     Q_ASSERT(img.depth() >= 8);
 
@@ -1140,6 +1140,33 @@ void QRasterPaintEnginePrivate::updateMatrixData(QSpanData *spanData, const QBru
     }
 }
 
+// #define QT_CLIPPING_RATIOS
+
+#ifdef QT_CLIPPING_RATIOS
+int rectClips;
+int regionClips;
+int totalClips;
+
+static void checkClipRatios(QRasterPaintEnginePrivate *d)
+{
+    if (d->clip()->hasRectClip)
+        rectClips++;
+    if (d->clip()->hasRegionClip)
+        regionClips++;
+    totalClips++;
+
+    if ((totalClips % 5000) == 0) {
+        printf("Clipping ratio: rectangular=%f%%, region=%f%%, complex=%f%%\n",
+               rectClips * 100.0 / (qreal) totalClips,
+               regionClips * 100.0 / (qreal) totalClips,
+               (totalClips - rectClips - regionClips) * 100.0 / (qreal) totalClips);
+        totalClips = 0;
+        rectClips = 0;
+        regionClips = 0;
+    }
+
+}
+#endif
 
 /*!
     \internal
@@ -1241,6 +1268,10 @@ void QRasterPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
 
     d->solid_color_filler.clip = d->clip();
     d->solid_color_filler.adjustSpanMethods();
+
+#ifdef QT_CLIPPING_RATIOS
+    checkClipRatios(d);
+#endif
 }
 
 
@@ -1315,6 +1346,11 @@ void QRasterPaintEngine::clip(const QRect &rect, Qt::ClipOperation op)
 
     d->solid_color_filler.clip = d->clip();
     d->solid_color_filler.adjustSpanMethods();
+
+
+#ifdef QT_CLIPPING_RATIOS
+    checkClipRatios(d);
+#endif
 }
 
 /*!
@@ -2537,7 +2573,12 @@ 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)) {
+        // as fillRect will apply the aliased coordinate delta we need to
+        // subtract it here as we don't use it for image drawing
+        QTransform old = s->matrix;
+        s->matrix = s->matrix * QTransform::fromTranslate(-aliasedCoordinateDelta, -aliasedCoordinateDelta);
         fillRect(r, QColor::fromRgba(img.pixel(sr.x(), sr.y())));
+        s->matrix = old;
         return;
     }
 
@@ -2571,6 +2612,18 @@ void QRasterPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRe
             return;
         d->image_filler_xform.setupMatrix(copy, s->flags.bilinear);
 
+        if (!aa && s->matrix.type() == QTransform::TxScale) {
+            QRectF rr = s->matrix.mapRect(r);
+
+            const int x1 = qRound(rr.x());
+            const int y1 = qRound(rr.y());
+            const int x2 = qRound(rr.right());
+            const int y2 = qRound(rr.bottom());
+
+            fillRect_normalized(QRect(x1, y1, x2-x1, y2-y1), &d->image_filler_xform, d);
+            return;
+        }
+
 #ifdef QT_FAST_SPANS
         ensureState();
         if (s->flags.tx_noshear || s->matrix.type() == QTransform::TxScale) {
@@ -2628,7 +2681,13 @@ void QRasterPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRe
 
         QRectF rr = r;
         rr.translate(s->matrix.dx(), s->matrix.dy());
-        fillRect_normalized(toRect_normalized(rr), &d->image_filler, d);
+
+        const int x1 = qRound(rr.x());
+        const int y1 = qRound(rr.y());
+        const int x2 = qRound(rr.right());
+        const int y2 = qRound(rr.bottom());
+
+        fillRect_normalized(QRect(x1, y1, x2-x1, y2-y1), &d->image_filler, d);
     }
 }
 
@@ -4369,6 +4428,9 @@ void QClipData::fixup()
  */
 void QClipData::setClipRect(const QRect &rect)
 {
+    if (rect == clipRect)
+        return;
+
 //    qDebug() << "setClipRect" << clipSpanHeight << count << allocated << rect;
     hasRectClip = true;
     clipRect = rect;
@@ -4378,6 +4440,11 @@ void QClipData::setClipRect(const QRect &rect)
     ymin = qMin(rect.y(), clipSpanHeight);
     ymax = qMin(rect.y() + rect.height(), clipSpanHeight);
 
+    if (m_spans) {
+        delete m_spans;
+        m_spans = 0;
+    }
+
 //    qDebug() << xmin << xmax << ymin << ymax;
 }
 
@@ -4401,6 +4468,12 @@ void QClipData::setClipRegion(const QRegion &region)
         ymin = rect.y();
         ymax = rect.y() + rect.height();
     }
+
+    if (m_spans) {
+        delete m_spans;
+        m_spans = 0;
+    }
+
 }
 
 /*!
@@ -5097,7 +5170,11 @@ void QSpanData::adjustSpanMethods()
 
 void QSpanData::setupMatrix(const QTransform &matrix, int bilin)
 {
-    QTransform inv = matrix.inverted();
+    QTransform delta;
+    // make sure we round off correctly in qdrawhelper.cpp
+    delta.translate(1.0 / 65536, 1.0 / 65536);
+
+    QTransform inv = (delta * matrix).inverted();
     m11 = inv.m11();
     m12 = inv.m12();
     m13 = inv.m13();
diff --git a/src/gui/painting/qpaintengine_x11.cpp b/src/gui/painting/qpaintengine_x11.cpp
index 39ce59f..9cc9683 100644
--- a/src/gui/painting/qpaintengine_x11.cpp
+++ b/src/gui/painting/qpaintengine_x11.cpp
@@ -1543,6 +1543,8 @@ void QX11PaintEnginePrivate::fillPolygon_dev(const QPointF *polygonPoints, int p
                                              QX11PaintEnginePrivate::GCMode gcMode,
                                              QPaintEngine::PolygonDrawMode mode)
 {
+    Q_Q(QX11PaintEngine);
+
     int clippedCount = 0;
     qt_float_point *clippedPoints = 0;
 
@@ -1617,7 +1619,29 @@ void QX11PaintEnginePrivate::fillPolygon_dev(const QPointF *polygonPoints, int p
     } else
 #endif
         if (fill.style() != Qt::NoBrush) {
-            if (clippedCount > 0) {
+            if (clippedCount > 200000) {
+                QPolygon poly;
+                for (int i = 0; i < clippedCount; ++i)
+                    poly << QPoint(qFloor(clippedPoints[i].x), qFloor(clippedPoints[i].y));
+
+                const QRect bounds = poly.boundingRect();
+                const QRect aligned = bounds
+                    & QRect(QPoint(), QSize(pdev->width(), pdev->height()));
+
+                QImage img(aligned.size(), QImage::Format_ARGB32_Premultiplied);
+                img.fill(0);
+
+                QPainter painter(&img);
+                painter.translate(-aligned.x(), -aligned.y());
+                painter.setPen(Qt::NoPen);
+                painter.setBrush(fill);
+                if (gcMode == BrushGC)
+                    painter.setBrushOrigin(q->painter()->brushOrigin());
+                painter.drawPolygon(poly);
+                painter.end();
+
+                q->drawImage(aligned, img, img.rect(), Qt::AutoColor);
+            } else if (clippedCount > 0) {
                 QVarLengthArray<XPoint> xpoints(clippedCount);
                 for (int i = 0; i < clippedCount; ++i) {
                     xpoints[i].x = qFloor(clippedPoints[i].x);
@@ -2352,7 +2376,9 @@ void QX11PaintEngine::drawFreetype(const QPointF &p, const QTextItemInt &ti)
         GlyphSet glyphSet = set->id;
         const QColor &pen = d->cpen.color();
         ::Picture src = X11->getSolidFill(d->scrn, pen);
-        XRenderPictFormat *maskFormat = XRenderFindStandardFormat(X11->display, ft->xglyph_format);
+        XRenderPictFormat *maskFormat = 0;
+        if (ft->xglyph_format != PictStandardA1)
+            maskFormat = XRenderFindStandardFormat(X11->display, ft->xglyph_format);
 
         enum { t_min = SHRT_MIN, t_max = SHRT_MAX };
 
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index 2fa6a56..cc48d24 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -1484,7 +1484,9 @@ void QPainter::initFrom(const QWidget *widget)
     d->state->bgBrush = pal.brush(widget->backgroundRole());
     d->state->deviceFont = QFont(widget->font(), const_cast<QWidget*> (widget));
     d->state->font = d->state->deviceFont;
-    if (d->engine) {
+    if (d->extended) {
+        d->extended->penChanged();
+    } else if (d->engine) {
         d->engine->setDirty(QPaintEngine::DirtyPen);
         d->engine->setDirty(QPaintEngine::DirtyBrush);
         d->engine->setDirty(QPaintEngine::DirtyFont);
@@ -2396,7 +2398,6 @@ QRegion QPainter::clipRegion() const
     // ### Falcon: Use QPainterPath
     for (int i=0; i<d->state->clipInfo.size(); ++i) {
         const QPainterClipInfo &info = d->state->clipInfo.at(i);
-        QRegion other;
         switch (info.clipType) {
 
         case QPainterClipInfo::RegionClip: {
@@ -2449,15 +2450,20 @@ QRegion QPainter::clipRegion() const
                 lastWasNothing = false;
                 continue;
             }
-            if (info.operation == Qt::IntersectClip)
-                region &= QRegion(info.rect) * matrix;
-            else if (info.operation == Qt::UniteClip)
+            if (info.operation == Qt::IntersectClip) {
+                // Use rect intersection if possible.
+                if (matrix.type() <= QTransform::TxScale)
+                    region &= matrix.mapRect(info.rect);
+                else
+                    region &= matrix.map(QRegion(info.rect));
+            } else if (info.operation == Qt::UniteClip) {
                 region |= QRegion(info.rect) * matrix;
-            else if (info.operation == Qt::NoClip) {
+            } else if (info.operation == Qt::NoClip) {
                 lastWasNothing = true;
                 region = QRegion();
-            } else
+            } else {
                 region = QRegion(info.rect) * matrix;
+            }
             break;
         }
 
@@ -2468,15 +2474,20 @@ QRegion QPainter::clipRegion() const
                 lastWasNothing = false;
                 continue;
             }
-            if (info.operation == Qt::IntersectClip)
-                region &= QRegion(info.rectf.toRect()) * matrix;
-            else if (info.operation == Qt::UniteClip)
+            if (info.operation == Qt::IntersectClip) {
+                // Use rect intersection if possible.
+                if (matrix.type() <= QTransform::TxScale)
+                    region &= matrix.mapRect(info.rectf.toRect());
+                else
+                    region &= matrix.map(QRegion(info.rectf.toRect()));
+            } else if (info.operation == Qt::UniteClip) {
                 region |= QRegion(info.rectf.toRect()) * matrix;
-            else if (info.operation == Qt::NoClip) {
+            } else if (info.operation == Qt::NoClip) {
                 lastWasNothing = true;
                 region = QRegion();
-            } else
+            } else {
                 region = QRegion(info.rectf.toRect()) * matrix;
+            }
             break;
         }
         }
@@ -5131,6 +5142,11 @@ void QPainter::drawConvexPolygon(const QPointF *points, int pointCount)
     d->engine->drawPolygon(points, pointCount, QPaintEngine::ConvexMode);
 }
 
+static inline QPointF roundInDeviceCoordinates(const QPointF &p, const QTransform &m)
+{
+    return m.inverted().map(QPointF(m.map(p).toPoint()));
+}
+
 /*!
     \fn void QPainter::drawPixmap(const QRectF &target, const QPixmap &pixmap, const QRectF &source)
 
@@ -5165,6 +5181,9 @@ void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm)
 
     Q_D(QPainter);
 
+    if (!d->engine)
+        return;
+
 #ifndef QT_NO_DEBUG
     qt_painter_thread_test(d->device->devType(), "drawPixmap()");
 #endif
@@ -5174,9 +5193,6 @@ void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm)
         return;
     }
 
-    if (!d->engine)
-        return;
-
     qreal x = p.x();
     qreal y = p.y();
 
@@ -5199,11 +5215,12 @@ void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm)
         || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity)))
     {
         save();
-        // If there is no scaling or transformation involved we have to make sure we use the
+        // If there is no rotation involved we have to make sure we use the
         // antialiased and not the aliased coordinate system by rounding the coordinates.
-        if (d->state->matrix.type() <= QTransform::TxTranslate) {
-            x = qRound(x + d->state->matrix.dx()) - d->state->matrix.dx();
-            y = qRound(y + d->state->matrix.dy()) - d->state->matrix.dy();
+        if (d->state->matrix.type() <= QTransform::TxScale) {
+            const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
+            x = p.x();
+            y = p.y();
         }
         translate(x, y);
         setBackgroundMode(Qt::TransparentMode);
@@ -5313,16 +5330,21 @@ void QPainter::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
         || ((sw != w || sh != h) && !d->engine->hasFeature(QPaintEngine::PixmapTransform)))
     {
         save();
-        // If there is no scaling or transformation involved we have to make sure we use the
+        // If there is no rotation involved we have to make sure we use the
         // antialiased and not the aliased coordinate system by rounding the coordinates.
+        if (d->state->matrix.type() <= QTransform::TxScale) {
+            const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
+            x = p.x();
+            y = p.y();
+        }
+
         if (d->state->matrix.type() <= QTransform::TxTranslate && sw == w && sh == h) {
-            x = qRound(x + d->state->matrix.dx()) - d->state->matrix.dx();
-            y = qRound(y + d->state->matrix.dy()) - d->state->matrix.dy();
             sx = qRound(sx);
             sy = qRound(sy);
             sw = qRound(sw);
             sh = qRound(sh);
         }
+
         translate(x, y);
         scale(w / sw, h / sh);
         setBackgroundMode(Qt::TransparentMode);
@@ -5472,11 +5494,12 @@ void QPainter::drawImage(const QPointF &p, const QImage &image)
         || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity)))
     {
         save();
-        // If there is no scaling or transformation involved we have to make sure we use the
+        // If there is no rotation involved we have to make sure we use the
         // antialiased and not the aliased coordinate system by rounding the coordinates.
-        if (d->state->matrix.type() <= QTransform::TxTranslate) {
-            x = qRound(x + d->state->matrix.dx()) - d->state->matrix.dx();
-            y = qRound(y + d->state->matrix.dy()) - d->state->matrix.dy();
+        if (d->state->matrix.type() <= QTransform::TxScale) {
+            const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
+            x = p.x();
+            y = p.y();
         }
         translate(x, y);
         setBackgroundMode(Qt::TransparentMode);
@@ -5575,11 +5598,15 @@ void QPainter::drawImage(const QRectF &targetRect, const QImage &image, const QR
         || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity)))
     {
         save();
-        // If there is no scaling or transformation involved we have to make sure we use the
+        // If there is no rotation involved we have to make sure we use the
         // antialiased and not the aliased coordinate system by rounding the coordinates.
+        if (d->state->matrix.type() <= QTransform::TxScale) {
+            const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
+            x = p.x();
+            y = p.y();
+        }
+
         if (d->state->matrix.type() <= QTransform::TxTranslate && sw == w && sh == h) {
-            x = qRound(x + d->state->matrix.dx()) - d->state->matrix.dx();
-            y = qRound(y + d->state->matrix.dy()) - d->state->matrix.dy();
             sx = qRound(sx);
             sy = qRound(sy);
             sw = qRound(sw);
@@ -6322,17 +6349,18 @@ void QPainter::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPo
         setBrush(QBrush(d->state->pen.color(), pixmap));
         setPen(Qt::NoPen);
 
-        // If there is no scaling or transformation involved we have to make sure we use the
+        // If there is no rotation involved we have to make sure we use the
         // antialiased and not the aliased coordinate system by rounding the coordinates.
-        if (d->state->matrix.type() <= QTransform::TxTranslate) {
-            qreal x = qRound(r.x() + d->state->matrix.dx()) - d->state->matrix.dx();
-            qreal y = qRound(r.y() + d->state->matrix.dy()) - d->state->matrix.dy();
-            qreal w = qRound(r.width());
-            qreal h = qRound(r.height());
-            sx = qRound(sx);
-            sy = qRound(sy);
+        if (d->state->matrix.type() <= QTransform::TxScale) {
+            const QPointF p = roundInDeviceCoordinates(r.topLeft(), d->state->matrix);
+
+            if (d->state->matrix.type() <= QTransform::TxTranslate) {
+                sx = qRound(sx);
+                sy = qRound(sy);
+            }
+
             setBrushOrigin(QPointF(r.x()-sx, r.y()-sy));
-            drawRect(QRectF(x, y, w, h));
+            drawRect(QRectF(p, r.size()));
         } else {
             setBrushOrigin(QPointF(r.x()-sx, r.y()-sy));
             drawRect(r);
@@ -7131,14 +7159,14 @@ QPoint QPainter::xFormDev(const QPoint &p) const
     \fn QRect QPainter::xFormDev(const QRect &rectangle) const
     \overload
 
-    Use  combineMatrix() combined with QMatrix::inverted() instead.
+    Use mapRect() combined with QMatrix::inverted() instead.
 
     \oldcode
         QPainter painter(this);
         QRect transformed = painter.xFormDev(rectangle);
     \newcode
         QPainter painter(this);
-        QRect transformed = rectangle * painter.combinedMatrix().inverted();
+        QRect transformed = painter.combinedMatrix().inverted(rectangle);
     \endcode
 */
 
@@ -8543,4 +8571,252 @@ void qt_draw_helper(QPainterPrivate *p, const QPainterPath &path, QPainterPrivat
     p->draw_helper(path, operation);
 }
 
+/*! \fn Display *QPaintDevice::x11Display() const
+    Use QX11Info::display() instead.
+
+    \oldcode
+        Display *display = widget->x11Display();
+    \newcode
+        Display *display = QX11Info::display();
+    \endcode
+
+    \sa QWidget::x11Info(), QX11Info::display()
+*/
+
+/*! \fn int QPaintDevice::x11Screen() const
+    Use QX11Info::screen() instead.
+
+    \oldcode
+        int screen = widget->x11Screen();
+    \newcode
+        int screen = widget->x11Info().screen();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn void *QPaintDevice::x11Visual() const
+    Use QX11Info::visual() instead.
+
+    \oldcode
+        void *visual = widget->x11Visual();
+    \newcode
+        void *visual = widget->x11Info().visual();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn int QPaintDevice::x11Depth() const
+    Use QX11Info::depth() instead.
+
+    \oldcode
+        int depth = widget->x11Depth();
+    \newcode
+        int depth = widget->x11Info().depth();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn int QPaintDevice::x11Cells() const
+    Use QX11Info::cells() instead.
+
+    \oldcode
+        int cells = widget->x11Cells();
+    \newcode
+        int cells = widget->x11Info().cells();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn Qt::HANDLE QPaintDevice::x11Colormap() const
+    Use QX11Info::colormap() instead.
+
+    \oldcode
+        unsigned long screen = widget->x11Colormap();
+    \newcode
+        unsigned long screen = widget->x11Info().colormap();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn bool QPaintDevice::x11DefaultColormap() const
+    Use QX11Info::defaultColormap() instead.
+
+    \oldcode
+        bool isDefault = widget->x11DefaultColormap();
+    \newcode
+        bool isDefault = widget->x11Info().defaultColormap();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn bool QPaintDevice::x11DefaultVisual() const
+    Use QX11Info::defaultVisual() instead.
+
+    \oldcode
+        bool isDefault = widget->x11DefaultVisual();
+    \newcode
+        bool isDefault = widget->x11Info().defaultVisual();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn void *QPaintDevice::x11AppVisual(int screen)
+    Use QX11Info::visual() instead.
+
+    \oldcode
+        void *visual = QPaintDevice::x11AppVisual(screen);
+    \newcode
+        void *visual = qApp->x11Info(screen).visual();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn Qt::HANDLE QPaintDevice::x11AppColormap(int screen)
+    Use QX11Info::colormap() instead.
+
+    \oldcode
+        unsigned long colormap = QPaintDevice::x11AppColormap(screen);
+    \newcode
+        unsigned long colormap = qApp->x11Info(screen).colormap();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn Display *QPaintDevice::x11AppDisplay()
+    Use QX11Info::display() instead.
+
+    \oldcode
+        Display *display = QPaintDevice::x11AppDisplay();
+    \newcode
+        Display *display = qApp->x11Info().display();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn int QPaintDevice::x11AppScreen()
+    Use QX11Info::screen() instead.
+
+    \oldcode
+        int screen = QPaintDevice::x11AppScreen();
+    \newcode
+        int screen = qApp->x11Info().screen();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn int QPaintDevice::x11AppDepth(int screen)
+    Use QX11Info::depth() instead.
+
+    \oldcode
+        int depth = QPaintDevice::x11AppDepth(screen);
+    \newcode
+        int depth = qApp->x11Info(screen).depth();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn int QPaintDevice::x11AppCells(int screen)
+    Use QX11Info::cells() instead.
+
+    \oldcode
+        int cells = QPaintDevice::x11AppCells(screen);
+    \newcode
+        int cells = qApp->x11Info(screen).cells();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn Qt::HANDLE QPaintDevice::x11AppRootWindow(int screen)
+    Use QX11Info::appRootWindow() instead.
+
+    \oldcode
+        unsigned long window = QPaintDevice::x11AppRootWindow(screen);
+    \newcode
+        unsigned long window = qApp->x11Info(screen).appRootWindow();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn bool QPaintDevice::x11AppDefaultColormap(int screen)
+    Use QX11Info::defaultColormap() instead.
+
+    \oldcode
+        bool isDefault = QPaintDevice::x11AppDefaultColormap(screen);
+    \newcode
+        bool isDefault = qApp->x11Info(screen).defaultColormap();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn bool QPaintDevice::x11AppDefaultVisual(int screen)
+    Use QX11Info::defaultVisual() instead.
+
+    \oldcode
+        bool isDefault = QPaintDevice::x11AppDefaultVisual(screen);
+    \newcode
+        bool isDefault = qApp->x11Info(screen).defaultVisual();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn void QPaintDevice::x11SetAppDpiX(int dpi, int screen)
+    Use QX11Info::setAppDpiX() instead.
+*/
+
+/*! \fn void QPaintDevice::x11SetAppDpiY(int dpi, int screen)
+    Use QX11Info::setAppDpiY() instead.
+*/
+
+/*! \fn int QPaintDevice::x11AppDpiX(int screen)
+    Use QX11Info::appDpiX() instead.
+
+    \oldcode
+        bool isDefault = QPaintDevice::x11AppDpiX(screen);
+    \newcode
+        bool isDefault = qApp->x11Info(screen).appDpiX();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn int QPaintDevice::x11AppDpiY(int screen)
+    Use QX11Info::appDpiY() instead.
+
+    \oldcode
+        bool isDefault = QPaintDevice::x11AppDpiY(screen);
+    \newcode
+        bool isDefault = qApp->x11Info(screen).appDpiY();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn HDC QPaintDevice::getDC() const
+  \internal
+*/
+
+/*! \fn void QPaintDevice::releaseDC(HDC) const
+  \internal
+*/
+
+/*! \fn QWSDisplay *QPaintDevice::qwsDisplay()
+    \internal
+*/
+
 QT_END_NAMESPACE
diff --git a/src/gui/painting/qprintengine_win.cpp b/src/gui/painting/qprintengine_win.cpp
index c8674b7..7601beb 100644
--- a/src/gui/painting/qprintengine_win.cpp
+++ b/src/gui/painting/qprintengine_win.cpp
@@ -1532,7 +1532,7 @@ QVariant QWin32PrintEngine::property(PrintEnginePropertyKey key) const
             value = rect;
         } else {
             value = QTransform(1/d->stretch_x, 0, 0, 1/d->stretch_y, 0, 0)
-                    .mapRect(d->fullPage ? d->devPaperRect : d->devPageRect);
+                    .mapRect(d->fullPage ? d->devPhysicalPageRect : d->devPageRect);
         }
         break;
 
diff --git a/src/gui/painting/qprinter.cpp b/src/gui/painting/qprinter.cpp
index 4f3e71c..5090b3a 100644
--- a/src/gui/painting/qprinter.cpp
+++ b/src/gui/painting/qprinter.cpp
@@ -284,8 +284,8 @@ void QPrinterPrivate::addToManualSetList(QPrintEngine::PrintEnginePropertyKey ke
   to send PostScript or PDF output to the printer. As an alternative,
   the printProgram() function can be used to specify the command or utility
   to use instead of the system default.
-  
-  Note that setting parameters like paper size and resolution on an 
+
+  Note that setting parameters like paper size and resolution on an
   invalid printer is undefined. You can use QPrinter::isValid() to
   verify this before changing any parameters.
 
@@ -744,7 +744,7 @@ void QPrinter::setOutputFormat(OutputFormat format)
 
 #ifndef QT_NO_PDF
     Q_D(QPrinter);
-    if (d->outputFormat == format)
+    if (d->validPrinter && d->outputFormat == format)
         return;
     d->outputFormat = format;
 
@@ -773,8 +773,8 @@ void QPrinter::setOutputFormat(OutputFormat format)
     if (def_engine)
         delete oldPrintEngine;
 
-    d->validPrinter = d->outputFormat == QPrinter::PdfFormat || d->outputFormat == QPrinter::PostScriptFormat;
-
+    if (d->outputFormat == QPrinter::PdfFormat || d->outputFormat == QPrinter::PostScriptFormat)
+        d->validPrinter = true;
 #else
     Q_UNUSED(format);
 #endif
diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp
index 39e429d..2383272 100644
--- a/src/gui/painting/qtransform.cpp
+++ b/src/gui/painting/qtransform.cpp
@@ -1317,12 +1317,16 @@ QRegion QTransform::map(const QRegion &r) const
     TransformationType t = type();
     if (t == TxNone)
         return r;
+
     if (t == TxTranslate) {
         QRegion copy(r);
         copy.translate(qRound(affine._dx), qRound(affine._dy));
         return copy;
     }
 
+    if (t == TxScale && r.numRects() == 1)
+        return QRegion(mapRect(r.boundingRect()));
+
     QPainterPath p = map(qt_regionToPath(r));
     return p.toFillPolygon(QTransform()).toPolygon();
 }
@@ -1880,7 +1884,7 @@ const QMatrix &QTransform::toAffine() const
 QTransform::TransformationType QTransform::type() const
 {
     if (m_dirty >= m_type) {
-        if (m_dirty > TxShear && (!qFuzzyCompare(m_13 + 1, 1) || !qFuzzyCompare(m_23 + 1, 1)))
+        if (m_dirty > TxShear && (!qFuzzyCompare(m_13 + 1, 1) || !qFuzzyCompare(m_23 + 1, 1) || !qFuzzyCompare(m_33, 1)))
              m_type = TxProject;
         else if (m_dirty > TxScale && (!qFuzzyCompare(affine._m12 + 1, 1) || !qFuzzyCompare(affine._m21 + 1, 1))) {
             const qreal dot = affine._m11 * affine._m12 + affine._m21 * affine._m22;
@@ -1888,7 +1892,7 @@ QTransform::TransformationType QTransform::type() const
                 m_type = TxRotate;
             else
                 m_type = TxShear;
-        } else if (m_dirty > TxTranslate && (!qFuzzyCompare(affine._m11, 1) || !qFuzzyCompare(affine._m22, 1) || !qFuzzyCompare(m_33, 1)))
+        } else if (m_dirty > TxTranslate && (!qFuzzyCompare(affine._m11, 1) || !qFuzzyCompare(affine._m22, 1)))
             m_type = TxScale;
         else if (m_dirty > TxNone && (!qFuzzyCompare(affine._dx + 1, 1) || !qFuzzyCompare(affine._dy + 1, 1)))
             m_type = TxTranslate;
diff --git a/src/gui/painting/qwindowsurface_raster.cpp b/src/gui/painting/qwindowsurface_raster.cpp
index 7a74fe0..110ba2f 100644
--- a/src/gui/painting/qwindowsurface_raster.cpp
+++ b/src/gui/painting/qwindowsurface_raster.cpp
@@ -142,8 +142,7 @@ void QRasterWindowSurface::beginPaint(const QRegion &rgn)
             p.fillRect(*it, blank);
         }
     }
-#endif
-#if defined(Q_OS_WINCE)
+#else
     Q_UNUSED(rgn);
 #endif
 }
@@ -250,6 +249,7 @@ void QRasterWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoi
 
 //     d->image->image.save("flush.png");
 
+    Q_UNUSED(offset);
     // Get a context for the widget.
 #ifndef QT_MAC_USE_COCOA
     CGContextRef context;
diff --git a/src/gui/styles/gtksymbols.cpp b/src/gui/styles/gtksymbols.cpp
index acb8437..0842ec7 100644
--- a/src/gui/styles/gtksymbols.cpp
+++ b/src/gui/styles/gtksymbols.cpp
@@ -746,9 +746,9 @@ static void setupGtkFileChooser(GtkWidget* gtkFileChooser, QWidget *parent,
         foreach (const QString &rawfilter, filters) {
             GtkFileFilter *gtkFilter = QGtk::gtk_file_filter_new ();
             QString name = rawfilter.left(rawfilter.indexOf(QLatin1Char('(')));
-            QGtk::gtk_file_filter_set_name(gtkFilter, qPrintable(name));
-
             QStringList extensions = extract_filter(rawfilter);
+            QGtk::gtk_file_filter_set_name(gtkFilter, qPrintable(name.isEmpty() ? extensions.join(QLS(", ")) : name));
+
             foreach (const QString &fileExtension, extensions) {
                 QGtk::gtk_file_filter_add_pattern (gtkFilter, qPrintable(fileExtension));
             }
diff --git a/src/gui/styles/qgtkstyle.cpp b/src/gui/styles/qgtkstyle.cpp
index b7fa575..ca71da2 100644
--- a/src/gui/styles/qgtkstyle.cpp
+++ b/src/gui/styles/qgtkstyle.cpp
@@ -951,14 +951,15 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
                                "interior-focus", &interior_focus,
                                "focus-line-width", &focus_line_width, NULL);
 
+        // See https://bugzilla.mozilla.org/show_bug.cgi?id=405421 for info about this hack
+        g_object_set_data(G_OBJECT(gtkEntry), "transparent-bg-hint", GINT_TO_POINTER(TRUE));
+
         if (!interior_focus && option->state & State_HasFocus)
             rect.adjust(focus_line_width, focus_line_width, -focus_line_width, -focus_line_width);
-
         gtkPainter.paintShadow(gtkEntry, "entry", rect, option->state & State_Enabled ? 
                                GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE, 
                                GTK_SHADOW_IN, gtkEntry->style,
                                option->state & State_HasFocus ? QLS("focus") : QString());
-
         if (!interior_focus && option->state & State_HasFocus)
             gtkPainter.paintShadow(gtkEntry, "entry", option->rect, option->state & State_Enabled ? 
                                    GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE,
diff --git a/src/gui/styles/qmacstyle_mac.mm b/src/gui/styles/qmacstyle_mac.mm
index 398e11d..7a870fe 100644
--- a/src/gui/styles/qmacstyle_mac.mm
+++ b/src/gui/styles/qmacstyle_mac.mm
@@ -549,7 +549,6 @@ extern QPaintDevice *qt_mac_safe_pdev; //qapplication_mac.cpp
   QMacCGStyle globals
  *****************************************************************************/
 const int qt_mac_hitheme_version = 0; //the HITheme version we speak
-const int macSpinBoxSep        = 5;    // distance between spinwidget and the lineedit
 const int macItemFrame         = 2;    // menu item frame width
 const int macItemHMargin       = 3;    // menu item hor text margin
 const int macItemVMargin       = 2;    // menu item ver text margin
@@ -2146,8 +2145,11 @@ void qt_mac_fill_background(QPainter *painter, const QRegion &rgn, const QPoint
 /*! \reimp */
 void QMacStyle::polish(QPalette &pal)
 {
-    if (qt_mac_backgroundPattern == 0)
+    if (!qt_mac_backgroundPattern) {
+        if (!qApp)
+            return;
         qt_mac_backgroundPattern = new QPixmap(d->generateBackgroundPattern());
+    }
 
     QColor pc(Qt::black);
     pc = qcolorForTheme(kThemeBrushDialogBackgroundActive);
@@ -2373,7 +2375,14 @@ int QMacStyle::pixelMetric(PixelMetric metric, const QStyleOption *opt, const QW
         break;
     case PM_SpinBoxFrameWidth:
         GetThemeMetric(kThemeMetricEditTextFrameOutset, &ret);
-        ret += 2;
+        switch (d->aquaSizeConstrain(opt, widget)) {
+        default:
+            ret += 2;
+            break;
+        case QAquaSizeMini:
+            ret += 1;
+            break;
+        }
         break;
     case PM_ButtonShiftHorizontal:
     case PM_ButtonShiftVertical:
@@ -5014,11 +5023,10 @@ void QMacStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex
                         bdi.kind = kThemeIncDecButton;
                         break;
                     case QAquaSizeMini:
+                        bdi.kind = kThemeIncDecButtonMini;
+                        break;
                     case QAquaSizeSmall:
-                        if (aquaSize == QAquaSizeMini)
-                            bdi.kind = kThemeIncDecButtonMini;
-                        else
-                            bdi.kind = kThemeIncDecButtonSmall;
+                        bdi.kind = kThemeIncDecButtonSmall;
                         break;
                 }
                 if (!(sb->stepEnabled & (QAbstractSpinBox::StepUpEnabled
@@ -5038,8 +5046,8 @@ void QMacStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex
                 bdi.value = kThemeButtonOff;
                 bdi.adornment = kThemeAdornmentNone;
 
-                QRect updown = subControlRect(CC_SpinBox, sb, SC_SpinBoxUp,
-                                                 widget);
+                QRect updown = subControlRect(CC_SpinBox, sb, SC_SpinBoxUp, widget);
+
                 updown |= subControlRect(CC_SpinBox, sb, SC_SpinBoxDown, widget);
                 HIRect newRect = qt_hirectForQRect(updown);
                 QRect off_rct;
@@ -5050,15 +5058,6 @@ void QMacStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex
                                 int(outRect.size.width - newRect.size.width),
                                 int(outRect.size.height - newRect.size.height));
 
-                // HIThemeGetButtonBackgroundBounds offsets non-focused normal sized
-                // buttons by one in de y direction, account for that here.
-                if (bdi.adornment == kThemeAdornmentNone && bdi.kind == kThemeIncDecButton)
-                    off_rct.adjust(0, 1, 0, 0);
-
-                // Adjust the rect for small buttos also.
-                if (bdi.adornment == kThemeAdornmentFocus && bdi.kind == kThemeIncDecButtonSmall)
-                    off_rct.adjust(0, 0, 0, -1);
-
                 newRect = qt_hirectForQRect(updown, off_rct);
                 HIThemeDrawButton(&newRect, &bdi, cg, kHIThemeOrientationNormal, 0);
             }
@@ -5723,39 +5722,61 @@ QRect QMacStyle::subControlRect(ComplexControl cc, const QStyleOptionComplex *op
         break;
     case CC_SpinBox:
         if (const QStyleOptionSpinBox *spin = qstyleoption_cast<const QStyleOptionSpinBox *>(opt)) {
-            const int spinner_w = 14,
-                      fw = pixelMetric(PM_SpinBoxFrameWidth, spin, widget);
+            QAquaWidgetSize aquaSize = d->aquaSizeConstrain(spin, widget);
+            int spinner_w;
+            int spinBoxSep;
+            int fw = pixelMetric(PM_SpinBoxFrameWidth, spin, widget);
+            switch (aquaSize) {
+            default:
+            case QAquaSizeUnknown:
+            case QAquaSizeLarge:
+                spinner_w = 14;
+                spinBoxSep = 2;
+                break;
+            case QAquaSizeSmall:
+                spinner_w = 12;
+                spinBoxSep = 2;
+                break;
+            case QAquaSizeMini:
+                spinner_w = 10;
+                spinBoxSep = 1;
+                break;
+            }
+
             switch (sc) {
             case SC_SpinBoxUp:
             case SC_SpinBoxDown: {
                 if (spin->buttonSymbols == QAbstractSpinBox::NoButtons)
                     break;
-                const int frameWidth = pixelMetric(PM_SpinBoxFrameWidth, spin, widget);
-                const int spinner_w = 18;
-                const int y = frameWidth;
-                const int x = spin->rect.width() - spinner_w + frameWidth;
+
+                const int y = fw;
+                const int x = spin->rect.width() - spinner_w;
                 ret.setRect(x + spin->rect.x(), y + spin->rect.y(), spinner_w, spin->rect.height() - y * 2);
                 HIThemeButtonDrawInfo bdi;
                 bdi.version = qt_mac_hitheme_version;
                 bdi.kind = kThemeIncDecButton;
-                QAquaWidgetSize aquaSize = d->aquaSizeConstrain(opt, widget);
+                int hackTranslateX;
                 switch (aquaSize) {
-                    case QAquaSizeUnknown:
-                    case QAquaSizeLarge:
-                        bdi.kind = kThemeIncDecButton;
-                        break;
-                    case QAquaSizeMini:
-                    case QAquaSizeSmall:
-                        if (aquaSize == QAquaSizeMini)
-                            bdi.kind = kThemeIncDecButtonMini;
-                        else
-                            bdi.kind = kThemeIncDecButtonSmall;
-                        break;
+                default:
+                case QAquaSizeUnknown:
+                case QAquaSizeLarge:
+                    bdi.kind = kThemeIncDecButton;
+                    hackTranslateX = 0;
+                    break;
+                case QAquaSizeSmall:
+                    bdi.kind = kThemeIncDecButtonSmall;
+                    hackTranslateX = -2;
+                    break;
+                case QAquaSizeMini:
+                    bdi.kind = kThemeIncDecButtonMini;
+                    hackTranslateX = -1;
+                    break;
                 }
                 bdi.state = kThemeStateActive;
                 bdi.value = kThemeButtonOff;
                 bdi.adornment = kThemeAdornmentNone;
                 HIRect hirect = qt_hirectForQRect(ret);
+
                 HIRect outRect;
                 HIThemeGetButtonBackgroundBounds(&hirect, &bdi, &outRect);
                 ret = qt_qrectForHIRect(outRect);
@@ -5770,13 +5791,13 @@ QRect QMacStyle::subControlRect(ComplexControl cc, const QStyleOptionComplex *op
                     Q_ASSERT(0);
                     break;
                 }
-                ret.translate(-1, -2); // hack: position the buttons correctly (weird that we need this)
+                ret.translate(hackTranslateX, 0); // hack: position the buttons correctly (weird that we need this)
                 ret = visualRect(spin->direction, spin->rect, ret);
                 break;
             }
             case SC_SpinBoxEditField:
                 ret.setRect(fw, fw,
-                            spin->rect.width() - spinner_w - fw * 2 - macSpinBoxSep + 1,
+                            spin->rect.width() - spinner_w - fw * 2 - spinBoxSep,
                             spin->rect.height() - fw * 2);
                 ret = visualRect(spin->direction, spin->rect, ret);
                 break;
@@ -5808,8 +5829,8 @@ QSize QMacStyle::sizeFromContents(ContentsType ct, const QStyleOption *opt,
 
     switch (ct) {
     case QStyle::CT_SpinBox:
-        sz.setWidth(sz.width() + macSpinBoxSep);
-        sz.setHeight(sz.height() - 3); // hack to work around horrible sizeHint() code in QAbstractSpinBox
+         // hack to work around horrible sizeHint() code in QAbstractSpinBox
+        sz.setHeight(sz.height() - 3);
         break;
     case QStyle::CT_TabBarTab:
         if (const QStyleOptionTabV3 *tab = qstyleoption_cast<const QStyleOptionTabV3 *>(opt)) {
diff --git a/src/gui/styles/qstylesheetstyle.cpp b/src/gui/styles/qstylesheetstyle.cpp
index 49ac57a..714b8c5 100644
--- a/src/gui/styles/qstylesheetstyle.cpp
+++ b/src/gui/styles/qstylesheetstyle.cpp
@@ -4926,7 +4926,7 @@ QSize QStyleSheetStyle::sizeFromContents(ContentsType ct, const QStyleOption *op
     case CT_LineEdit:
 #ifndef QT_NO_SPINBOX
         // ### hopelessly broken QAbstractSpinBox (part 2)
-        if (QAbstractSpinBox *spinBox = qobject_cast<QAbstractSpinBox *>(w->parentWidget())) {
+        if (QAbstractSpinBox *spinBox = qobject_cast<QAbstractSpinBox *>(w ? w->parentWidget() : 0)) {
             QRenderRule rule = renderRule(spinBox, opt);
             if (rule.hasBox() || !rule.hasNativeBorder())
                 return csz;
@@ -5842,7 +5842,7 @@ QRect QStyleSheetStyle::subElementRect(SubElement se, const QStyleOption *opt, c
 
 bool QStyleSheetStyle::event(QEvent *e)
 {
-    return baseStyle()->event(e) || ParentStyle::event(e);
+    return (baseStyle()->event(e) && e->isAccepted()) || ParentStyle::event(e);
 }
 
 void QStyleSheetStyle::updateStyleSheetFont(QWidget* w) const
diff --git a/src/gui/text/qcssparser.cpp b/src/gui/text/qcssparser.cpp
index db1e781..8214e54 100644
--- a/src/gui/text/qcssparser.cpp
+++ b/src/gui/text/qcssparser.cpp
@@ -278,19 +278,15 @@ static const QCssKnownValue values[NumKnownValues - 1] = {
     { "xx-large", Value_XXLarge }
 };
 
+//Map id to strings as they appears in the 'values' array above
+static const int indexOfId[NumKnownValues] = { 0, 40, 47, 41, 48, 53, 34, 26, 68, 69, 25, 42, 5, 62, 46,
+    29, 57, 58, 27, 50, 60, 6, 10, 38, 55, 19, 13, 17, 18, 20, 21, 49, 24, 45, 65, 36, 3, 2, 39, 61, 16,
+    11, 56, 14, 32, 63, 54, 64, 33, 67, 8, 28, 37, 12, 35, 59, 7, 9, 4, 66, 52, 22, 23, 30, 31, 1, 15, 0,
+    51, 44, 43 };
+
 QString Value::toString() const
 {
-    static int indexOfId[NumKnownValues - 1];
-    static bool hasCachedIndexes = false;
-
     if (type == KnownIdentifier) {
-        if (!hasCachedIndexes) {
-            for (int i = 0; i < NumKnownValues - 1; ++i)
-                indexOfId[values[i].id] = i;
-
-            hasCachedIndexes = true;
-        }
-
         return QLatin1String(values[indexOfId[variant.toInt()]].name);
     } else {
         return variant.toString();
diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp
index 43f5b1e..f73ffb5 100644
--- a/src/gui/text/qfont.cpp
+++ b/src/gui/text/qfont.cpp
@@ -890,7 +890,10 @@ int QFont::pointSize() const
 */
 void QFont::setPointSize(int pointSize)
 {
-    Q_ASSERT_X (pointSize > 0, "QFont::setPointSize", "point size must be greater than 0");
+    if (pointSize <= 0) {
+        qWarning("QFont::setPointSize: Point size <= 0 (%d), must be greater than 0", pointSize);
+        return;
+    }
 
     detach();
 
@@ -909,7 +912,10 @@ void QFont::setPointSize(int pointSize)
 */
 void QFont::setPointSizeF(qreal pointSize)
 {
-    Q_ASSERT_X(pointSize > 0.0, "QFont::setPointSizeF", "point size must be greater than 0");
+    if (pointSize <= 0) {
+        qWarning("QFont::setPointSizeF: Point size <= 0 (%f), must be greater than 0", pointSize);
+        return;
+    }
 
     detach();
 
diff --git a/src/gui/text/qfontdatabase_win.cpp b/src/gui/text/qfontdatabase_win.cpp
index c9f5586..780ae28 100644
--- a/src/gui/text/qfontdatabase_win.cpp
+++ b/src/gui/text/qfontdatabase_win.cpp
@@ -699,6 +699,7 @@ QFontEngine *loadEngine(int script, const QFontPrivate *fp, const QFontDef &requ
     }
 
     bool stockFont = false;
+    bool preferClearTypeAA = false;
 
     HFONT hfont = 0;
 
@@ -799,10 +800,12 @@ QFontEngine *loadEngine(int script, const QFontPrivate *fp, const QFontDef &requ
 #endif
 
         if (request.styleStrategy & QFont::PreferAntialias) {
-            if (QSysInfo::WindowsVersion >= QSysInfo::WV_XP)
+            if (QSysInfo::WindowsVersion >= QSysInfo::WV_XP) {
                 qual = 5; // == CLEARTYPE_QUALITY;
-            else
+                preferClearTypeAA = true;
+            } else {
                 qual = ANTIALIASED_QUALITY;
+            }
         } else if (request.styleStrategy & QFont::NoAntialias) {
             qual = NONANTIALIASED_QUALITY;
         }
@@ -884,6 +887,9 @@ QFontEngine *loadEngine(int script, const QFontPrivate *fp, const QFontDef &requ
     }
     QFontEngineWin *few = new QFontEngineWin(font_name, hfont, stockFont, lf);
 
+    if (preferClearTypeAA)
+        few->glyphFormat = QFontEngineGlyphCache::Raster_RGBMask;
+
     // Also check for OpenType tables when using complex scripts
     // ### TODO: This only works for scripts that require OpenType. More generally
     // for scripts that do not require OpenType we should just look at the list of
@@ -1134,7 +1140,7 @@ static void getFamiliesAndSignatures(const QByteArray &fontData, QFontDatabasePr
             signature.fsUsb[1] = qFromBigEndian<quint32>(table + 46);
             signature.fsUsb[2] = qFromBigEndian<quint32>(table + 50);
             signature.fsUsb[3] = qFromBigEndian<quint32>(table + 54);
-    
+
             signature.fsCsb[0] = qFromBigEndian<quint32>(table + 78);
             signature.fsCsb[1] = qFromBigEndian<quint32>(table + 82);
         }
diff --git a/src/gui/text/qfontengine.cpp b/src/gui/text/qfontengine.cpp
index 47fe5c2..d7a9c23 100644
--- a/src/gui/text/qfontengine.cpp
+++ b/src/gui/text/qfontengine.cpp
@@ -624,6 +624,45 @@ QImage QFontEngine::alphaRGBMapForGlyph(glyph_t glyph, int /* margin */, const Q
     return rgbMask;
 }
 
+QImage QFontEngine::alphaMapForGlyph(glyph_t glyph)
+{
+    glyph_metrics_t gm = boundingBox(glyph);
+    int glyph_x = qFloor(gm.x.toReal());
+    int glyph_y = qFloor(gm.y.toReal());
+    int glyph_width = qCeil((gm.x + gm.width).toReal()) -  glyph_x;
+    int glyph_height = qCeil((gm.y + gm.height).toReal()) - glyph_y;
+
+    if (glyph_width <= 0 || glyph_height <= 0)
+        return QImage();
+    QFixedPoint pt;
+    pt.x = 0;
+    pt.y = -glyph_y; // the baseline
+    QPainterPath path;
+    QImage im(glyph_width + qAbs(glyph_x) + 4, glyph_height, QImage::Format_ARGB32_Premultiplied);
+    im.fill(Qt::transparent);
+    QPainter p(&im);
+    p.setRenderHint(QPainter::Antialiasing);
+    addGlyphsToPath(&glyph, &pt, 1, &path, 0);
+    p.setPen(Qt::NoPen);
+    p.setBrush(Qt::black);
+    p.drawPath(path);
+    p.end();
+
+    QImage indexed(im.width(), im.height(), QImage::Format_Indexed8);
+    QVector<QRgb> colors(256);
+    for (int i=0; i<256; ++i)
+        colors[i] = qRgba(0, 0, 0, i);
+    indexed.setColorTable(colors);
+
+    for (int y=0; y<im.height(); ++y) {
+        uchar *dst = (uchar *) indexed.scanLine(y);
+        uint *src = (uint *) im.scanLine(y);
+        for (int x=0; x<im.width(); ++x)
+            dst[x] = qAlpha(src[x]);
+    }
+
+    return indexed;
+}
 
 void QFontEngine::removeGlyphFromCache(glyph_t)
 {
diff --git a/src/gui/text/qfontengine_ft.cpp b/src/gui/text/qfontengine_ft.cpp
index cb0b436..6f5ee1f 100644
--- a/src/gui/text/qfontengine_ft.cpp
+++ b/src/gui/text/qfontengine_ft.cpp
@@ -613,7 +613,7 @@ QFontEngineFT::QFontEngineFT(const QFontDef &fd)
     subpixelType = Subpixel_None;
     lcdFilterType = 0;
 #if defined(FT_LCD_FILTER_H)
-    lcdFilterType = (int) FT_LCD_FILTER_DEFAULT;
+    lcdFilterType = (int)((quintptr) FT_LCD_FILTER_DEFAULT);
 #endif
     defaultFormat = Format_None;
     canUploadGlyphsToServer = false;
@@ -1521,6 +1521,11 @@ bool QFontEngineFT::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs
         return false;
     }
 
+#if !defined(QT_NO_FONTCONFIG)
+    extern QMutex *qt_fontdatabase_mutex();
+    QMutex *mtx = 0;
+#endif
+
     bool mirrored = flags & QTextEngine::RightToLeft;
     int glyph_pos = 0;
     if (freetype->symbol_map) {
@@ -1533,6 +1538,11 @@ bool QFontEngineFT::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs
             if ( !glyphs->glyphs[glyph_pos] ) {
                 glyph_t glyph;
 #if !defined(QT_NO_FONTCONFIG)
+                if (!mtx) {
+                    mtx = qt_fontdatabase_mutex();
+                    mtx->lock();
+                }
+
                 if (FcCharSetHasChar(freetype->charset, uc)) {
 #else
                 if (false) {
@@ -1561,20 +1571,26 @@ bool QFontEngineFT::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs
             if (mirrored)
                 uc = QChar::mirroredChar(uc);
             glyphs->glyphs[glyph_pos] = uc < QFreetypeFace::cmapCacheSize ? freetype->cmapCache[uc] : 0;
-            if (!glyphs->glyphs[glyph_pos]
+            if (!glyphs->glyphs[glyph_pos]) {
 #if !defined(QT_NO_FONTCONFIG)
-                && FcCharSetHasChar(freetype->charset, uc)
+                if (!mtx) {
+                    mtx = qt_fontdatabase_mutex();
+                    mtx->lock();
+                }
+
+                if (FcCharSetHasChar(freetype->charset, uc))
 #endif
-                ) {
-            redo:
-                glyph_t glyph = FT_Get_Char_Index(face, uc);
-                if (!glyph && (uc == 0xa0 || uc == 0x9)) {
-                    uc = 0x20;
-                    goto redo;
+                {
+                redo:
+                    glyph_t glyph = FT_Get_Char_Index(face, uc);
+                    if (!glyph && (uc == 0xa0 || uc == 0x9)) {
+                        uc = 0x20;
+                        goto redo;
+                    }
+                    glyphs->glyphs[glyph_pos] = glyph;
+                    if (uc < QFreetypeFace::cmapCacheSize)
+                        freetype->cmapCache[uc] = glyph;
                 }
-                glyphs->glyphs[glyph_pos] = glyph;
-                if (uc < QFreetypeFace::cmapCacheSize)
-                    freetype->cmapCache[uc] = glyph;
             }
             ++glyph_pos;
         }
@@ -1583,6 +1599,11 @@ bool QFontEngineFT::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs
     *nglyphs = glyph_pos;
     glyphs->numGlyphs = glyph_pos;
 
+#if !defined(QT_NO_FONTCONFIG)
+    if (mtx)
+        mtx->unlock();
+#endif
+
     if (flags & QTextEngine::GlyphIndicesOnly)
         return true;
 
@@ -1788,9 +1809,11 @@ QImage QFontEngineFT::alphaMapForGlyph(glyph_t g)
 
     GlyphFormat glyph_format = antialias ? Format_A8 : Format_Mono;
 
-    Glyph *glyph = loadGlyph(g, glyph_format);
-    if (!glyph)
-        return QImage();
+    Glyph *glyph = defaultGlyphSet.outline_drawing ? 0 : loadGlyph(g, glyph_format);
+    if (!glyph) {
+        unlockFace();
+        return QFontEngine::alphaMapForGlyph(g);
+    }
 
     const int pitch = antialias ? (glyph->width + 3) & ~3 : ((glyph->width + 31)/32) * 4;
 
diff --git a/src/gui/text/qfontengine_p.h b/src/gui/text/qfontengine_p.h
index 176c728..dc18991 100644
--- a/src/gui/text/qfontengine_p.h
+++ b/src/gui/text/qfontengine_p.h
@@ -178,7 +178,7 @@ public:
      * Create a qimage with the alpha values for the glyph.
      * Returns an image indexed_8 with index values ranging from 0=fully transparant to 255=opaque
      */
-    virtual QImage alphaMapForGlyph(glyph_t) = 0;
+    virtual QImage alphaMapForGlyph(glyph_t);
     virtual QImage alphaMapForGlyph(glyph_t, const QTransform &t);
     virtual QImage alphaRGBMapForGlyph(glyph_t, int margin, const QTransform &t);
 
diff --git a/src/gui/text/qtextcursor.cpp b/src/gui/text/qtextcursor.cpp
index c327b9f..48963bb 100644
--- a/src/gui/text/qtextcursor.cpp
+++ b/src/gui/text/qtextcursor.cpp
@@ -1074,7 +1074,10 @@ QTextCursor::QTextCursor(const QTextCursor &cursor)
 }
 
 /*!
-    Makes a copy of \a cursor and assigns it to this QTextCursor.
+    Makes a copy of \a cursor and assigns it to this QTextCursor. Note
+    that QTextCursor is an \l{Implicitly Shared Classes}{implicitly
+    shared} class.
+
  */
 QTextCursor &QTextCursor::operator=(const QTextCursor &cursor)
 {
diff --git a/src/gui/text/qtextdocument.cpp b/src/gui/text/qtextdocument.cpp
index e84b324..873f846 100644
--- a/src/gui/text/qtextdocument.cpp
+++ b/src/gui/text/qtextdocument.cpp
@@ -287,7 +287,7 @@ QTextCodec *Qt::codecForHtml(const QByteArray &ba)
     that inform connected editor widgets about the state of the undo/redo
     system.
 
-    \sa QTextCursor QTextEdit \link richtext.html Rich Text Processing\endlink
+    \sa QTextCursor, QTextEdit, \link richtext.html Rich Text Processing\endlink , {Text Object Example}
 */
 
 /*!
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/text/qtextobject.cpp b/src/gui/text/qtextobject.cpp
index 3f4c8e5..71b68e0 100644
--- a/src/gui/text/qtextobject.cpp
+++ b/src/gui/text/qtextobject.cpp
@@ -76,7 +76,7 @@ QT_BEGIN_NAMESPACE
     objects, you will also need to reimplement QTextDocument::createObject()
     which acts as a factory method for creating text objects.
 
-    \sa QTextDocument
+    \sa QTextDocument, {Text Object Example}
 */
 
 /*!
diff --git a/src/gui/text/qtexttable.cpp b/src/gui/text/qtexttable.cpp
index ba1c04f..48708c9 100644
--- a/src/gui/text/qtexttable.cpp
+++ b/src/gui/text/qtexttable.cpp
@@ -525,7 +525,12 @@ void QTextTablePrivate::update() const
     Rows and columns within a QTextTable can be merged and split using
     the mergeCells() and splitCell() functions. However, only cells that span multiple
     rows or columns can be split. (Merging or splitting does not increase or decrease
-    the number of rows and columns.)
+    the number of rows and columns.) 
+
+    Note that if you have merged multiple columns and rows into one cell, you will not
+    be able to split the merged cell into new cells spanning over more than one row 
+    or column. To be able to split cells spanning over several rows and columns you 
+    need to do this over several iterations.
 
     \table 80%
     \row
diff --git a/src/gui/util/qcompleter.cpp b/src/gui/util/qcompleter.cpp
index 7571dfe..faa4e7b 100644
--- a/src/gui/util/qcompleter.cpp
+++ b/src/gui/util/qcompleter.cpp
@@ -824,7 +824,7 @@ void QCompleterPrivate::_q_complete(QModelIndex index, bool highlighted)
     Q_Q(QCompleter);
     QString completion;
 
-    if (!index.isValid() || (index.row() >= proxy->engine->matchCount())) {
+    if (!index.isValid() || (!proxy->showAll && (index.row() >= proxy->engine->matchCount()))) {
         completion = prefix;
     } else {
         QModelIndex si = proxy->mapToSource(index);
@@ -1080,7 +1080,7 @@ void QCompleter::setPopup(QAbstractItemView *popup)
     popup->hide();
     popup->setParent(0, Qt::Popup);
 
-    Qt::FocusPolicy origPolicy;
+    Qt::FocusPolicy origPolicy = Qt::NoFocus;
     if (d->widget)
         origPolicy = d->widget->focusPolicy();
     popup->setFocusPolicy(Qt::NoFocus);
diff --git a/src/gui/widgets/qmainwindow.cpp b/src/gui/widgets/qmainwindow.cpp
index 2abc9e8..502c1e9 100644
--- a/src/gui/widgets/qmainwindow.cpp
+++ b/src/gui/widgets/qmainwindow.cpp
@@ -480,9 +480,6 @@ void QMainWindow::setMenuBar(QMenuBar *menuBar)
         oldMenuBar->hide();
         oldMenuBar->deleteLater();
     }
-#ifdef Q_OS_WINCE
-    if (menuBar && menuBar->size().height() > 0)
-#endif
     d->layout->setMenuBar(menuBar);
 }
 
diff --git a/src/gui/widgets/qmenu_wince.cpp b/src/gui/widgets/qmenu_wince.cpp
index ea58d46..847a623 100644
--- a/src/gui/widgets/qmenu_wince.cpp
+++ b/src/gui/widgets/qmenu_wince.cpp
@@ -58,6 +58,9 @@
 
 #include <QtCore/qlibrary.h>
 #include <commctrl.h>
+#if Q_OS_WINCE_WM
+#   include <windowsm.h>
+#endif
 
 #include "qguifunctions_wince.h"
 
@@ -71,6 +74,12 @@
 #define SHCMBM_GETSUBMENU (WM_USER + 401)
 #endif
 
+#ifdef Q_OS_WINCE_WM
+#   define SHMBOF_NODEFAULT 0x00000001
+#   define SHMBOF_NOTIFY    0x00000002
+#   define SHCMBM_OVERRIDEKEY (WM_USER + 0x193)
+#endif
+
 extern bool qt_wince_is_smartphone();//defined in qguifunctions_wce.cpp
 extern bool qt_wince_is_pocket_pc(); //defined in qguifunctions_wce.cpp
 
@@ -204,8 +213,13 @@ static HWND qt_wce_create_menubar(HWND parentHandle, HINSTANCE resourceHandle, i
         mbi.dwFlags = flags;
         mbi.nToolBarId = toolbarID;
 
-        if (ptrCreateMenuBar(&mbi))
+        if (ptrCreateMenuBar(&mbi)) {
+            // Tell the menu bar that we want to override hot key behaviour.
+            LPARAM lparam = MAKELPARAM(SHMBOF_NODEFAULT | SHMBOF_NOTIFY,
+                                       SHMBOF_NODEFAULT | SHMBOF_NOTIFY);
+            SendMessage(mbi.hwndMB, SHCMBM_OVERRIDEKEY, VK_TBACK, lparam);
             return mbi.hwndMB;
+        }
     }
     return 0;
 }
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/gui/widgets/qtabbar.cpp b/src/gui/widgets/qtabbar.cpp
index b6e6b6d..69221ba 100644
--- a/src/gui/widgets/qtabbar.cpp
+++ b/src/gui/widgets/qtabbar.cpp
@@ -1085,7 +1085,7 @@ void QTabBar::setTabData(int index, const QVariant & data)
 }
 
 /*!
-    Returns the datad of the tab at position \a index, or a null
+    Returns the data of the tab at position \a index, or a null
     variant if \a index is out of range.
 */
 QVariant QTabBar::tabData(int index) const
@@ -1167,13 +1167,13 @@ void QTabBar::setCurrentIndex(int index)
         d->currentIndex = index;
         update();
         d->makeVisible(index);
+        d->tabList[index].lastTab = oldIndex;
+        d->layoutWidgets(oldIndex);
+        d->layoutWidgets(index);
 #ifdef QT3_SUPPORT
         emit selected(index);
 #endif
         emit currentChanged(index);
-        d->tabList[index].lastTab = oldIndex;
-        d->layoutWidgets(oldIndex);
-        d->layoutWidgets(index);
     }
 }
 
@@ -2222,6 +2222,7 @@ void QTabBar::setTabButton(int index, ButtonPosition position, QWidget *widget)
         d->tabList[index].rightWidget = widget;
     }
     d->layoutTabs();
+    d->refresh();
     update();
 }
 
diff --git a/src/network/access/qhttpnetworkconnection.cpp b/src/network/access/qhttpnetworkconnection.cpp
index 980c0e0..5940fba 100644
--- a/src/network/access/qhttpnetworkconnection.cpp
+++ b/src/network/access/qhttpnetworkconnection.cpp
@@ -265,6 +265,11 @@ bool QHttpNetworkConnectionPrivate::ensureConnection(QAbstractSocket *socket)
     if (socket->state() != QAbstractSocket::ConnectedState) {
         // connect to the host if not already connected.
         int index = indexOf(socket);
+        // resend this request after we receive the disconnected signal
+        if (socket->state() == QAbstractSocket::ClosingState) {
+            channels[index].resendCurrent = true;
+            return false;
+        }
         channels[index].state = ConnectingState;
         channels[index].pendingEncrypt = encrypt;
 
@@ -982,6 +987,9 @@ void QHttpNetworkConnectionPrivate::_q_disconnected()
         channels[i].state = ReadingState;
         if (channels[i].reply)
             receiveReply(socket, channels[i].reply);
+    } else if (channels[i].state == IdleState && channels[i].resendCurrent) {
+        // re-sending request because the socket was in ClosingState
+        QMetaObject::invokeMethod(q, "_q_startNextRequest", Qt::QueuedConnection);
     }
     channels[i].state = IdleState;
 }
diff --git a/src/network/access/qnetworkaccessmanager.cpp b/src/network/access/qnetworkaccessmanager.cpp
index 11e1e46..bcbeef1 100644
--- a/src/network/access/qnetworkaccessmanager.cpp
+++ b/src/network/access/qnetworkaccessmanager.cpp
@@ -477,7 +477,8 @@ void QNetworkAccessManager::setCache(QAbstractNetworkCache *cache)
     if (d->networkCache != cache) {
         delete d->networkCache;
         d->networkCache = cache;
-        d->networkCache->setParent(this);
+        if (d->networkCache)
+            d->networkCache->setParent(this);
     }
 }
 
diff --git a/src/network/access/qnetworkcookie.cpp b/src/network/access/qnetworkcookie.cpp
index 01a743b..67df526 100644
--- a/src/network/access/qnetworkcookie.cpp
+++ b/src/network/access/qnetworkcookie.cpp
@@ -913,6 +913,17 @@ static QDateTime parseDateString(const QByteArray &dateString)
 */
 QList<QNetworkCookie> QNetworkCookie::parseCookies(const QByteArray &cookieString)
 {
+    // cookieString can be a number of set-cookie header strings joined together
+    // by \n, parse each line separately.
+    QList<QNetworkCookie> cookies;
+    QList<QByteArray> list = cookieString.split('\n');
+    for (int a = 0; a < list.size(); a++)
+        cookies += QNetworkCookiePrivate::parseSetCookieHeaderLine(list.at(a));
+    return cookies;
+}
+
+QList<QNetworkCookie> QNetworkCookiePrivate::parseSetCookieHeaderLine(const QByteArray &cookieString)
+{
     // According to http://wp.netscape.com/newsref/std/cookie_spec.html,<
     // the Set-Cookie response header is of the format:
     //
@@ -930,12 +941,6 @@ QList<QNetworkCookie> QNetworkCookie::parseCookies(const QByteArray &cookieStrin
     while (position < length) {
         QNetworkCookie cookie;
 
-        // When there are multiple SetCookie headers they are join with a new line
-        // \n will always be the start of a new cookie
-        int endOfSetCookie = cookieString.indexOf('\n', position);
-        if (endOfSetCookie == -1)
-            endOfSetCookie = length;
-
         // The first part is always the "NAME=VALUE" part
         QPair<QByteArray,QByteArray> field = nextField(cookieString, position);
         if (field.first.isEmpty() || field.second.isNull())
@@ -946,7 +951,7 @@ QList<QNetworkCookie> QNetworkCookie::parseCookies(const QByteArray &cookieStrin
 
         position = nextNonWhitespace(cookieString, position);
         bool endOfCookie = false;
-        while (!endOfCookie && position < endOfSetCookie)
+        while (!endOfCookie && position < length) {
             switch (cookieString.at(position++)) {
             case ',':
                 // end of the cookie
@@ -969,27 +974,24 @@ QList<QNetworkCookie> QNetworkCookie::parseCookies(const QByteArray &cookieStrin
                     position = end;
                     QDateTime dt = parseDateString(dateString.toLower());
                     if (!dt.isValid()) {
-                        cookie = QNetworkCookie();
-                        endOfCookie = true;
-                        continue;
+                        return result;
                     }
                     cookie.setExpirationDate(dt);
                 } else if (field.first == "domain") {
                     QByteArray rawDomain = field.second;
-                    QString maybeLeadingDot;
                     if (rawDomain.startsWith('.')) {
-                        maybeLeadingDot = QLatin1Char('.');
                         rawDomain = rawDomain.mid(1);
                     }
-
                     QString normalizedDomain = QUrl::fromAce(QUrl::toAce(QString::fromUtf8(rawDomain)));
-                    cookie.setDomain(maybeLeadingDot + normalizedDomain);
+                    // always add the dot, there are some servers that forget the
+                    // leading dot. This is actually forbidden according to RFC 2109,
+                    // but all browsers accept it anyway so we do that as well
+                    cookie.setDomain(QLatin1Char('.') + normalizedDomain);
                 } else if (field.first == "max-age") {
                     bool ok = false;
                     int secs = field.second.toInt(&ok);
                     if (!ok)
-                        // invalid cookie string
-                        return QList<QNetworkCookie>();
+                        return result;
                     cookie.setExpirationDate(now.addSecs(secs));
                 } else if (field.first == "path") {
                     QString path = QUrl::fromPercentEncoding(field.second);
@@ -1003,9 +1005,7 @@ QList<QNetworkCookie> QNetworkCookie::parseCookies(const QByteArray &cookieStrin
                 } else if (field.first == "version") {
                     if (field.second != "1") {
                         // oops, we don't know how to handle this cookie
-                        cookie = QNetworkCookie();
-                        endOfCookie = true;
-                        continue;
+                        return result;
                     }
                 } else {
                     // got an unknown field in the cookie
@@ -1013,9 +1013,8 @@ QList<QNetworkCookie> QNetworkCookie::parseCookies(const QByteArray &cookieStrin
                 }
 
                 position = nextNonWhitespace(cookieString, position);
-                if (position > endOfSetCookie)
-                    endOfCookie = true;
             }
+        }
 
         if (!cookie.name().isEmpty())
             result += cookie;
@@ -1184,7 +1183,6 @@ bool QNetworkCookieJar::setCookiesFromUrl(const QList<QNetworkCookie> &cookieLis
                           cookie.expirationDate() < now;
 
         // validate the cookie & set the defaults if unset
-        // (RFC 2965: "The request-URI MUST path-match the Path attribute of the cookie.")
         if (cookie.path().isEmpty())
             cookie.setPath(defaultPath);
         else if (!isParentPath(pathAndFileName, cookie.path()))
@@ -1198,6 +1196,13 @@ bool QNetworkCookieJar::setCookiesFromUrl(const QList<QNetworkCookie> &cookieLis
                 || isParentDomain(defaultDomain, domain))) {
                     continue;           // not accepted
             }
+
+            // reject if domain is like ".com"
+            // (i.e., reject if domain does not contain embedded dots, see RFC 2109 section 4.3.2)
+            // this is just a rudimentary check and does not cover all cases
+            if (domain.lastIndexOf(QLatin1Char('.')) == 0)
+                continue;           // not accepted
+
         }
 
         QList<QNetworkCookie>::Iterator it = d->allCookies.begin(),
diff --git a/src/network/access/qnetworkcookie_p.h b/src/network/access/qnetworkcookie_p.h
index 83ef14a..0c41322 100644
--- a/src/network/access/qnetworkcookie_p.h
+++ b/src/network/access/qnetworkcookie_p.h
@@ -61,6 +61,7 @@ class QNetworkCookiePrivate: public QSharedData
 {
 public:
     inline QNetworkCookiePrivate() : secure(false), httpOnly(false) { }
+    static QList<QNetworkCookie> parseSetCookieHeaderLine(const QByteArray &cookieString);
 
     QDateTime expirationDate;
     QString domain;
diff --git a/src/network/access/qnetworkdiskcache.cpp b/src/network/access/qnetworkdiskcache.cpp
index 93360c8..892929e 100644
--- a/src/network/access/qnetworkdiskcache.cpp
+++ b/src/network/access/qnetworkdiskcache.cpp
@@ -191,7 +191,11 @@ QIODevice *QNetworkDiskCache::prepare(const QNetworkCacheMetaData &metaData)
     } else {
         QString templateName = d->tmpCacheFileName();
         cacheItem->file = new QTemporaryFile(templateName, &cacheItem->data);
-        cacheItem->file->open();
+        if (!cacheItem->file->open()) {
+            qWarning() << "QNetworkDiskCache::prepare() unable to open temporary file";
+            delete cacheItem;
+            return 0;
+        }
         cacheItem->writeHeader(cacheItem->file);
         device = cacheItem->file;
     }
@@ -229,7 +233,7 @@ void QNetworkDiskCachePrivate::storeItem(QCacheItem *cacheItem)
 
     if (QFile::exists(fileName)) {
         if (!QFile::remove(fileName)) {
-            qWarning() << "QNetworkDiskCache: could't remove the cache file " << fileName;
+            qWarning() << "QNetworkDiskCache: couldn't remove the cache file " << fileName;
             return;
         }
     }
diff --git a/src/network/kernel/qauthenticator.cpp b/src/network/kernel/qauthenticator.cpp
index c9161f8..33795aa 100644
--- a/src/network/kernel/qauthenticator.cpp
+++ b/src/network/kernel/qauthenticator.cpp
@@ -73,6 +73,15 @@ static QByteArray qNtlmPhase3(QAuthenticatorPrivate *ctx, const QByteArray& phas
   authentication information to the socket when accessing services that
   require authentication.
 
+  QAuthenticator supports the following authentication methods:
+  \list
+    \o Basic
+    \o NTLM version 1
+    \o Digest-MD5
+  \endlist
+
+  Note that, in particular, NTLM version 2 is not supported.
+
   \sa QSslSocket
 */
 
diff --git a/src/network/kernel/qnetworkproxy.cpp b/src/network/kernel/qnetworkproxy.cpp
index f4ece97..62bdfc7 100644
--- a/src/network/kernel/qnetworkproxy.cpp
+++ b/src/network/kernel/qnetworkproxy.cpp
@@ -86,10 +86,11 @@
     The SOCKS5 support in Qt 4 is based on \l{RFC 1928} and \l{RFC 1929}.
     The supported authentication methods are no authentication and
     username/password authentication.  Both IPv4 and IPv6 are
-    supported, but domain name resolution via the SOCKS server is not
-    supported; i.e. all domain names are resolved locally. There are
-    several things to remember when using SOCKS5 with QUdpSocket and
-    QTcpServer:
+    supported. Domain names are resolved through the SOCKS5 server if
+    the QNetworkProxy::HostNameLookupCapability is enabled, otherwise
+    they are resolved locally and the IP address is sent to the
+    server. There are several things to remember when using SOCKS5
+    with QUdpSocket and QTcpServer:
 
     With QUdpSocket, a call to \l {QUdpSocket::bind()}{bind()} may fail
     with a timeout error. If a port number other than 0 is passed to
@@ -365,7 +366,8 @@ static QNetworkProxy::Capabilities defaultCapabilitiesForType(QNetworkProxy::Pro
          int(QNetworkProxy::HostNameLookupCapability)),
     };
 
-    Q_ASSERT(int(type) >= 0 && int(type) <= int(QNetworkProxy::FtpCachingProxy));
+    if (int(type) < 0 && int(type) > int(QNetworkProxy::FtpCachingProxy))
+        type = QNetworkProxy::DefaultProxy;
     return QNetworkProxy::Capabilities(defaults[int(type)]);
 }
 
@@ -378,6 +380,7 @@ public:
     QNetworkProxy::Capabilities capabilities;
     quint16 port;
     QNetworkProxy::ProxyType type;
+    bool capabilitiesSet;
 
     inline QNetworkProxyPrivate(QNetworkProxy::ProxyType t = QNetworkProxy::DefaultProxy,
                                 const QString &h = QString(), quint16 p = 0,
@@ -387,7 +390,8 @@ public:
           password(pw),
           capabilities(defaultCapabilitiesForType(t)),
           port(p),
-          type(t)
+          type(t),
+          capabilitiesSet(false)
     { }
 
     inline bool operator==(const QNetworkProxyPrivate &other) const
@@ -490,13 +494,16 @@ QNetworkProxy &QNetworkProxy::operator=(const QNetworkProxy &other)
     Sets the proxy type for this instance to be \a type.
 
     Note that changing the type of a proxy does not change
-    the set of capabilities this QNetworkProxy object holds.
+    the set of capabilities this QNetworkProxy object holds if any
+    capabilities have been set with setCapabilities().
 
     \sa type(), setCapabilities()
 */
 void QNetworkProxy::setType(QNetworkProxy::ProxyType type)
 {
     d->type = type;
+    if (!d->capabilitiesSet)
+        d->capabilities = defaultCapabilitiesForType(type);
 }
 
 /*!
@@ -519,6 +526,7 @@ QNetworkProxy::ProxyType QNetworkProxy::type() const
 void QNetworkProxy::setCapabilities(Capabilities capabilities)
 {
     d->capabilities = capabilities;
+    d->capabilitiesSet = true;
 }
 
 /*!
diff --git a/src/network/socket/qlocalserver_unix.cpp b/src/network/socket/qlocalserver_unix.cpp
index 065a9de..e7d2252 100644
--- a/src/network/socket/qlocalserver_unix.cpp
+++ b/src/network/socket/qlocalserver_unix.cpp
@@ -148,9 +148,11 @@ void QLocalServerPrivate::closeServer()
         QT_CLOSE(listenSocket);
     listenSocket = -1;
 
-    if (socketNotifier)
+    if (socketNotifier) {
+        socketNotifier->setEnabled(false); // Otherwise, closed socket is checked before deleter runs
         socketNotifier->deleteLater();
-    socketNotifier = 0;
+        socketNotifier = 0;
+    }
 
     if (!fullServerName.isEmpty())
         QFile::remove(fullServerName);
diff --git a/src/network/socket/qlocalsocket_win.cpp b/src/network/socket/qlocalsocket_win.cpp
index e759d0b..39c9284 100644
--- a/src/network/socket/qlocalsocket_win.cpp
+++ b/src/network/socket/qlocalsocket_win.cpp
@@ -298,7 +298,7 @@ qint64 QLocalSocketPrivate::bytesAvailable()
     if (PeekNamedPipe(handle, NULL, 0, NULL, &bytes, NULL)) {
         return bytes;
     } else {
-        if (ERROR_BROKEN_PIPE == GetLastError() && !pipeClosed) {
+        if (!pipeClosed) {
             pipeClosed = true;
             QTimer::singleShot(0, q, SLOT(_q_pipeClosed()));
         }
diff --git a/src/network/ssl/qsslcipher.cpp b/src/network/ssl/qsslcipher.cpp
index 505c662..7fec2df 100644
--- a/src/network/ssl/qsslcipher.cpp
+++ b/src/network/ssl/qsslcipher.cpp
@@ -64,9 +64,9 @@
 
 #ifndef QT_NO_DEBUG_STREAM
 #include <QtCore/qdebug.h>
+#endif
 
 QT_BEGIN_NAMESPACE
-#endif
 
 /*!
     Constructs an empty QSslCipher object.
diff --git a/src/network/ssl/qsslsocket_openssl_symbols.cpp b/src/network/ssl/qsslsocket_openssl_symbols.cpp
index e09e764..42c09f5 100644
--- a/src/network/ssl/qsslsocket_openssl_symbols.cpp
+++ b/src/network/ssl/qsslsocket_openssl_symbols.cpp
@@ -364,11 +364,14 @@ static QPair<QLibrary*, QLibrary*> loadOpenSsl()
     // DT_RPATH tags on our library header as well as other system-specific search
     // paths. See the man page for dlopen(3) on your system for more information.
 
+#ifdef Q_OS_OPENBSD
+    libcrypto->setLoadHints(QLibrary::ExportExternalSymbolsHint);
+#endif
 #ifdef SHLIB_VERSION_NUMBER
     // first attempt: the canonical name is libssl.so.<SHLIB_VERSION_NUMBER>
     libssl->setFileNameAndVersion(QLatin1String("ssl"), QLatin1String(SHLIB_VERSION_NUMBER));
     libcrypto->setFileNameAndVersion(QLatin1String("crypto"), QLatin1String(SHLIB_VERSION_NUMBER));
-    if (libssl->load() && libcrypto->load()) {
+    if (libcrypto->load() && libssl->load()) {
         // libssl.so.<SHLIB_VERSION_NUMBER> and libcrypto.so.<SHLIB_VERSION_NUMBER> found
         return pair;
     } else {
@@ -380,7 +383,7 @@ static QPair<QLibrary*, QLibrary*> loadOpenSsl()
     // second attempt: find the development files libssl.so and libcrypto.so
     libssl->setFileNameAndVersion(QLatin1String("ssl"), -1);
     libcrypto->setFileNameAndVersion(QLatin1String("crypto"), -1);
-    if (libssl->load() && libcrypto->load()) {
+    if (libcrypto->load() && libssl->load()) {
         // libssl.so.0 and libcrypto.so.0 found
         return pair;
     } else {
@@ -395,7 +398,7 @@ static QPair<QLibrary*, QLibrary*> loadOpenSsl()
         crypto.replace(QLatin1String("ssl"), QLatin1String("crypto"));
         libssl->setFileNameAndVersion(ssl, -1);
         libcrypto->setFileNameAndVersion(crypto, -1);
-        if (libssl->load() && libcrypto->load()) {
+        if (libcrypto->load() && libssl->load()) {
             // libssl.so.0 and libcrypto.so.0 found
             return pair;
         } else {
diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp
index b4a0e5c..04bc611 100644
--- a/src/opengl/qgl.cpp
+++ b/src/opengl/qgl.cpp
@@ -1327,13 +1327,21 @@ QImage qt_gl_read_framebuffer(const QSize &size, bool alpha_format, bool include
             // This is an old legacy fix for PowerPC based Macs, which
             // we shouldn't remove
             while (p < end) {
-                *p = 0xFF000000 | (*p>>8);
+                *p = 0xff000000 | (*p>>8);
                 ++p;
             }
         }
     } else {
         // OpenGL gives ABGR (i.e. RGBA backwards); Qt wants ARGB
-        img = img.rgbSwapped();
+        for (int y = 0; y < h; y++) {
+            uint *q = (uint*)img.scanLine(y);
+            for (int x=0; x < w; ++x) {
+                const uint pixel = *q;
+                *q = ((pixel << 16) & 0xff0000) | ((pixel >> 16) & 0xff) | (pixel & 0xff00ff00);
+                q++;
+            }
+        }
+
     }
     return img.mirrored();
 }
@@ -2398,6 +2406,10 @@ bool QGLContext::create(const QGLContext* shareContext)
         return false;
     reset();
     d->valid = chooseContext(shareContext);
+    if (d->valid && d->paintDevice->devType() == QInternal::Widget) {
+        QWidgetPrivate *wd = qt_widget_private(static_cast<QWidget *>(d->paintDevice));
+        wd->usesDoubleBufferedGLContext = d->glFormat.doubleBuffer();
+    }
     if (d->sharing)  // ok, we managed to share
         qgl_share_reg()->addShare(this, shareContext);
     return d->valid;
diff --git a/src/opengl/qglpixelbuffer_mac.mm b/src/opengl/qglpixelbuffer_mac.mm
index 9a679b1..e95e36b 100644
--- a/src/opengl/qglpixelbuffer_mac.mm
+++ b/src/opengl/qglpixelbuffer_mac.mm
@@ -299,9 +299,8 @@ void QGLPixelBuffer::releaseFromDynamicTexture()
 
 GLuint QGLPixelBuffer::generateDynamicTexture() const
 {
-    Q_D(const QGLPixelBuffer);
-
 #ifdef QT_MAC_USE_COCOA
+    Q_D(const QGLPixelBuffer);
     NSOpenGLContext *oldContext = [NSOpenGLContext currentContext];
     if (d->share_ctx != oldContext)
         [static_cast<NSOpenGLContext *>(d->share_ctx) makeCurrentContext];
diff --git a/src/opengl/qpaintengine_opengl.cpp b/src/opengl/qpaintengine_opengl.cpp
index 88fd379..5a212f5 100644
--- a/src/opengl/qpaintengine_opengl.cpp
+++ b/src/opengl/qpaintengine_opengl.cpp
@@ -3716,8 +3716,14 @@ void QOpenGLPaintEngine::drawRects(const QRectF *rects, int rectCount)
                 d->disableClipping();
                 GLuint program = qt_gl_program_cache()->getProgram(d->drawable.context(),
                                                                    FRAGMENT_PROGRAM_MASK_TRAPEZOID_AA, 0, true);
-                QGLRectMaskGenerator maskGenerator(path, d->matrix, d->offscreen, program);
-                d->addItem(qt_mask_texture_cache()->getMask(maskGenerator, d));
+
+                if (d->matrix.type() >= QTransform::TxProject) {
+                    QGLPathMaskGenerator maskGenerator(path, d->matrix, d->offscreen, program);
+                    d->addItem(qt_mask_texture_cache()->getMask(maskGenerator, d));
+                } else {
+                    QGLRectMaskGenerator maskGenerator(path, d->matrix, d->offscreen, program);
+                    d->addItem(qt_mask_texture_cache()->getMask(maskGenerator, d));
+                }
 
                 d->enableClipping();
             }
@@ -5062,9 +5068,8 @@ void QOpenGLPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textIte
 
     // fall back to drawing a polygon if the scale factor is large, or
     // we use a gradient pen
-    if (ti.fontEngine->fontDef.pixelSize >= 64
-        || (d->matrix.det() > 1) || (d->pen_brush_style >= Qt::LinearGradientPattern
-                                     && d->pen_brush_style <= Qt::ConicalGradientPattern)) {
+    if ((d->matrix.det() > 1) || (d->pen_brush_style >= Qt::LinearGradientPattern
+                                  && d->pen_brush_style <= Qt::ConicalGradientPattern)) {
         QPaintEngine::drawTextItem(p, textItem);
         return;
     }
diff --git a/src/opengl/qwindowsurface_gl.cpp b/src/opengl/qwindowsurface_gl.cpp
index 837ccf2..b41adf9 100644
--- a/src/opengl/qwindowsurface_gl.cpp
+++ b/src/opengl/qwindowsurface_gl.cpp
@@ -86,7 +86,7 @@ QT_BEGIN_NAMESPACE
 // QGLGraphicsSystem
 //
 #ifdef Q_WS_WIN
-Q_GUI_EXPORT bool qt_win_owndc_required;
+extern Q_GUI_EXPORT bool qt_win_owndc_required;
 #endif
 QGLGraphicsSystem::QGLGraphicsSystem()
     : QGraphicsSystem()
diff --git a/src/plugins/gfxdrivers/directfb/directfb.pro b/src/plugins/gfxdrivers/directfb/directfb.pro
index 89a289c..5c60b2f 100644
--- a/src/plugins/gfxdrivers/directfb/directfb.pro
+++ b/src/plugins/gfxdrivers/directfb/directfb.pro
@@ -3,9 +3,10 @@ include(../../qpluginbase.pri)
 
 QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/gfxdrivers
 
-# These defines might be necessary if your DirectFB driver doesn't 
+# 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
@@ -14,29 +15,30 @@ QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/gfxdrivers
 #DEFINES += QT_NO_DIRECTFB_KEYBOARD
 #DEFINES += QT_DIRECTFB_TIMING
 #DEFINES += QT_NO_DIRECTFB_OPAQUE_DETECTION
+#DIRECTFB_DRAWINGOPERATIONS=DRAW_RECTS|DRAW_LINES|DRAW_IMAGE|DRAW_PIXMAP|DRAW_TILED_PIXMAP|STROKE_PATH|DRAW_PATH|DRAW_POINTS|DRAW_ELLIPSE|DRAW_POLYGON|DRAW_TEXT|FILL_PATH|FILL_RECT|DRAW_COLORSPANS
+#DEFINES += \"QT_DIRECTFB_WARN_ON_RASTERFALLBACKS=$$DIRECTFB_DRAWINGOPERATIONS\"
+#DEFINES += \"QT_DIRECTFB_DISABLE_RASTERFALLBACKS=$$DIRECTFB_DRAWINGOPERATIONS\"
 
 target.path = $$[QT_INSTALL_PLUGINS]/gfxdrivers
 INSTALLS += target
 
-HEADERS	= \
-	qdirectfbscreen.h \
-	qdirectfbsurface.h \
-	qdirectfbpaintengine.h \
-        qdirectfbpaintdevice.h \
-	qdirectfbpixmap.h \
-	qdirectfbkeyboard.h \
-	qdirectfbmouse.h
+HEADERS = qdirectfbscreen.h \
+          qdirectfbwindowsurface.h \
+          qdirectfbpaintengine.h \
+          qdirectfbpaintdevice.h \
+          qdirectfbpixmap.h \
+          qdirectfbkeyboard.h \
+          qdirectfbmouse.h
 
-SOURCES	= \
-	qdirectfbscreen.cpp \
-	qdirectfbscreenplugin.cpp \
-	qdirectfbsurface.cpp \
-	qdirectfbpaintengine.cpp \
-        qdirectfbpaintdevice.cpp \
-	qdirectfbpixmap.cpp \
-	qdirectfbkeyboard.cpp \
-	qdirectfbmouse.cpp
+SOURCES = qdirectfbscreen.cpp \
+          qdirectfbscreenplugin.cpp \
+          qdirectfbwindowsurface.cpp \
+          qdirectfbpaintengine.cpp \
+          qdirectfbpaintdevice.cpp \
+          qdirectfbpixmap.cpp \
+          qdirectfbkeyboard.cpp \
+          qdirectfbmouse.cpp
 
 QMAKE_CXXFLAGS += $$QT_CFLAGS_DIRECTFB
 LIBS += $$QT_LIBS_DIRECTFB
-
+DEFINES += $$QT_DEFINES_DIRECTFB
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbkeyboard.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbkeyboard.cpp
index cd19f69..368b9f9 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbkeyboard.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbkeyboard.cpp
@@ -173,6 +173,22 @@ void QDirectFBKeyboardHandlerPrivate::readKeyboardData()
 
         Qt::KeyboardModifiers modifiers = Qt::NoModifier;
 
+        // Not implemented:
+        // if (input.modifiers & DIMM_SUPER)
+        // if (input.modifiers & DIMM_HYPER)
+
+        if (!(input.flags & DIEF_KEYSYMBOL) ||
+            !(input.flags & DIEF_KEYID) ||
+            !(input.type & (DIET_KEYPRESS|DIET_KEYRELEASE)))
+        {
+            static bool first = true;
+            if (first) {
+                qWarning("QDirectFBKeyboardHandler - Getting unexpected non-keyboard related events");
+                first = false;
+            }
+            break;
+        }
+
         if (input.flags & DIEF_MODIFIERS) {
             if (input.modifiers & DIMM_SHIFT)
                 modifiers |= Qt::ShiftModifier;
@@ -185,31 +201,15 @@ void QDirectFBKeyboardHandlerPrivate::readKeyboardData()
             if (input.modifiers & DIMM_META)
                 modifiers |= Qt::MetaModifier;
         }
-        // Not implemented:
-        // if (input.modifiers & DIMM_SUPER)
-        // if (input.modifiers & DIMM_HYPER)
 
-        if ( !(input.flags & DIEF_KEYSYMBOL) ||
-             !(input.flags & DIEF_KEYID) ||
-             !(input.type & (DIET_KEYPRESS | DIET_KEYRELEASE)) )
-        {
-            static int warningCount = 0;
-            if (!warningCount) {
-                qWarning("QDirectFBKeyboardHandler - Getting unexpected non-keyboard related events");
-                warningCount = 100;
-            }
-            else
-                warningCount--;
-            break;
-        }
 
-        bool press = input.type & DIET_KEYPRESS;
+        const bool press = input.type & DIET_KEYPRESS;
         DFBInputDeviceKeySymbol symbol = input.key_symbol;
         int unicode = -1;
         int keycode = 0;
 
         keycode = keymap()->value(symbol);
-        if (keycode == 0 && DFB_KEY_TYPE(symbol) == DIKT_UNICODE)
+        if (DFB_KEY_TYPE(symbol) == DIKT_UNICODE)
             unicode = symbol;
 
         if (unicode != -1 || keycode != 0) {
@@ -314,6 +314,100 @@ KeyMap::KeyMap()
     insert(DIKS_DEAD_SEMIVOICED_SOUND , Qt::Key_Dead_Semivoiced_Sound);
     insert(DIKS_DEAD_TILDE            , Qt::Key_Dead_Tilde);
     insert(DIKS_DEAD_VOICED_SOUND     , Qt::Key_Dead_Voiced_Sound);
+    insert(DIKS_SPACE                 , Qt::Key_Space);
+    insert(DIKS_EXCLAMATION_MARK      , Qt::Key_Exclam);
+    insert(DIKS_QUOTATION             , Qt::Key_QuoteDbl);
+    insert(DIKS_NUMBER_SIGN           , Qt::Key_NumberSign);
+    insert(DIKS_DOLLAR_SIGN           , Qt::Key_Dollar);
+    insert(DIKS_PERCENT_SIGN          , Qt::Key_Percent);
+    insert(DIKS_AMPERSAND             , Qt::Key_Ampersand);
+    insert(DIKS_APOSTROPHE            , Qt::Key_Apostrophe);
+    insert(DIKS_PARENTHESIS_LEFT      , Qt::Key_ParenLeft);
+    insert(DIKS_PARENTHESIS_RIGHT     , Qt::Key_ParenRight);
+    insert(DIKS_ASTERISK              , Qt::Key_Asterisk);
+    insert(DIKS_PLUS_SIGN             , Qt::Key_Plus);
+    insert(DIKS_COMMA                 , Qt::Key_Comma);
+    insert(DIKS_MINUS_SIGN            , Qt::Key_Minus);
+    insert(DIKS_PERIOD                , Qt::Key_Period);
+    insert(DIKS_SLASH                 , Qt::Key_Slash);
+    insert(DIKS_0                     , Qt::Key_0);
+    insert(DIKS_1                     , Qt::Key_1);
+    insert(DIKS_2                     , Qt::Key_2);
+    insert(DIKS_3                     , Qt::Key_3);
+    insert(DIKS_4                     , Qt::Key_4);
+    insert(DIKS_5                     , Qt::Key_5);
+    insert(DIKS_6                     , Qt::Key_6);
+    insert(DIKS_7                     , Qt::Key_7);
+    insert(DIKS_8                     , Qt::Key_8);
+    insert(DIKS_9                     , Qt::Key_9);
+    insert(DIKS_COLON                 , Qt::Key_Colon);
+    insert(DIKS_SEMICOLON             , Qt::Key_Semicolon);
+    insert(DIKS_LESS_THAN_SIGN        , Qt::Key_Less);
+    insert(DIKS_EQUALS_SIGN           , Qt::Key_Equal);
+    insert(DIKS_GREATER_THAN_SIGN     , Qt::Key_Greater);
+    insert(DIKS_QUESTION_MARK         , Qt::Key_Question);
+    insert(DIKS_AT                    , Qt::Key_At);
+    insert(DIKS_CAPITAL_A             , Qt::Key_A);
+    insert(DIKS_CAPITAL_B             , Qt::Key_B);
+    insert(DIKS_CAPITAL_C             , Qt::Key_C);
+    insert(DIKS_CAPITAL_D             , Qt::Key_D);
+    insert(DIKS_CAPITAL_E             , Qt::Key_E);
+    insert(DIKS_CAPITAL_F             , Qt::Key_F);
+    insert(DIKS_CAPITAL_G             , Qt::Key_G);
+    insert(DIKS_CAPITAL_H             , Qt::Key_H);
+    insert(DIKS_CAPITAL_I             , Qt::Key_I);
+    insert(DIKS_CAPITAL_J             , Qt::Key_J);
+    insert(DIKS_CAPITAL_K             , Qt::Key_K);
+    insert(DIKS_CAPITAL_L             , Qt::Key_L);
+    insert(DIKS_CAPITAL_M             , Qt::Key_M);
+    insert(DIKS_CAPITAL_N             , Qt::Key_N);
+    insert(DIKS_CAPITAL_O             , Qt::Key_O);
+    insert(DIKS_CAPITAL_P             , Qt::Key_P);
+    insert(DIKS_CAPITAL_Q             , Qt::Key_Q);
+    insert(DIKS_CAPITAL_R             , Qt::Key_R);
+    insert(DIKS_CAPITAL_S             , Qt::Key_S);
+    insert(DIKS_CAPITAL_T             , Qt::Key_T);
+    insert(DIKS_CAPITAL_U             , Qt::Key_U);
+    insert(DIKS_CAPITAL_V             , Qt::Key_V);
+    insert(DIKS_CAPITAL_W             , Qt::Key_W);
+    insert(DIKS_CAPITAL_X             , Qt::Key_X);
+    insert(DIKS_CAPITAL_Y             , Qt::Key_Y);
+    insert(DIKS_CAPITAL_Z             , Qt::Key_Z);
+    insert(DIKS_SQUARE_BRACKET_LEFT   , Qt::Key_BracketLeft);
+    insert(DIKS_BACKSLASH             , Qt::Key_Backslash);
+    insert(DIKS_SQUARE_BRACKET_RIGHT  , Qt::Key_BracketRight);
+    insert(DIKS_CIRCUMFLEX_ACCENT     , Qt::Key_AsciiCircum);
+    insert(DIKS_UNDERSCORE            , Qt::Key_Underscore);
+    insert(DIKS_SMALL_A               , Qt::Key_A);
+    insert(DIKS_SMALL_B               , Qt::Key_B);
+    insert(DIKS_SMALL_C               , Qt::Key_C);
+    insert(DIKS_SMALL_D               , Qt::Key_D);
+    insert(DIKS_SMALL_E               , Qt::Key_E);
+    insert(DIKS_SMALL_F               , Qt::Key_F);
+    insert(DIKS_SMALL_G               , Qt::Key_G);
+    insert(DIKS_SMALL_H               , Qt::Key_H);
+    insert(DIKS_SMALL_I               , Qt::Key_I);
+    insert(DIKS_SMALL_J               , Qt::Key_J);
+    insert(DIKS_SMALL_K               , Qt::Key_K);
+    insert(DIKS_SMALL_L               , Qt::Key_L);
+    insert(DIKS_SMALL_M               , Qt::Key_M);
+    insert(DIKS_SMALL_N               , Qt::Key_N);
+    insert(DIKS_SMALL_O               , Qt::Key_O);
+    insert(DIKS_SMALL_P               , Qt::Key_P);
+    insert(DIKS_SMALL_Q               , Qt::Key_Q);
+    insert(DIKS_SMALL_R               , Qt::Key_R);
+    insert(DIKS_SMALL_S               , Qt::Key_S);
+    insert(DIKS_SMALL_T               , Qt::Key_T);
+    insert(DIKS_SMALL_U               , Qt::Key_U);
+    insert(DIKS_SMALL_V               , Qt::Key_V);
+    insert(DIKS_SMALL_W               , Qt::Key_W);
+    insert(DIKS_SMALL_X               , Qt::Key_X);
+    insert(DIKS_SMALL_Y               , Qt::Key_Y);
+    insert(DIKS_SMALL_Z               , Qt::Key_Z);
+    insert(DIKS_CURLY_BRACKET_LEFT    , Qt::Key_BraceLeft);
+    insert(DIKS_VERTICAL_BAR          , Qt::Key_Bar);
+    insert(DIKS_CURLY_BRACKET_RIGHT   , Qt::Key_BraceRight);
+    insert(DIKS_TILDE                 , Qt::Key_AsciiTilde);
 }
 
 #include "qdirectfbkeyboard.moc"
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbmouse.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbmouse.cpp
index f4d9b46..b999dd2 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbmouse.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbmouse.cpp
@@ -56,9 +56,7 @@ public:
     QDirectFBMouseHandlerPrivate(QDirectFBMouseHandler *h);
     ~QDirectFBMouseHandlerPrivate();
 
-    void suspend();
-    void resume();
-
+    void setEnabled(bool on);
 private:
     QDirectFBMouseHandler *handler;
     IDirectFBEventBuffer *eventBuffer;
@@ -130,7 +128,7 @@ QDirectFBMouseHandlerPrivate::QDirectFBMouseHandlerPrivate(QDirectFBMouseHandler
 
     mouseNotifier = new QSocketNotifier(fd, QSocketNotifier::Read, this);
     connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData()));
-    resume();
+    setEnabled(true);
 }
 
 QDirectFBMouseHandlerPrivate::~QDirectFBMouseHandlerPrivate()
@@ -139,15 +137,32 @@ QDirectFBMouseHandlerPrivate::~QDirectFBMouseHandlerPrivate()
         eventBuffer->Release(eventBuffer);
 }
 
-void QDirectFBMouseHandlerPrivate::suspend()
+void QDirectFBMouseHandlerPrivate::setEnabled(bool on)
 {
-    mouseNotifier->setEnabled(false);
-}
+    if (mouseNotifier->isEnabled() != on) {
+#ifndef QT_NO_DIRECTFB_LAYER
+        DFBResult result;
+        result = layer->SetCooperativeLevel(layer, DLSCL_ADMINISTRATIVE);
+        if (result != DFB_OK) {
+            DirectFBError("QDirectFBScreenCursor::QDirectFBScreenCursor: "
+                          "Unable to set cooperative level", result);
+        }
+        result = layer->EnableCursor(layer, on ? 1 : 0);
+        if (result != DFB_OK) {
+            DirectFBError("QDirectFBScreenCursor::QDirectFBScreenCursor: "
+                          "Unable to enable cursor", result);
+        }
 
-void QDirectFBMouseHandlerPrivate::resume()
-{
-    eventBuffer->Reset(eventBuffer);
-    mouseNotifier->setEnabled(true);
+        result = layer->SetCooperativeLevel(layer, DLSCL_SHARED);
+        if (result != DFB_OK) {
+            DirectFBError("QDirectFBScreenCursor::show: "
+                          "Unable to set cooperative level", result);
+        }
+
+        layer->SetCooperativeLevel(layer, DLSCL_SHARED);
+#endif
+        mouseNotifier->setEnabled(on);
+    }
 }
 
 void QDirectFBMouseHandlerPrivate::readMouseData()
@@ -260,12 +275,12 @@ QDirectFBMouseHandler::~QDirectFBMouseHandler()
 
 void QDirectFBMouseHandler::suspend()
 {
-    d->suspend();
+    d->setEnabled(false);
 }
 
 void QDirectFBMouseHandler::resume()
 {
-    d->resume();
+    d->setEnabled(true);
 }
 
 #include "qdirectfbmouse.moc"
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbmouse.h b/src/plugins/gfxdrivers/directfb/qdirectfbmouse.h
index e81a4ba..d2eccfc 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbmouse.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbmouse.h
@@ -61,7 +61,6 @@ public:
 
     void suspend();
     void resume();
-
 protected:
     QDirectFBMouseHandlerPrivate *d;
 };
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
index 2a2ef5c..72e0ce5 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
@@ -56,23 +56,21 @@ IDirectFBSurface *QDirectFBPaintDevice::directFBSurface() const
 }
 
 
-// Locks the dfb surface and creates a QImage (lockedImage) from the pointer
-void QDirectFBPaintDevice::lockDirectFB() {
-
-    if (lockedImage)
-        return; // Already locked
-
-    void *mem;
-    int w, h;
-    DFBResult result = dfbSurface->Lock(dfbSurface, DSLF_WRITE, &mem, &bpl);
-    if (result != DFB_OK || !mem) {
-        DirectFBError("QDirectFBPixmapData::buffer()", result);
-        return;
+void QDirectFBPaintDevice::lockDirectFB(uint flags)
+{
+    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;
+        }
     }
-
-    dfbSurface->GetSize(dfbSurface, &w, &h);
-    lockedImage = new QImage(static_cast<uchar*>(mem), w, h, bpl,
-                             QDirectFBScreen::getImageFormat(dfbSurface));
 }
 
 
@@ -84,15 +82,19 @@ void QDirectFBPaintDevice::unlockDirectFB()
     dfbSurface->Unlock(dfbSurface);
     delete lockedImage;
     lockedImage = 0;
+    mem = 0;
+    lock = 0;
 }
 
 
-void* QDirectFBPaintDevice::memory() const
+void *QDirectFBPaintDevice::memory() const
 {
-    QDirectFBPaintDevice* that = const_cast<QDirectFBPaintDevice*>(this);
-    that->lockDirectFB();
-    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;
 }
 
 
@@ -108,7 +110,7 @@ int QDirectFBPaintDevice::bytesPerLine() const
         // Can only get the stride when we lock the surface
         Q_ASSERT(!lockedImage);
         QDirectFBPaintDevice* that = const_cast<QDirectFBPaintDevice*>(this);
-        that->lockDirectFB();
+        that->lockDirectFB(DSLF_READ);
         Q_ASSERT(bpl != -1);
     }
     return bpl;
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.h b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.h
index a11064b..13f0a8f 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.h
@@ -58,7 +58,7 @@ public:
 
     IDirectFBSurface *directFBSurface() const;
 
-    void lockDirectFB();
+    void lockDirectFB(uint flags);
     void unlockDirectFB();
 
     inline bool forceRasterPrimitives() const { return forceRaster; }
@@ -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())
@@ -76,7 +77,10 @@ protected:
           dfbSurface(0),
           lockedImage(0),
           screen(scr),
-          forceRaster(false) {}
+          forceRaster(false),
+          lock(0),
+          mem(0)
+    {}
 
     inline int dotsPerMeterX() const
     {
@@ -92,6 +96,8 @@ protected:
     QDirectFBScreen *screen;
     int bpl;
     bool forceRaster;
+    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 d9346fd..989a37a 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
@@ -43,7 +43,7 @@
 
 #ifndef QT_NO_DIRECTFB
 
-#include "qdirectfbsurface.h"
+#include "qdirectfbwindowsurface.h"
 #include "qdirectfbscreen.h"
 #include "qdirectfbpixmap.h"
 #include <directfb.h>
@@ -54,6 +54,98 @@
 #include <private/qpixmapdata_p.h>
 #include <private/qpixmap_raster_p.h>
 
+#if defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS || defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS
+#define VOID_ARG() static_cast<bool>(false)
+enum PaintOperation {
+    DRAW_RECTS = 0x0001,
+    DRAW_LINES = 0x0002,
+    DRAW_IMAGE = 0x0004,
+    DRAW_PIXMAP = 0x0008,
+    DRAW_TILED_PIXMAP = 0x0010,
+    STROKE_PATH = 0x0020,
+    DRAW_PATH = 0x0040,
+    DRAW_POINTS = 0x0080,
+    DRAW_ELLIPSE = 0x0100,
+    DRAW_POLYGON = 0x0200,
+    DRAW_TEXT = 0x0400,
+    FILL_PATH = 0x0800,
+    FILL_RECT = 0x1000,
+    DRAW_COLORSPANS = 0x2000,
+    ALL = 0xffff
+};
+#endif
+
+#ifdef QT_DIRECTFB_WARN_ON_RASTERFALLBACKS
+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,
+                               int scale, bool matrixRotShear, bool simplePen,
+                               bool dfbHandledClip, bool forceRasterPrimitives,
+                               const char *nameOne, const T1 &one,
+                               const char *nameTwo, const T2 &two,
+                               const char *nameThree, const T3 &three)
+{
+    QString out;
+    QDebug dbg(&out);
+    dbg << msg << (QByteArray(func) + "()")  << "painting on";
+    if (dev->devType() == QInternal::Widget) {
+        dbg << static_cast<const QWidget*>(dev);
+    } else {
+        dbg << dev << "of type" << dev->devType();
+    }
+
+    dbg << "scale" << scale
+        << "matrixRotShear" << matrixRotShear
+        << "simplePen" << simplePen
+        << "dfbHandledClip" << dfbHandledClip
+        << "forceRasterPrimitives" << forceRasterPrimitives;
+
+    const T1 *t1 = ptr(one);
+    const T2 *t2 = ptr(two);
+    const T3 *t3 = ptr(three);
+
+    if (t1) {
+        dbg << nameOne << *t1;
+        if (t2) {
+            dbg << nameTwo << *t2;
+            if (t3) {
+                dbg << nameThree << *t3;
+            }
+        }
+    }
+    qWarning("%s", qPrintable(out));
+}
+#endif
+
+#if defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS && defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS
+#define RASTERFALLBACK(op, one, two, three)                             \
+    if (op & (QT_DIRECTFB_WARN_ON_RASTERFALLBACKS))                     \
+        rasterFallbackWarn("Disabled raster engine operation",          \
+                           __FUNCTION__, state()->painter->device(),    \
+                           d_func()->scale, d_func()->matrixRotShear, \
+                           d_func()->simplePen, d_func()->dfbCanHandleClip(), \
+                           d_func()->forceRasterPrimitives,             \
+                           #one, one, #two, two, #three, three);        \
+    if (op & (QT_DIRECTFB_DISABLE_RASTERFALLBACKS))                     \
+        return;
+#elif defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS
+#define RASTERFALLBACK(op, one, two, three)             \
+    if (op & (QT_DIRECTFB_DISABLE_RASTERFALLBACKS))     \
+        return;
+#elif defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS
+#define RASTERFALLBACK(op, one, two, three)                             \
+    if (op & (QT_DIRECTFB_WARN_ON_RASTERFALLBACKS))                     \
+        rasterFallbackWarn("Falling back to raster engine for",         \
+                           __FUNCTION__, state()->painter->device(),    \
+                           d_func()->scale, d_func()->matrixRotShear, \
+                           d_func()->simplePen, d_func()->dfbCanHandleClip(), \
+                           d_func()->forceRasterPrimitives,             \
+                           #one, one, #two, two, #three, three);
+#else
+#define RASTERFALLBACK(op, one, two, three)
+#endif
+
 static inline uint ALPHA_MUL(uint x, uint a)
 {
     uint t = x * a;
@@ -64,137 +156,68 @@ static inline uint ALPHA_MUL(uint x, uint a)
 class SurfaceCache
 {
 public:
-    SurfaceCache();
-    ~SurfaceCache();
-
-    inline IDirectFBSurface *getSurface(const uint *buffer, int size);
-    inline void clear();
-
-private:
-    IDirectFBSurface *surface;
-    uint *buffer;
-    int bufsize;
-};
+    SurfaceCache() : surface(0), buffer(0), bufsize(0) {}
+    ~SurfaceCache() { clear(); }
 
-SurfaceCache::SurfaceCache()
-    : surface(0), buffer(0), bufsize(0)
-{
-}
 
-class CachedImage
-{
-public:
-    CachedImage(const QImage &image);
-    ~CachedImage();
+    IDirectFBSurface *getSurface(const uint *buf, int size)
+    {
+        if (buffer == buf && bufsize == size)
+            return surface;
 
-    IDirectFBSurface *surface() { return s; }
+        clear();
 
-private:
-    IDirectFBSurface *s;
-};
+        const DFBSurfaceDescription description = QDirectFBScreen::getSurfaceDescription(buf, size);
+        surface = QDirectFBScreen::instance()->createDFBSurface(description, QDirectFBScreen::TrackSurface);
+        if (!surface)
+            qWarning("QDirectFBPaintEngine: SurfaceCache: Unable to create surface");
 
-CachedImage::CachedImage(const QImage &image)
-    : s(0)
-{
-    IDirectFBSurface *tmpSurface = 0;
-    DFBSurfaceDescription description;
-    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();
-
-    DFBSurfaceDescription description;
-    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
 {
 public:
+    enum Scale { NoScale, Scaled, NegativeScale };
+
     QDirectFBPaintEnginePrivate(QDirectFBPaintEngine *p);
     ~QDirectFBPaintEnginePrivate();
 
-    IDirectFBSurface *surface;
-
-    QPen pen;
-    QBrush brush;
-
-    bool antialiased;
-    bool forceRasterPrimitives;
-
-    bool simplePen;
-    bool simpleBrush;
-
-    bool matrixRotShear;
-    bool matrixScale;
-
     void setTransform(const QTransform &m);
     void setPen(const QPen &pen);
-    void setBrush(const QBrush &brush);
     void setCompositionMode(QPainter::CompositionMode mode);
     void setOpacity(quint8 value);
     void setRenderHints(QPainter::RenderHints hints);
@@ -207,35 +230,51 @@ public:
     inline bool dfbCanHandleClip(const QRect &rect) const;
     inline bool dfbCanHandleClip(const QRectF &rect) const;
     inline bool dfbCanHandleClip() const;
+    inline bool isSimpleBrush(const QBrush &brush) const;
 
-    void drawLines(const QLine *lines, int count) const;
-    void drawLines(const QLineF *lines, int count) const;
+    void drawLines(const QLine *lines, int count);
+    void drawLines(const QLineF *lines, int count);
 
-    void fillRegion(const QRegion &r) const;
-    void fillRects(const QRect *rects, int count) const;
-    void drawRects(const QRect *rects, int count) const;
-    void fillRects(const QRectF *rects, int count) const;
-    void drawRects(const QRectF *rects, int count) const;
+    void fillRegion(const QRegion &r);
+    void fillRects(const QRect *rects, int count);
+    void drawRects(const QRect *rects, int count);
+    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;
+    Scale scale;
+
     SurfaceCache *surfaceCache;
     QTransform transform;
     int lastLockedHeight;
-private:
+
     IDirectFB *fb;
-    DFBSurfaceDescription fbDescription;
     int fbWidth;
     int fbHeight;
 
@@ -246,470 +285,14 @@ private:
 
     bool dirtyClip;
     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),
-      simpleBrush(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();
-    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;
-}
-
-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::setBrush(const QBrush &b)
-{
-    brush = b;
-    simpleBrush = (brush.style() == Qt::NoBrush) ||
-                  (brush.style() == Qt::SolidPattern && !antialiased);
-}
-
-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) const
-{
-    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) const
-{
-    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) const
-{
-    const QVector<QRect> rects = region.rects();
-    const int n = rects.size();
-    fillRects(rects.constData(), n);
-}
-
-void QDirectFBPaintEnginePrivate::fillRects(const QRect *rects, int n) const
-{
-    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) const
-{
-    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) const
-{
-    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) const
-{
-    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;
-
-            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;
-
-    if (!clip() || !clip()->enabled) {
-        surface->SetClip(surface, NULL);
-        dfbHandledClip = true;
-    }
-    else if (clip()->hasRectClip) {
-        const DFBRegion r = {
-            clip()->clipRect.x(),
-            clip()->clipRect.y(),
-            clip()->clipRect.x() + clip()->clipRect.width(),
-            clip()->clipRect.y() + clip()->clipRect.height()
-        };
-        surface->SetClip(surface, &r);
-
-        dfbHandledClip = true;
-    }
-    else
-        dfbHandledClip = false;
-
-    dirtyClip = false;
-}
-
-void QDirectFBPaintEnginePrivate::systemStateChanged()
-{
-    setClipDirty();
-    QRasterPaintEnginePrivate::systemStateChanged();
-}
-
 QDirectFBPaintEngine::QDirectFBPaintEngine(QPaintDevice *device)
     : QRasterPaintEngine(*(new QDirectFBPaintEnginePrivate(this)), device)
 {
@@ -738,12 +321,10 @@ bool QDirectFBPaintEngine::end()
     return QRasterPaintEngine::end();
 }
 
-
-
 void QDirectFBPaintEngine::clipEnabledChanged()
 {
     Q_D(QDirectFBPaintEngine);
-    d->setClipDirty();
+    d->dirtyClip = true;
     QRasterPaintEngine::clipEnabledChanged();
 }
 
@@ -755,14 +336,6 @@ void QDirectFBPaintEngine::penChanged()
     QRasterPaintEngine::penChanged();
 }
 
-void QDirectFBPaintEngine::brushChanged()
-{
-    Q_D(QDirectFBPaintEngine);
-    d->setBrush(state()->brush);
-
-    QRasterPaintEngine::brushChanged();
-}
-
 void QDirectFBPaintEngine::opacityChanged()
 {
     Q_D(QDirectFBPaintEngine);
@@ -787,9 +360,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();
@@ -799,9 +372,8 @@ void QDirectFBPaintEngine::setState(QPainterState *s)
 {
     Q_D(QDirectFBPaintEngine);
     QRasterPaintEngine::setState(s);
-    d->setClipDirty();
+    d->dirtyClip = true;
     d->setPen(state()->pen);
-    d->setBrush(state()->brush);
     d->setOpacity(quint8(state()->opacity * 255));
     d->setCompositionMode(state()->compositionMode());
     d->setTransform(state()->transform());
@@ -810,7 +382,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();
@@ -820,8 +392,8 @@ void QDirectFBPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
 void QDirectFBPaintEngine::clip(const QRect &rect, Qt::ClipOperation op)
 {
     Q_D(QDirectFBPaintEngine);
-    d->setClipDirty();
-    if (!d->clip()->hasRectClip && d->clip()->enabled) {
+    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)
             d->lock();
@@ -834,8 +406,11 @@ void QDirectFBPaintEngine::drawRects(const QRect *rects, int rectCount)
 {
     Q_D(QDirectFBPaintEngine);
     d->updateClip();
-    if (!d->dfbCanHandleClip() || d->matrixRotShear || !d->simpleBrush
-        || !d->simplePen || d->forceRasterPrimitives) {
+    const QBrush &brush = state()->brush;
+    if (!d->dfbCanHandleClip() || d->matrixRotShear
+        || !d->simplePen || d->forceRasterPrimitives
+        || !d->isSimpleBrush(brush)) {
+        RASTERFALLBACK(DRAW_RECTS, rectCount, VOID_ARG(), VOID_ARG());
         d->lock();
         QRasterPaintEngine::drawRects(rects, rectCount);
         return;
@@ -843,8 +418,8 @@ void QDirectFBPaintEngine::drawRects(const QRect *rects, int rectCount)
 
     d->unlock();
 
-    if (d->brush != Qt::NoBrush) {
-        d->setDFBColor(d->brush.color());
+    if (brush != Qt::NoBrush) {
+        d->setDFBColor(brush.color());
         d->fillRects(rects, rectCount);
     }
     if (d->pen != Qt::NoPen) {
@@ -857,8 +432,11 @@ void QDirectFBPaintEngine::drawRects(const QRectF *rects, int rectCount)
 {
     Q_D(QDirectFBPaintEngine);
     d->updateClip();
-    if (!d->dfbCanHandleClip() || d->matrixRotShear || !d->simpleBrush
-        || !d->simplePen || d->forceRasterPrimitives) {
+    const QBrush &brush = state()->brush;
+    if (!d->dfbCanHandleClip() || d->matrixRotShear
+        || !d->simplePen || d->forceRasterPrimitives
+        || !d->isSimpleBrush(brush)) {
+        RASTERFALLBACK(DRAW_RECTS, rectCount, VOID_ARG(), VOID_ARG());
         d->lock();
         QRasterPaintEngine::drawRects(rects, rectCount);
         return;
@@ -866,8 +444,8 @@ void QDirectFBPaintEngine::drawRects(const QRectF *rects, int rectCount)
 
     d->unlock();
 
-    if (d->brush != Qt::NoBrush) {
-        d->setDFBColor(d->brush.color());
+    if (brush != Qt::NoBrush) {
+        d->setDFBColor(brush.color());
         d->fillRects(rects, rectCount);
     }
     if (d->pen != Qt::NoPen) {
@@ -881,6 +459,7 @@ void QDirectFBPaintEngine::drawLines(const QLine *lines, int lineCount)
     Q_D(QDirectFBPaintEngine);
     d->updateClip();
     if (!d->simplePen || !d->dfbCanHandleClip() || d->forceRasterPrimitives) {
+        RASTERFALLBACK(DRAW_LINES, lineCount, VOID_ARG(), VOID_ARG());
         d->lock();
         QRasterPaintEngine::drawLines(lines, lineCount);
         return;
@@ -898,6 +477,7 @@ void QDirectFBPaintEngine::drawLines(const QLineF *lines, int lineCount)
     Q_D(QDirectFBPaintEngine);
     d->updateClip();
     if (!d->simplePen || !d->dfbCanHandleClip() || d->forceRasterPrimitives) {
+        RASTERFALLBACK(DRAW_LINES, lineCount, VOID_ARG(), VOID_ARG());
         d->lock();
         QRasterPaintEngine::drawLines(lines, lineCount);
         return;
@@ -915,22 +495,53 @@ 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);
         d->lock();
         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
 }
 
@@ -946,15 +557,23 @@ void QDirectFBPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pixmap,
     d->updateClip();
 
     if (pixmap.pixmapData()->classId() != QPixmapData::DirectFBClass) {
+        RASTERFALLBACK(DRAW_PIXMAP, r, pixmap.size(), sr);
         d->lock();
         QRasterPaintEngine::drawPixmap(r, pixmap, sr);
-    } else if (!d->dfbCanHandleClip(r) || d->matrixRotShear) {
-        const QImage *img = static_cast<QDirectFBPixmapData*>(pixmap.pixmapData())->buffer();
+    } 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);
     }
 }
 
@@ -970,10 +589,13 @@ void QDirectFBPaintEngine::drawTiledPixmap(const QRectF &r,
     Q_D(QDirectFBPaintEngine);
     d->updateClip();
     if (pixmap.pixmapData()->classId() != QPixmapData::DirectFBClass) {
+        RASTERFALLBACK(DRAW_TILED_PIXMAP, r, pixmap.size(), sp);
         d->lock();
         QRasterPaintEngine::drawTiledPixmap(r, pixmap, sp);
-    } else if (!d->dfbCanHandleClip(r) || d->matrixRotShear || !sp.isNull()) {
-        const QImage *img = static_cast<QDirectFBPixmapData*>(pixmap.pixmapData())->buffer();
+    } 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();
         QRasterPixmapData *data = new QRasterPixmapData(QPixmapData::PixmapType);
         data->fromImage(*img, Qt::AutoColor);
@@ -988,6 +610,7 @@ void QDirectFBPaintEngine::drawTiledPixmap(const QRectF &r,
 
 void QDirectFBPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
 {
+    RASTERFALLBACK(STROKE_PATH, path, VOID_ARG(), VOID_ARG());
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::stroke(path, pen);
@@ -995,6 +618,7 @@ void QDirectFBPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
 
 void QDirectFBPaintEngine::drawPath(const QPainterPath &path)
 {
+    RASTERFALLBACK(DRAW_PATH, path, VOID_ARG(), VOID_ARG());
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawPath(path);
@@ -1002,6 +626,7 @@ void QDirectFBPaintEngine::drawPath(const QPainterPath &path)
 
 void QDirectFBPaintEngine::drawPoints(const QPointF *points, int pointCount)
 {
+    RASTERFALLBACK(DRAW_POINTS, pointCount, VOID_ARG(), VOID_ARG());
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawPoints(points, pointCount);
@@ -1009,6 +634,7 @@ void QDirectFBPaintEngine::drawPoints(const QPointF *points, int pointCount)
 
 void QDirectFBPaintEngine::drawPoints(const QPoint *points, int pointCount)
 {
+    RASTERFALLBACK(DRAW_POINTS, pointCount, VOID_ARG(), VOID_ARG());
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawPoints(points, pointCount);
@@ -1016,6 +642,7 @@ void QDirectFBPaintEngine::drawPoints(const QPoint *points, int pointCount)
 
 void QDirectFBPaintEngine::drawEllipse(const QRectF &rect)
 {
+    RASTERFALLBACK(DRAW_ELLIPSE, rect, VOID_ARG(), VOID_ARG());
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawEllipse(rect);
@@ -1024,6 +651,7 @@ void QDirectFBPaintEngine::drawEllipse(const QRectF &rect)
 void QDirectFBPaintEngine::drawPolygon(const QPointF *points, int pointCount,
                                        PolygonDrawMode mode)
 {
+    RASTERFALLBACK(DRAW_POLYGON, pointCount, mode, VOID_ARG());
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawPolygon(points, pointCount, mode);
@@ -1032,6 +660,7 @@ void QDirectFBPaintEngine::drawPolygon(const QPointF *points, int pointCount,
 void QDirectFBPaintEngine::drawPolygon(const QPoint *points, int pointCount,
                                        PolygonDrawMode mode)
 {
+    RASTERFALLBACK(DRAW_POLYGON, pointCount, mode, VOID_ARG());
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawPolygon(points, pointCount, mode);
@@ -1040,6 +669,7 @@ void QDirectFBPaintEngine::drawPolygon(const QPoint *points, int pointCount,
 void QDirectFBPaintEngine::drawTextItem(const QPointF &p,
                                         const QTextItem &textItem)
 {
+    RASTERFALLBACK(DRAW_TEXT, p, textItem.text(), VOID_ARG());
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawTextItem(p, textItem);
@@ -1047,6 +677,7 @@ void QDirectFBPaintEngine::drawTextItem(const QPointF &p,
 
 void QDirectFBPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
 {
+    RASTERFALLBACK(FILL_PATH, path, brush, VOID_ARG());
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::fill(path, brush);
@@ -1080,6 +711,7 @@ void QDirectFBPaintEngine::fillRect(const QRectF &rect, const QBrush &brush)
             break;
         }
     }
+    RASTERFALLBACK(FILL_RECT, rect, brush, VOID_ARG());
     d->lock();
     QRasterPaintEngine::fillRect(rect, brush);
 }
@@ -1089,6 +721,7 @@ void QDirectFBPaintEngine::fillRect(const QRectF &rect, const QColor &color)
     Q_D(QDirectFBPaintEngine);
     d->updateClip();
     if (!d->dfbCanHandleClip() || d->matrixRotShear || d->forceRasterPrimitives) {
+        RASTERFALLBACK(FILL_RECT, rect, color, VOID_ARG());
         d->lock();
         QRasterPaintEngine::fillRect(rect, color);
     } else {
@@ -1105,6 +738,7 @@ void QDirectFBPaintEngine::drawColorSpans(const QSpan *spans, int count,
 {
     Q_D(QDirectFBPaintEngine);
     if (d->forceRasterPrimitives) {
+        RASTERFALLBACK(DRAW_COLORSPANS, count, color, VOID_ARG());
         d->lock();
         QRasterPaintEngine::drawColorSpans(spans, count, color);
     } else {
@@ -1149,4 +783,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 3c2cefa..d33255b 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h
@@ -96,7 +96,6 @@ public:
 
     virtual void clipEnabledChanged();
     virtual void penChanged();
-    virtual void brushChanged();
     virtual void opacityChanged();
     virtual void compositionModeChanged();
     virtual void renderHintsChanged();
@@ -107,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 0a1696a..c9b676a 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
@@ -157,13 +157,26 @@ static bool checkForAlphaPixels(const QImage &img)
     return false;
 }
 
-void QDirectFBPixmapData::fromImage(const QImage &img,
+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)
 {
-    Q_ASSERT(img.depth() != 1); // these should be handled by QRasterPixmapData
+#ifdef QT_NO_DIRECTFB_OPAQUE_DETECTION
+    Q_UNUSED(flags);
+#endif
+    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;
@@ -258,7 +271,7 @@ void QDirectFBPixmapData::fill(const QColor &color)
         forceRaster = false;
         setSerialNumber(++global_ser_no);
         if (!dfbSurface) {
-            qWarning("QDirecttFBPixmapData::fill()");
+            qWarning("QDirectFBPixmapData::fill()");
             invalidate();
             return;
         }
@@ -267,16 +280,17 @@ void QDirectFBPixmapData::fill(const QColor &color)
     if (forceRaster) {
         // in DSPF_RGB32 all dfb drawing causes the Alpha byte to be
         // set to 0. This causes issues for the raster engine.
-        char *mem;
-        int bpl;
-        const int h = QPixmapData::height();
-        dfbSurface->Lock(dfbSurface, DSLF_WRITE, (void**)&mem, &bpl);
-        const int c = color.rgba();
-        for (int i = 0; i < h; ++i) {
-            memset(mem, c, bpl);
-            mem += bpl;
+        uchar *mem = QDirectFBScreen::lockSurface(dfbSurface, DSLF_WRITE, &bpl);
+        if (mem) {
+            const int h = QPixmapData::height();
+            const int w = QPixmapData::width() * 4; // 4 bytes per 32 bit pixel
+            const int c = color.rgba();
+            for (int i = 0; i < h; ++i) {
+                memset(mem, c, w);
+                mem += bpl;
+            }
+            dfbSurface->Unlock(dfbSurface);
         }
-        dfbSurface->Unlock(dfbSurface);
     } else {
         dfbSurface->Clear(dfbSurface, color.red(), color.green(), color.blue(),
                           color.alpha());
@@ -353,7 +367,7 @@ QImage QDirectFBPixmapData::toImage() const
     return img->copy();
 }
 
-QPaintEngine* QDirectFBPixmapData::paintEngine() const
+QPaintEngine *QDirectFBPixmapData::paintEngine() const
 {
     if (!engine) {
         // QDirectFBPixmapData is also a QCustomRasterPaintDevice, so pass
@@ -364,10 +378,15 @@ QPaintEngine* QDirectFBPixmapData::paintEngine() const
     return engine;
 }
 
+QImage *QDirectFBPixmapData::buffer()
+{
+    lockDirectFB(DSLF_READ|DSLF_WRITE);
+    return lockedImage;
+}
 
-QImage* QDirectFBPixmapData::buffer()
+QImage * QDirectFBPixmapData::buffer(uint lockFlags)
 {
-    lockDirectFB();
+    lockDirectFB(lockFlags);
     return lockedImage;
 }
 
@@ -377,3 +396,4 @@ void QDirectFBPixmapData::invalidate()
     alpha = false;
     format = QImage::Format_Invalid;
 }
+
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.h b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.h
index 6cfafcd..7cd60d6 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.h
@@ -69,11 +69,13 @@ public:
                         Qt::TransformationMode mode) const;
     QImage toImage() const;
     QPaintEngine* paintEngine() const;
-    QImage *buffer();
+    virtual QImage *buffer();
+    QImage *buffer(uint lockFlags);
 
     // 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 041d522..65fddbf 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
@@ -40,7 +40,7 @@
 ****************************************************************************/
 
 #include "qdirectfbscreen.h"
-#include "qdirectfbsurface.h"
+#include "qdirectfbwindowsurface.h"
 #include "qdirectfbpixmap.h"
 #include "qdirectfbmouse.h"
 #include "qdirectfbkeyboard.h"
@@ -80,11 +80,11 @@ public:
 #ifndef QT_NO_DIRECTFB_KEYBOARD
     QDirectFBKeyboardHandler *keyboard;
 #endif
-    bool videoonly;
+    QDirectFBScreen::DirectFBFlags directFBFlags;
     QImage::Format alphaPixmapFormat;
 };
 
-QDirectFBScreenPrivate::QDirectFBScreenPrivate(QDirectFBScreen* screen)
+QDirectFBScreenPrivate::QDirectFBScreenPrivate(QDirectFBScreen *screen)
     : QWSGraphicsSystem(screen), dfb(0), dfbSurface(0), flipFlags(DSFLIP_NONE)
 #ifndef QT_NO_DIRECTFB_LAYER
     , dfbLayer(0)
@@ -96,7 +96,7 @@ QDirectFBScreenPrivate::QDirectFBScreenPrivate(QDirectFBScreen* screen)
 #ifndef QT_NO_DIRECTFB_KEYBOARD
     , keyboard(0)
 #endif
-    , videoonly(false)
+    , directFBFlags(QDirectFBScreen::NoFlags)
     , alphaPixmapFormat(QImage::Format_Invalid)
 {
 #ifndef QT_NO_QWS_SIGNALHANDLER
@@ -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);
@@ -137,7 +137,7 @@ QDirectFBScreenPrivate::~QDirectFBScreenPrivate()
 // creates a preallocated surface with the same format as the image if
 // possible.
 
-IDirectFBSurface* QDirectFBScreen::createDFBSurface(const QImage &img, SurfaceCreationOptions options)
+IDirectFBSurface *QDirectFBScreen::createDFBSurface(const QImage &img, SurfaceCreationOptions options)
 {
     if (img.isNull()) // assert?
         return 0;
@@ -155,19 +155,20 @@ IDirectFBSurface* QDirectFBScreen::createDFBSurface(const QImage &img, SurfaceCr
         return surface;
     }
 
-    DFBSurfaceDescription desc = QDirectFBScreen::getSurfaceDescription(img);
-    IDirectFBSurface *surface = createDFBSurface(&desc, options);
+    IDirectFBSurface *surface = createDFBSurface(QDirectFBScreen::getSurfaceDescription(img), options);
 #ifdef QT_NO_DIRECTFB_PREALLOCATED
     if (surface) {
-        char *mem;
         int bpl;
-        surface->Lock(surface, DSLF_WRITE, (void**)&mem, &bpl);
-        const int h = img.height();
-        for (int i = 0; i < h; ++i) {
-            memcpy(mem, img.scanLine(i), bpl);
-            mem += bpl;
+        uchar *mem = QDirectFBScreen::lockSurface(surface, DSLF_WRITE, &bpl);
+        if (mem) {
+            const int h = img.height();
+            const int w = img.width() * img.depth() / 8;
+            for (int i = 0; i < h; ++i) {
+                memcpy(mem, img.scanLine(i), w);
+                mem += bpl;
+            }
+            surface->Unlock(surface);
         }
-        surface->Unlock(surface);
     }
 #endif
 #ifndef QT_NO_DIRECTFB_PALETTE
@@ -204,58 +205,61 @@ IDirectFBSurface *QDirectFBScreen::createDFBSurface(const QSize &size,
                                                     SurfaceCreationOptions options)
 {
     DFBSurfaceDescription desc;
+    memset(&desc, 0, sizeof(DFBSurfaceDescription));
     desc.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH|DSDESC_HEIGHT);
     if (!QDirectFBScreen::initSurfaceDescriptionPixelFormat(&desc, format))
         return 0;
     desc.width = size.width();
     desc.height = size.height();
-    return createDFBSurface(&desc, options);
+    return createDFBSurface(desc, options);
 }
 
-
-IDirectFBSurface* QDirectFBScreen::createDFBSurface(const DFBSurfaceDescription *desc, SurfaceCreationOptions options)
+IDirectFBSurface *QDirectFBScreen::createDFBSurface(DFBSurfaceDescription desc, SurfaceCreationOptions options)
 {
-    DFBResult result;
-    IDirectFBSurface* newSurface = 0;
+    DFBResult result = DFB_OK;
+    IDirectFBSurface *newSurface = 0;
 
     if (!d_ptr->dfb) {
         qWarning("QDirectFBScreen::createDFBSurface() - not connected");
         return 0;
     }
 
-    if (d_ptr->videoonly && !(desc->flags & DSDESC_PREALLOCATED)) {
+    if (d_ptr->directFBFlags & VideoOnly && !(desc.flags & DSDESC_PREALLOCATED)) {
         // Add the video only capability. This means the surface will be created in video ram
-        DFBSurfaceDescription voDesc = *desc;
-        if (!(voDesc.flags & DSDESC_CAPS)) {
-            voDesc.caps = DSCAPS_VIDEOONLY;
-            voDesc.flags = DFBSurfaceDescriptionFlags(voDesc.flags | DSDESC_CAPS);
+        if (!(desc.flags & DSDESC_CAPS)) {
+            desc.caps = DSCAPS_VIDEOONLY;
+            desc.flags = DFBSurfaceDescriptionFlags(desc.flags | DSDESC_CAPS);
         } else {
-            voDesc.caps = DFBSurfaceCapabilities(voDesc.caps | DSCAPS_VIDEOONLY);
+            desc.caps = DFBSurfaceCapabilities(desc.caps | DSCAPS_VIDEOONLY);
         }
-        result = d_ptr->dfb->CreateSurface(d_ptr->dfb, &voDesc, &newSurface);
+        result = d_ptr->dfb->CreateSurface(d_ptr->dfb, &desc, &newSurface);
         if (result != DFB_OK
 #ifdef QT_NO_DEBUG
-            && (desc->flags & DSDESC_CAPS) && (desc->caps & DSCAPS_PRIMARY)
+            && (desc.flags & DSDESC_CAPS) && (desc.caps & DSCAPS_PRIMARY)
 #endif
             ) {
             qWarning("QDirectFBScreen::createDFBSurface() Failed to create surface in video memory!\n"
                      "   Flags %0x Caps %0x width %d height %d pixelformat %0x %d preallocated %p %d\n%s",
-                     desc->flags, desc->caps, desc->width, desc->height,
-                     desc->pixelformat, DFB_PIXELFORMAT_INDEX(desc->pixelformat),
-                     desc->preallocated[0].data, desc->preallocated[0].pitch,
+                     desc.flags, desc.caps, desc.width, desc.height,
+                     desc.pixelformat, DFB_PIXELFORMAT_INDEX(desc.pixelformat),
+                     desc.preallocated[0].data, desc.preallocated[0].pitch,
                      DirectFBErrorString(result));
         }
+        desc.caps = DFBSurfaceCapabilities(desc.caps & ~DSCAPS_VIDEOONLY);
     }
 
+    if (d_ptr->directFBFlags & SystemOnly)
+        desc.caps = DFBSurfaceCapabilities(desc.caps | DSCAPS_SYSTEMONLY);
+
     if (!newSurface)
-        result = d_ptr->dfb->CreateSurface(d_ptr->dfb, desc, &newSurface);
+        result = d_ptr->dfb->CreateSurface(d_ptr->dfb, &desc, &newSurface);
 
     if (result != DFB_OK) {
         qWarning("QDirectFBScreen::createDFBSurface() Failed!\n"
                  "   Flags %0x Caps %0x width %d height %d pixelformat %0x %d preallocated %p %d\n%s",
-                 desc->flags, desc->caps, desc->width, desc->height,
-                 desc->pixelformat, DFB_PIXELFORMAT_INDEX(desc->pixelformat),
-                 desc->preallocated[0].data, desc->preallocated[0].pitch,
+                 desc.flags, desc.caps, desc.width, desc.height,
+                 desc.pixelformat, DFB_PIXELFORMAT_INDEX(desc.pixelformat),
+                 desc.preallocated[0].data, desc.preallocated[0].pitch,
                  DirectFBErrorString(result));
         return 0;
     }
@@ -317,15 +321,17 @@ IDirectFBSurface *QDirectFBScreen::copyToDFBSurface(const QImage &img,
     imgSurface->Release(imgSurface);
 #else // QT_NO_DIRECTFB_PREALLOCATED
     Q_ASSERT(image.format() == pixmapFormat);
-    char *mem;
     int bpl;
-    dfbSurface->Lock(dfbSurface, DSLF_WRITE, (void**)&mem, &bpl);
-    const int w = image.width() * image.depth() / 8;
-    for (int i = 0; i < image.height(); ++i) {
-        memcpy(mem, image.scanLine(i), w);
-        mem += bpl;
+    uchar *mem = QDirectFBScreen::lockSurface(dfbSurface, DSLF_WRITE, &bpl);
+    if (mem) {
+        const int h = image.height();
+        const int w = image.width() * image.depth() / 8;
+        for (int i=0; i<h; ++i) {
+            memcpy(mem, image.scanLine(i), w);
+            mem += bpl;
+        }
+        dfbSurface->Unlock(dfbSurface);
     }
-    dfbSurface->Unlock(dfbSurface);
 #endif
     return dfbSurface;
 }
@@ -341,23 +347,23 @@ void QDirectFBScreen::releaseDFBSurface(IDirectFBSurface *surface)
     //qDebug("Released surface at %p. New count = %d", surface, d_ptr->allocatedSurfaces.count());
 }
 
-bool QDirectFBScreen::preferVideoOnly() const
+QDirectFBScreen::DirectFBFlags QDirectFBScreen::directFBFlags() const
 {
-    return d_ptr->videoonly;
+    return d_ptr->directFBFlags;
 }
 
-IDirectFB* QDirectFBScreen::dfb()
+IDirectFB *QDirectFBScreen::dfb()
 {
     return d_ptr->dfb;
 }
 
-IDirectFBSurface* QDirectFBScreen::dfbSurface()
+IDirectFBSurface *QDirectFBScreen::dfbSurface()
 {
     return d_ptr->dfbSurface;
 }
 
 #ifndef QT_NO_DIRECTFB_LAYER
-IDirectFBDisplayLayer* QDirectFBScreen::dfbDisplayLayer()
+IDirectFBDisplayLayer *QDirectFBScreen::dfbDisplayLayer()
 {
     return d_ptr->dfbLayer;
 }
@@ -440,6 +446,7 @@ QImage::Format QDirectFBScreen::getImageFormat(IDirectFBSurface *surface)
 DFBSurfaceDescription QDirectFBScreen::getSurfaceDescription(const QImage &image)
 {
     DFBSurfaceDescription description;
+    memset(&description, 0, sizeof(DFBSurfaceDescription));
 
     const DFBSurfacePixelFormat format = getSurfacePixelFormat(image.format());
 
@@ -474,6 +481,7 @@ DFBSurfaceDescription QDirectFBScreen::getSurfaceDescription(const uint *buffer,
                                                              int length)
 {
     DFBSurfaceDescription description;
+    memset(&description, 0, sizeof(DFBSurfaceDescription));
 
     description.flags = DFBSurfaceDescriptionFlags(DSDESC_CAPS
                                                    | DSDESC_WIDTH
@@ -535,16 +543,12 @@ class Q_GUI_EXPORT QDirectFBScreenCursor : public QScreenCursor
 {
 public:
     QDirectFBScreenCursor();
-    ~QDirectFBScreenCursor();
-
-    void set(const QImage &image, int hotx, int hoty);
-    void move(int x, int y);
-    void show();
-    void hide();
-
+    virtual void set(const QImage &image, int hotx, int hoty);
+    virtual void move(int x, int y);
+    virtual void show();
+    virtual void hide();
 private:
     IDirectFBDisplayLayer *layer;
-    bool implicitHide;
 };
 
 QDirectFBScreenCursor::QDirectFBScreenCursor()
@@ -554,116 +558,101 @@ QDirectFBScreenCursor::QDirectFBScreenCursor()
         qFatal("QDirectFBScreenCursor: DirectFB not initialized");
 
     layer = QDirectFBScreen::instance()->dfbDisplayLayer();
+    Q_ASSERT(layer);
 
-    if (layer)
-        layer->SetCooperativeLevel(layer, DLSCL_SHARED); // XXX: hw: remove?
-    else
-        qFatal("QDirectFBScreenCursor: Unable to get primary display layer!");
-
-    enable = true;
+    enable = false;
     hwaccel = true;
-    implicitHide = false;
     supportsAlpha = true;
-
-    set(QImage(), 0, 0);
 }
 
-QDirectFBScreenCursor::~QDirectFBScreenCursor()
-{
-}
-
-void QDirectFBScreenCursor::show()
+void QDirectFBScreenCursor::move(int x, int y)
 {
-    DFBResult result;
-    result = layer->SetCooperativeLevel(layer, DLSCL_ADMINISTRATIVE);
-    if (result != DFB_OK) {
-        DirectFBError("QDirectFBScreenCursor::show: "
-                      "Unable to set cooperative level", result);
-    }
-    result = layer->EnableCursor(layer, 1);
-    if (result != DFB_OK) {
-        DirectFBError("QDirectFBScreenCursor::show: "
-                      "Unable to enable cursor", result);
-    }
-    result = layer->SetCooperativeLevel(layer, DLSCL_SHARED);
-    if (result != DFB_OK) {
-        DirectFBError("QDirectFBScreenCursor::show: "
-                      "Unable to reset cooperative level", result);
-    }
-    implicitHide = false;
+    layer->WarpCursor(layer, x, y);
 }
 
 void QDirectFBScreenCursor::hide()
 {
-    DFBResult result;
-    result = layer->SetCooperativeLevel(layer, DLSCL_ADMINISTRATIVE);
-    if (result != DFB_OK) {
-        DirectFBError("QDirectFBScreenCursor::hide: "
-                      "Unable to set cooperative level", result);
-    }
-    result = layer->EnableCursor(layer, 0);
-    if (result != DFB_OK) {
-        DirectFBError("QDirectFBScreenCursor::hide: "
-                      "Unable to disable cursor", result);
-    }
-    result = layer->SetCooperativeLevel(layer, DLSCL_SHARED);
-    if (result != DFB_OK) {
-        DirectFBError("QDirectFBScreenCursor::hide: "
-                      "Unable to reset cooperative level", result);
+    if (enable) {
+        enable = false;
+        DFBResult result;
+        result = layer->SetCooperativeLevel(layer, DLSCL_ADMINISTRATIVE);
+        if (result != DFB_OK) {
+            DirectFBError("QDirectFBScreenCursor::hide: "
+                          "Unable to set cooperative level", result);
+        }
+        result = layer->SetCursorOpacity(layer, 0);
+        if (result != DFB_OK) {
+            DirectFBError("QDirectFBScreenCursor::hide: "
+                          "Unable to set cursor opacity", result);
+        }
+        result = layer->SetCooperativeLevel(layer, DLSCL_SHARED);
+        if (result != DFB_OK) {
+            DirectFBError("QDirectFBScreenCursor::hide: "
+                          "Unable to set cooperative level", result);
+        }
     }
-    implicitHide = true;
 }
 
-void QDirectFBScreenCursor::move(int x, int y)
+void QDirectFBScreenCursor::show()
 {
-    layer->WarpCursor(layer, x, y);
+    if (!enable) {
+        enable = true;
+        DFBResult result;
+        result = layer->SetCooperativeLevel(layer, DLSCL_ADMINISTRATIVE);
+        if (result != DFB_OK) {
+            DirectFBError("QDirectFBScreenCursor::show: "
+                          "Unable to set cooperative level", result);
+        }
+        result = layer->SetCursorOpacity(layer, 255);
+        if (result != DFB_OK) {
+            DirectFBError("QDirectFBScreenCursor::show: "
+                          "Unable to set cursor shape", result);
+        }
+        result = layer->SetCooperativeLevel(layer, DLSCL_SHARED);
+        if (result != DFB_OK) {
+            DirectFBError("QDirectFBScreenCursor::show: "
+                          "Unable to set cooperative level", result);
+        }
+    }
 }
 
 void QDirectFBScreenCursor::set(const QImage &image, int hotx, int hoty)
 {
-    if (image.isNull() && isVisible()) {
-        hide();
-        implicitHide = true;
-    } else if (!image.isNull() && implicitHide) {
-        show();
-    }
-    cursor = image.convertToFormat(QDirectFBScreen::instance()->alphaPixmapFormat());
+    QDirectFBScreen *screen = QDirectFBScreen::instance();
+    if (!screen)
+        return;
 
-    if (!image.isNull()) {
-        Q_ASSERT(cursor.numColors() == 0);
+    if (image.isNull()) {
+        cursor = QImage();
+        hide();
+    } else {
+        cursor = image.convertToFormat(screen->alphaPixmapFormat());
         size = cursor.size();
         hotspot = QPoint(hotx, hoty);
-
-        DFBSurfaceDescription description;
-        description = QDirectFBScreen::getSurfaceDescription(cursor);
-
-        IDirectFBSurface *surface;
-        surface = QDirectFBScreen::instance()->createDFBSurface(&description,
-                                                                QDirectFBScreen::TrackSurface);
+        IDirectFBSurface *surface = screen->createDFBSurface(cursor, QDirectFBScreen::DontTrackSurface);
         if (!surface) {
             qWarning("QDirectFBScreenCursor::set: Unable to create surface");
             return;
         }
         DFBResult result = layer->SetCooperativeLevel(layer, DLSCL_ADMINISTRATIVE);
         if (result != DFB_OK) {
-            DirectFBError("QDirectFBScreenCursor::set: "
+            DirectFBError("QDirectFBScreenCursor::show: "
                           "Unable to set cooperative level", result);
         }
         result = layer->SetCursorShape(layer, surface, hotx, hoty);
         if (result != DFB_OK) {
-            DirectFBError("QDirectFBScreenCursor::set: Unable to set cursor shape",
-                          result);
+            DirectFBError("QDirectFBScreenCursor::show: "
+                          "Unable to set cursor shape", result);
         }
-
+        surface->Release(surface);
         result = layer->SetCooperativeLevel(layer, DLSCL_SHARED);
         if (result != DFB_OK) {
-            DirectFBError("QDirectFBScreenCursor::set: "
-                          "Unable to reset cooperative level", result);
+            DirectFBError("QDirectFBScreenCursor::show: "
+                          "Unable to set cooperative level", result);
         }
-
-        if (surface)
-            QDirectFBScreen::instance()->releaseDFBSurface(surface);
+        show();
     }
+
 }
 #endif // QT_NO_DIRECTFB_LAYER
 
@@ -746,7 +735,7 @@ void QDirectFBScreenPrivate::setFlipFlags(const QStringList &args)
     }
 }
 
-QPixmapData* QDirectFBScreenPrivate::createPixmapData(QPixmapData::PixelType type) const
+QPixmapData *QDirectFBScreenPrivate::createPixmapData(QPixmapData::PixelType type) const
 {
     if (type == QPixmapData::BitmapType)
         return QWSGraphicsSystem::createPixmapData(type);
@@ -754,7 +743,85 @@ QPixmapData* QDirectFBScreenPrivate::createPixmapData(QPixmapData::PixelType typ
     return new QDirectFBPixmapData(type);
 }
 
-static void printDirectFBInfo(IDirectFB *fb)
+#ifdef QT_NO_DEBUG
+struct FlagDescription;
+static const FlagDescription *accelerationDescriptions = 0;
+static const FlagDescription *blitDescriptions = 0;
+static const FlagDescription *drawDescriptions = 0;
+#else
+struct FlagDescription {
+    const char *name;
+    uint flag;
+};
+
+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 },
+    { 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 },
+    { 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 },
+    { 0, 0 }
+};
+#endif
+
+
+
+static const QByteArray flagDescriptions(uint mask, const FlagDescription *flags)
+{
+#ifdef QT_NO_DEBUG
+    Q_UNUSED(mask);
+    Q_UNUSED(flags);
+    return QByteArray("");
+#else
+    if (!mask)
+        return flags[0].name;
+
+    QStringList list;
+    for (int i=1; flags[i].name; ++i) {
+        if (mask & flags[i].flag) {
+            list.append(QString::fromLatin1(flags[i].name));
+        }
+    }
+    Q_ASSERT(!list.isEmpty());
+    return (QLatin1Char(' ') + list.join(QLatin1String("|"))).toLatin1();
+#endif
+}
+
+
+
+static void printDirectFBInfo(IDirectFB *fb, IDirectFBSurface *primarySurface)
 {
     DFBResult result;
     DFBGraphicsDeviceDescription dev;
@@ -765,11 +832,18 @@ static void printDirectFBInfo(IDirectFB *fb)
         return;
     }
 
-    qDebug("Device: %s (%s), Driver: %s v%i.%i (%s)\n"
-           "  acceleration: 0x%x, blit: 0x%x, draw: 0x%0x video: %i\n",
+    DFBSurfacePixelFormat pixelFormat;
+    primarySurface->GetPixelFormat(primarySurface, &pixelFormat);
+
+    qDebug("Device: %s (%s), Driver: %s v%i.%i (%s) Pixelformat: %d (%d)\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,
-           dev.blitting_flags, dev.drawing_flags, dev.video_memory);
+           dev.driver.minor, dev.driver.vendor, DFB_PIXELFORMAT_INDEX(pixelFormat),
+           QDirectFBScreen::getImageFormat(primarySurface), dev.acceleration_mask,
+           ::flagDescriptions(dev.acceleration_mask, accelerationDescriptions).constData(),
+           dev.blitting_flags, ::flagDescriptions(dev.blitting_flags, blitDescriptions).constData(),
+           dev.drawing_flags, ::flagDescriptions(dev.drawing_flags, drawDescriptions).constData(),
+           (dev.video_memory >> 10));
 }
 
 static inline bool setIntOption(const QStringList &arguments, const QString &variable, int *value)
@@ -816,11 +890,29 @@ bool QDirectFBScreen::connect(const QString &displaySpec)
         return false;
     }
 
-    if (displayArgs.contains(QLatin1String("debug"), Qt::CaseInsensitive))
-        printDirectFBInfo(d_ptr->dfb);
+    if (displayArgs.contains(QLatin1String("videoonly"), Qt::CaseInsensitive))
+        d_ptr->directFBFlags |= VideoOnly;
 
-    if (displayArgs.contains(QLatin1String("videoonly")))
-        d_ptr->videoonly = true;
+    if (displayArgs.contains(QLatin1String("systemonly"), Qt::CaseInsensitive)) {
+        if (d_ptr->directFBFlags & VideoOnly) {
+            qWarning("QDirectFBScreen: error. videoonly and systemonly are mutually exclusive");
+        } else {
+            d_ptr->directFBFlags |= SystemOnly;
+        }
+    }
+
+    if (displayArgs.contains(QLatin1String("boundingrectflip"), Qt::CaseInsensitive)) {
+        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;
 
 #ifndef QT_NO_DIRECTFB_WM
     if (displayArgs.contains(QLatin1String("fullscreen")))
@@ -828,28 +920,47 @@ bool QDirectFBScreen::connect(const QString &displaySpec)
         d_ptr->dfb->SetCooperativeLevel(d_ptr->dfb, DFSCL_FULLSCREEN);
 
     DFBSurfaceDescription description;
+    memset(&description, 0, sizeof(DFBSurfaceDescription));
+
     description.flags = DFBSurfaceDescriptionFlags(DSDESC_CAPS);
     if (::setIntOption(displayArgs, QLatin1String("width"), &description.width))
         description.flags = DFBSurfaceDescriptionFlags(description.flags | DSDESC_WIDTH);
     if (::setIntOption(displayArgs, QLatin1String("height"), &description.height))
         description.flags = DFBSurfaceDescriptionFlags(description.flags | DSDESC_HEIGHT);
-    description.caps = DFBSurfaceCapabilities(DSCAPS_PRIMARY
-                                              | DSCAPS_DOUBLE
-                                              | DSCAPS_STATIC_ALLOC);
-    if (displayArgs.contains(QLatin1String("forcepremultiplied"),
-                             Qt::CaseInsensitive)) {
-        description.caps = DFBSurfaceCapabilities(description.caps
-                                                  | DSCAPS_PREMULTIPLIED);
+
+    uint caps = DSCAPS_PRIMARY|DSCAPS_DOUBLE;
+    struct {
+        const char *name;
+        const DFBSurfaceCapabilities cap;
+    } const capabilities[] = {
+        { "static_alloc", DSCAPS_STATIC_ALLOC },
+        { "triplebuffer", DSCAPS_TRIPLE },
+        { "interlaced", DSCAPS_INTERLACED },
+        { "separated", DSCAPS_SEPARATED },
+//        { "depthbuffer", DSCAPS_DEPTH }, // only makes sense with TextureTriangles which are not supported
+        { 0, DSCAPS_NONE }
+    };
+    for (int i=0; capabilities[i].name; ++i) {
+        if (displayArgs.contains(QString::fromLatin1(capabilities[i].name), Qt::CaseInsensitive))
+            caps |= capabilities[i].cap;
     }
 
+    if (displayArgs.contains(QLatin1String("forcepremultiplied"), Qt::CaseInsensitive)) {
+        caps |= DSCAPS_PREMULTIPLIED;
+    }
+
+    description.caps = DFBSurfaceCapabilities(caps);
     // We don't track the primary surface as it's released in disconnect
-    d_ptr->dfbSurface = createDFBSurface(&description, DontTrackSurface);
+    d_ptr->dfbSurface = createDFBSurface(description, DontTrackSurface);
     if (!d_ptr->dfbSurface) {
         DirectFBError("QDirectFBScreen: error creating primary surface",
                       result);
         return false;
     }
 
+    if (displayArgs.contains(QLatin1String("debug"), Qt::CaseInsensitive))
+        printDirectFBInfo(d_ptr->dfb, d_ptr->dfbSurface);
+
     // Work out what format we're going to use for surfaces with an alpha channel
     d_ptr->alphaPixmapFormat = QDirectFBScreen::getImageFormat(d_ptr->dfbSurface);
     setPixelFormat(d_ptr->alphaPixmapFormat);
@@ -934,7 +1045,7 @@ void QDirectFBScreen::disconnect()
     d_ptr->dfbSurface->Release(d_ptr->dfbSurface);
     d_ptr->dfbSurface = 0;
 
-    foreach (IDirectFBSurface* surf, d_ptr->allocatedSurfaces)
+    foreach (IDirectFBSurface *surf, d_ptr->allocatedSurfaces)
         surf->Release(surf);
     d_ptr->allocatedSurfaces.clear();
 
@@ -952,16 +1063,15 @@ void QDirectFBScreen::disconnect()
 
 bool QDirectFBScreen::initDevice()
 {
-    QWSServer *server = QWSServer::instance();
 #ifndef QT_NO_DIRECTFB_MOUSE
     if (qgetenv("QWS_MOUSE_PROTO").isEmpty()) {
-        server->setDefaultMouse("None");
+        QWSServer::instance()->setDefaultMouse("None");
         d_ptr->mouse = new QDirectFBMouseHandler;
     }
 #endif
 #ifndef QT_NO_DIRECTFB_KEYBOARD
     if (qgetenv("QWS_KEYBOARD").isEmpty()) {
-        server->setDefaultKeyboard("None");
+        QWSServer::instance()->setDefaultKeyboard("None");
         d_ptr->keyboard = new QDirectFBKeyboardHandler(QString());
     }
 #endif
@@ -1004,23 +1114,23 @@ void QDirectFBScreen::blank(bool on)
                                    (on ? DSPM_ON : DSPM_SUSPEND));
 }
 
-QWSWindowSurface* QDirectFBScreen::createSurface(QWidget *widget) const
+QWSWindowSurface *QDirectFBScreen::createSurface(QWidget *widget) const
 {
 #ifdef QT_NO_DIRECTFB_WM
     if (QApplication::type() == QApplication::GuiServer) {
-        return new QDirectFBSurface(d_ptr->flipFlags, const_cast<QDirectFBScreen*>(this), widget);
+        return new QDirectFBWindowSurface(d_ptr->flipFlags, const_cast<QDirectFBScreen*>(this), widget);
     } else {
         return QScreen::createSurface(widget);
     }
 #else
-    return new QDirectFBSurface(d_ptr->flipFlags, const_cast<QDirectFBScreen*>(this), widget);
+    return new QDirectFBWindowSurface(d_ptr->flipFlags, const_cast<QDirectFBScreen*>(this), widget);
 #endif
 }
 
-QWSWindowSurface* QDirectFBScreen::createSurface(const QString &key) const
+QWSWindowSurface *QDirectFBScreen::createSurface(const QString &key) const
 {
     if (key == QLatin1String("directfb")) {
-        return new QDirectFBSurface(d_ptr->flipFlags, const_cast<QDirectFBScreen*>(this));
+        return new QDirectFBWindowSurface(d_ptr->flipFlags, const_cast<QDirectFBScreen*>(this));
     }
     return QScreen::createSurface(key);
 }
@@ -1053,7 +1163,7 @@ void QDirectFBScreen::compose(const QRegion &region)
             const QPoint offset = win->requestedRegion().boundingRect().topLeft();
 
             if (surface->key() == QLatin1String("directfb")) {
-                QDirectFBSurface *s = static_cast<QDirectFBSurface*>(surface);
+                QDirectFBWindowSurface *s = static_cast<QDirectFBWindowSurface*>(surface);
                 blit(s->directFBSurface(), offset, r);
             } else {
                 blit(surface->image(), offset, r);
@@ -1102,7 +1212,7 @@ void QDirectFBScreen::compose(const QRegion &region)
         const QPoint offset = win->requestedRegion().boundingRect().topLeft();
 
         if (surface->key() == QLatin1String("directfb")) {
-            QDirectFBSurface *s = static_cast<QDirectFBSurface*>(surface);
+            QDirectFBWindowSurface *s = static_cast<QDirectFBWindowSurface*>(surface);
             blit(s->directFBSurface(), offset, r);
         } else {
             blit(surface->image(), offset, r);
@@ -1188,23 +1298,23 @@ void QDirectFBScreen::blit(IDirectFBSurface *src, const QPoint &topLeft,
                                  points.data(), n);
 }
 
+// This function is only ever called by QScreen::drawBackground which
+// is only ever called by QScreen::compose which is never called with
+// DirectFB so it's really a noop.
 void QDirectFBScreen::solidFill(const QColor &color, const QRegion &region)
 {
     if (region.isEmpty())
         return;
 
     if (QDirectFBScreen::getImageFormat(d_ptr->dfbSurface) == QImage::Format_RGB32) {
-        uchar *mem;
-        int bpl;
-        d_ptr->dfbSurface->Lock(d_ptr->dfbSurface, DSLF_WRITE, (void**)&mem, &bpl);
-        QImage img(mem, w, h, bpl, QImage::Format_RGB32);
-        QPainter p(&img);
-        p.setBrush(color);
-        p.setPen(Qt::NoPen);
-        const QVector<QRect> rects = region.rects();
-        p.drawRects(rects.constData(), rects.size());
-        p.end();
+        data = QDirectFBScreen::lockSurface(d_ptr->dfbSurface, DSLF_WRITE, &lstep);
+        if (!data)
+            return;
+
+        QScreen::solidFill(color, region);
         d_ptr->dfbSurface->Unlock(d_ptr->dfbSurface);
+        data = 0;
+        lstep = 0;
     } else {
         d_ptr->dfbSurface->SetColor(d_ptr->dfbSurface,
                                     color.red(), color.green(), color.blue(),
@@ -1241,3 +1351,15 @@ bool QDirectFBScreen::initSurfaceDescriptionPixelFormat(DFBSurfaceDescription *d
     }
     return true;
 }
+
+uchar *QDirectFBScreen::lockSurface(IDirectFBSurface *surface, uint flags, int *bpl)
+{
+    void *mem;
+    const DFBResult result = surface->Lock(surface, static_cast<DFBSurfaceLockFlags>(flags), static_cast<void**>(&mem), bpl);
+    if (result != DFB_OK) {
+        DirectFBError("QDirectFBScreen::lockSurface()", result);
+    }
+
+    return reinterpret_cast<uchar*>(mem);
+}
+
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
index f394ac1..84199a2 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
@@ -59,6 +59,18 @@ public:
     QDirectFBScreen(int display_id);
     ~QDirectFBScreen();
 
+    enum DirectFBFlag {
+        NoFlags = 0x00,
+        VideoOnly = 0x01,
+        SystemOnly = 0x02,
+        IgnoreSystemClip = 0x04,
+        BoundingRectFlip = 0x08
+    };
+
+    Q_DECLARE_FLAGS(DirectFBFlags, DirectFBFlag);
+
+    DirectFBFlags directFBFlags() const;
+
     bool connect(const QString &displaySpec);
     void disconnect();
     bool initDevice();
@@ -72,19 +84,19 @@ public:
     void setMode(int width, int height, int depth);
     void blank(bool on);
 
-    QWSWindowSurface* createSurface(QWidget *widget) const;
-    QWSWindowSurface* createSurface(const QString &key) const;
+    QWSWindowSurface *createSurface(QWidget *widget) const;
+    QWSWindowSurface *createSurface(const QString &key) const;
 
-    static inline QDirectFBScreen* instance() {
+    static inline QDirectFBScreen *instance() {
         QScreen *inst = QScreen::instance();
         Q_ASSERT(!inst || inst->classId() == QScreen::DirectFBClass);
         return static_cast<QDirectFBScreen*>(inst);
     }
 
-    IDirectFB* dfb();
-    IDirectFBSurface* dfbSurface();
+    IDirectFB *dfb();
+    IDirectFBSurface *dfbSurface();
 #ifndef QT_NO_DIRECTFB_LAYER
-    IDirectFBDisplayLayer* dfbDisplayLayer();
+    IDirectFBDisplayLayer *dfbDisplayLayer();
 #endif
 
     // Track surface creation/release so we can release all on exit
@@ -93,8 +105,6 @@ public:
         TrackSurface = 1
     };
     Q_DECLARE_FLAGS(SurfaceCreationOptions, SurfaceCreationOption);
-    IDirectFBSurface *createDFBSurface(const DFBSurfaceDescription *desc,
-                                       SurfaceCreationOptions options);
     IDirectFBSurface *createDFBSurface(const QImage &image,
                                        SurfaceCreationOptions options);
     IDirectFBSurface *createDFBSurface(const QSize &size,
@@ -106,9 +116,7 @@ public:
     IDirectFBSurface *copyToDFBSurface(const QImage &image,
                                      QImage::Format format,
                                      SurfaceCreationOptions options);
-    void releaseDFBSurface(IDirectFBSurface* surface);
-
-    bool preferVideoOnly() const;
+    void releaseDFBSurface(IDirectFBSurface *surface);
 
     static int depth(DFBSurfacePixelFormat format);
 
@@ -120,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
@@ -127,15 +136,21 @@ public:
                                      const QImage &image);
 #endif
 
+    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);
+Q_DECLARE_OPERATORS_FOR_FLAGS(QDirectFBScreen::DirectFBFlags);
 
 inline bool QDirectFBScreen::isPremultiplied(QImage::Format format)
 {
@@ -173,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/plugins/gfxdrivers/directfb/qdirectfbsurface.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.cpp
index 8ed308c..cd8796b 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbsurface.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.cpp
@@ -39,7 +39,7 @@
 **
 ****************************************************************************/
 
-#include "qdirectfbsurface.h"
+#include "qdirectfbwindowsurface.h"
 #include "qdirectfbscreen.h"
 #include "qdirectfbpaintengine.h"
 
@@ -50,13 +50,14 @@
 
 //#define QT_DIRECTFB_DEBUG_SURFACES 1
 
-QDirectFBSurface::QDirectFBSurface(DFBSurfaceFlipFlags flip, QDirectFBScreen* scr)
+QDirectFBWindowSurface::QDirectFBWindowSurface(DFBSurfaceFlipFlags flip, QDirectFBScreen *scr)
     : QDirectFBPaintDevice(scr)
 #ifndef QT_NO_DIRECTFB_WM
     , dfbWindow(0)
 #endif
     , engine(0)
     , flipFlags(flip)
+    , boundingRectFlip(scr->directFBFlags() & QDirectFBScreen::BoundingRectFlip)
 {
     setSurfaceFlags(Opaque | Buffered);
 #ifdef QT_DIRECTFB_TIMING
@@ -65,13 +66,14 @@ QDirectFBSurface::QDirectFBSurface(DFBSurfaceFlipFlags flip, QDirectFBScreen* sc
 #endif
 }
 
-QDirectFBSurface::QDirectFBSurface(DFBSurfaceFlipFlags flip, QDirectFBScreen *scr, QWidget *widget)
+QDirectFBWindowSurface::QDirectFBWindowSurface(DFBSurfaceFlipFlags flip, QDirectFBScreen *scr, QWidget *widget)
     : QWSWindowSurface(widget), QDirectFBPaintDevice(scr)
 #ifndef QT_NO_DIRECTFB_WM
     , dfbWindow(0)
 #endif
     , engine(0)
     , flipFlags(flip)
+    , boundingRectFlip(scr->directFBFlags() & QDirectFBScreen::BoundingRectFlip)
 {
     onscreen = widget->testAttribute(Qt::WA_PaintOnScreen);
     if (onscreen)
@@ -84,17 +86,17 @@ QDirectFBSurface::QDirectFBSurface(DFBSurfaceFlipFlags flip, QDirectFBScreen *sc
 #endif
 }
 
-QDirectFBSurface::~QDirectFBSurface()
+QDirectFBWindowSurface::~QDirectFBWindowSurface()
 {
 }
 
-bool QDirectFBSurface::isValid() const
+bool QDirectFBWindowSurface::isValid() const
 {
     return true;
 }
 
 #ifndef QT_NO_DIRECTFB_WM
-void QDirectFBSurface::createWindow()
+void QDirectFBWindowSurface::createWindow()
 {
 #ifdef QT_NO_DIRECTFB_LAYER
 #warning QT_NO_DIRECTFB_LAYER requires QT_NO_DIRECTFB_WM
@@ -110,7 +112,7 @@ void QDirectFBSurface::createWindow()
                                                   |DWDESC_PIXELFORMAT);
 
     description.surface_caps = DSCAPS_NONE;
-    if (screen->preferVideoOnly())
+    if (screen->directFBFlags() & QDirectFBScreen::VideoOnly)
         description.surface_caps = DFBSurfaceCapabilities(description.surface_caps|DSCAPS_VIDEOONLY);
     const QImage::Format format = screen->pixelFormat();
     description.pixelformat = QDirectFBScreen::getSurfacePixelFormat(format);
@@ -130,7 +132,7 @@ void QDirectFBSurface::createWindow()
 }
 #endif // QT_NO_DIRECTFB_WM
 
-void QDirectFBSurface::setGeometry(const QRect &rect, const QRegion &mask)
+void QDirectFBWindowSurface::setGeometry(const QRect &rect, const QRegion &mask)
 {
     if (rect.isNull()) {
 #ifndef QT_NO_DIRECTFB_WM
@@ -176,15 +178,7 @@ void QDirectFBSurface::setGeometry(const QRect &rect, const QRegion &mask)
                            "Unable to get DirectFB handle!");
                 }
 
-                DFBSurfaceDescription description;
-                description.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH |
-                                                               DSDESC_HEIGHT |
-                                                               DSDESC_PIXELFORMAT);
-                description.width = rect.width();
-                description.height = rect.height();
-                QDirectFBScreen::initSurfaceDescriptionPixelFormat(&description,
-                                                                   screen->pixelFormat());
-                dfbSurface = screen->createDFBSurface(&description, false);
+                dfbSurface = screen->createDFBSurface(rect.size(), screen->pixelFormat(), QDirectFBScreen::DontTrackSurface);
                 forceRaster = (dfbSurface && QDirectFBScreen::getImageFormat(dfbSurface) == QImage::Format_RGB32);
             } else {
                 Q_ASSERT(dfbSurface);
@@ -209,13 +203,13 @@ void QDirectFBSurface::setGeometry(const QRect &rect, const QRegion &mask)
         }
 
         if (result != DFB_OK)
-            DirectFBErrorFatal("QDirectFBSurface::setGeometry()", result);
+            DirectFBErrorFatal("QDirectFBWindowSurface::setGeometry()", result);
     }
 
     QWSWindowSurface::setGeometry(rect, mask);
 }
 
-QByteArray QDirectFBSurface::permanentState() const
+QByteArray QDirectFBWindowSurface::permanentState() const
 {
     QByteArray array;
 #ifdef QT_NO_DIRECTFB_WM
@@ -234,7 +228,7 @@ QByteArray QDirectFBSurface::permanentState() const
     return array;
 }
 
-void QDirectFBSurface::setPermanentState(const QByteArray &state)
+void QDirectFBWindowSurface::setPermanentState(const QByteArray &state)
 {
     SurfaceFlags flags;
     const char *ptr = state.constData();
@@ -248,7 +242,7 @@ void QDirectFBSurface::setPermanentState(const QByteArray &state)
 #endif
 }
 
-bool QDirectFBSurface::scroll(const QRegion &region, int dx, int dy)
+bool QDirectFBWindowSurface::scroll(const QRegion &region, int dx, int dy)
 {
     if (!dfbSurface || !(flipFlags & DSFLIP_BLIT))
         return false;
@@ -276,7 +270,7 @@ bool QDirectFBSurface::scroll(const QRegion &region, int dx, int dy)
     return true;
 }
 
-bool QDirectFBSurface::move(const QPoint &offset)
+bool QDirectFBWindowSurface::move(const QPoint &offset)
 {
     QWSWindowSurface::move(offset);
 
@@ -291,7 +285,7 @@ bool QDirectFBSurface::move(const QPoint &offset)
 #endif
 }
 
-QRegion QDirectFBSurface::move(const QPoint &offset, const QRegion &newClip)
+QRegion QDirectFBWindowSurface::move(const QPoint &offset, const QRegion &newClip)
 {
 #ifdef QT_NO_DIRECTFB_WM
     return QWSWindowSurface::move(offset, newClip);
@@ -304,10 +298,10 @@ QRegion QDirectFBSurface::move(const QPoint &offset, const QRegion &newClip)
 #endif
 }
 
-QPaintEngine* QDirectFBSurface::paintEngine() const
+QPaintEngine* QDirectFBWindowSurface::paintEngine() const
 {
     if (!engine) {
-        QDirectFBSurface *that = const_cast<QDirectFBSurface*>(this);
+        QDirectFBWindowSurface *that = const_cast<QDirectFBWindowSurface*>(this);
         that->engine = new QDirectFBPaintEngine(that);
         return that->engine;
     }
@@ -337,8 +331,8 @@ inline bool isWidgetOpaque(const QWidget *w)
 
     return false;
 }
-void QDirectFBSurface::flush(QWidget *widget, const QRegion &region,
-                             const QPoint &offset)
+void QDirectFBWindowSurface::flush(QWidget *widget, const QRegion &region,
+                                   const QPoint &offset)
 {
     Q_UNUSED(widget);
 #ifdef QT_NO_DIRECTFB_WM
@@ -369,20 +363,15 @@ void QDirectFBSurface::flush(QWidget *widget, const QRegion &region,
     if (!(flipFlags & DSFLIP_BLIT)) {
         dfbSurface->Flip(dfbSurface, 0, flipFlags);
     } else {
-        if (region.numRects() > 1) {
+        if (!boundingRectFlip && region.numRects() > 1) {
             const QVector<QRect> rects = region.rects();
-            DFBSurfaceFlipFlags tmpFlags = flipFlags;
-            if (flipFlags & DSFLIP_WAIT)
-                tmpFlags = DFBSurfaceFlipFlags(flipFlags & ~DSFLIP_WAIT);
+            const DFBSurfaceFlipFlags nonWaitFlags = DFBSurfaceFlipFlags(flipFlags & ~DSFLIP_WAIT);
             for (int i=0; i<rects.size(); ++i) {
                 const QRect &r = rects.at(i);
                 const DFBRegion dfbReg = { r.x() + offset.x(), r.y() + offset.y(),
                                            r.x() + r.width() + offset.x(),
                                            r.y() + r.height() + offset.y() };
-                dfbSurface->Flip(dfbSurface, &dfbReg,
-                                 i + 1 < rects.size()
-                                 ? tmpFlags
-                                 : flipFlags);
+                dfbSurface->Flip(dfbSurface, &dfbReg, i + 1 < rects.size() ? nonWaitFlags : flipFlags);
             }
         } else {
             const QRect r = region.boundingRect();
@@ -405,15 +394,15 @@ void QDirectFBSurface::flush(QWidget *widget, const QRegion &region,
 }
 
 
-void QDirectFBSurface::beginPaint(const QRegion &)
+void QDirectFBWindowSurface::beginPaint(const QRegion &)
 {
 }
 
-void QDirectFBSurface::endPaint(const QRegion &)
+void QDirectFBWindowSurface::endPaint(const QRegion &)
 {
 #ifdef QT_DIRECTFB_DEBUG_SURFACES
     if (bufferImages.count()) {
-        qDebug("QDirectFBSurface::endPaint() this=%p", this);
+        qDebug("QDirectFBWindowSurface::endPaint() this=%p", this);
 
         foreach(QImage* bufferImg, bufferImages)
             qDebug("   Deleting buffer image %p", bufferImg);
@@ -426,7 +415,7 @@ void QDirectFBSurface::endPaint(const QRegion &)
 }
 
 
-QImage* QDirectFBSurface::buffer(const QWidget *widget)
+QImage *QDirectFBWindowSurface::buffer(const QWidget *widget)
 {
     if (!lockedImage)
         return 0;
@@ -444,7 +433,7 @@ QImage* QDirectFBSurface::buffer(const QWidget *widget)
     bufferImages.append(img);
 
 #ifdef QT_DIRECTFB_DEBUG_SURFACES
-    qDebug("QDirectFBSurface::buffer() Created & returned %p", img);
+    qDebug("QDirectFBWindowSurface::buffer() Created & returned %p", img);
 #endif
 
     return img;
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbsurface.h b/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.h
index ab4145d..75998c4 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbsurface.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.h
@@ -58,12 +58,12 @@ QT_BEGIN_HEADER
 
 QT_MODULE(Gui)
 
-class QDirectFBSurface: public QWSWindowSurface, public QDirectFBPaintDevice
+class QDirectFBWindowSurface : public QWSWindowSurface, public QDirectFBPaintDevice
 {
 public:
-    QDirectFBSurface(DFBSurfaceFlipFlags flipFlags, QDirectFBScreen* scr);
-    QDirectFBSurface(DFBSurfaceFlipFlags flipFlags, QDirectFBScreen* scr, QWidget *widget);
-    ~QDirectFBSurface();
+    QDirectFBWindowSurface(DFBSurfaceFlipFlags flipFlags, QDirectFBScreen* scr);
+    QDirectFBWindowSurface(DFBSurfaceFlipFlags flipFlags, QDirectFBScreen* scr, QWidget *widget);
+    ~QDirectFBWindowSurface();
 
     bool isValid() const;
 
@@ -79,15 +79,15 @@ public:
     QRegion move(const QPoint &offset, const QRegion &newClip);
 
     QImage image() const { return QImage(); }
-    QPaintDevice* paintDevice() { return this; }
-    QPaintEngine* paintEngine() const;
+    QPaintDevice *paintDevice() { return this; }
+    QPaintEngine *paintEngine() const;
 
     void flush(QWidget *widget, const QRegion &region, const QPoint &offset);
 
     void beginPaint(const QRegion &);
     void endPaint(const QRegion &);
 
-    QImage* buffer(const QWidget *widget);
+    QImage *buffer(const QWidget *widget);
 
 private:
 #ifndef QT_NO_DIRECTFB_WM
@@ -100,6 +100,7 @@ private:
 
     QList<QImage*> bufferImages;
     DFBSurfaceFlipFlags flipFlags;
+    bool boundingRectFlip;
 #ifdef QT_DIRECTFB_TIMING
     int frames;
     QTime timer;
diff --git a/src/plugins/gfxdrivers/powervr/QWSWSEGL/QWSWSEGL.pro b/src/plugins/gfxdrivers/powervr/QWSWSEGL/QWSWSEGL.pro
index b62894d..9331d0a 100644
--- a/src/plugins/gfxdrivers/powervr/QWSWSEGL/QWSWSEGL.pro
+++ b/src/plugins/gfxdrivers/powervr/QWSWSEGL/QWSWSEGL.pro
@@ -22,3 +22,5 @@ LIBS += -lpvr2d
 DESTDIR = $$QMAKE_LIBDIR_QT
 target.path = $$[QT_INSTALL_LIBS]
 INSTALLS += target
+
+include(../powervr.pri)
\ No newline at end of file
diff --git a/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable.c b/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable.c
index 5c37253..4771d14 100644
--- a/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable.c
+++ b/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable.c
@@ -72,7 +72,7 @@ static int pvrQwsInitFbScreen(int screen)
     /* Bail out if already initialized, or the number is incorrect */
     if (screen < 0 || screen >= PVRQWS_MAX_SCREENS)
         return 0;
-    if (pvrQwsDisplay.screens[screen].mapped)
+    if (pvrQwsDisplay.screens[screen].initialized)
         return 1;
 
     /* Open the framebuffer and fetch its properties */
@@ -125,26 +125,33 @@ static int pvrQwsInitFbScreen(int screen)
     start = fix.smem_start;
     length = var.xres_virtual * var.yres_virtual * bytesPerPixel;
 
-    /* Map the framebuffer region into memory */
-    mapped = mmap(0, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-    if (!mapped || mapped == (void *)(-1)) {
-        perror("mmap");
-        close(fd);
-        return 0;
-    }
-
-    /* Allocate a PVR2D memory region for the framebuffer */
-    memInfo = 0;
-    if (pvrQwsDisplay.context) {
-        pageAddresses[0] = start & 0xFFFFF000;
-        pageAddresses[1] = 0;
-        if (PVR2DMemWrap
-                (pvrQwsDisplay.context, mapped, PVR2D_WRAPFLAG_CONTIGUOUS,
-                 length, pageAddresses, &memInfo) != PVR2D_OK) {
-            munmap(mapped, length);
+    if (screen == 0) {
+        /* We use PVR2DGetFrameBuffer to map the first screen.
+           On some chipsets it is more reliable than using PVR2DMemWrap */
+        mapped = 0;
+        memInfo = 0;
+    } else {
+        /* Other screens: map the framebuffer region into memory */
+        mapped = mmap(0, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+        if (!mapped || mapped == (void *)(-1)) {
+            perror("mmap");
             close(fd);
             return 0;
         }
+
+        /* Allocate a PVR2D memory region for the framebuffer */
+        memInfo = 0;
+        if (pvrQwsDisplay.context) {
+            pageAddresses[0] = start & 0xFFFFF000;
+            pageAddresses[1] = 0;
+            if (PVR2DMemWrap
+                    (pvrQwsDisplay.context, mapped, PVR2D_WRAPFLAG_CONTIGUOUS,
+                     length, pageAddresses, &memInfo) != PVR2D_OK) {
+                munmap(mapped, length);
+                close(fd);
+                return 0;
+            }
+        }
     }
 
     /* We don't need the file descriptor any more */
@@ -158,11 +165,17 @@ static int pvrQwsInitFbScreen(int screen)
     pvrQwsDisplay.screens[screen].screenStride = stride;
     pvrQwsDisplay.screens[screen].pixelFormat = format;
     pvrQwsDisplay.screens[screen].bytesPerPixel = bytesPerPixel;
-    pvrQwsDisplay.screens[screen].frameBuffer = memInfo;
     pvrQwsDisplay.screens[screen].screenDrawable = 0;
-    pvrQwsDisplay.screens[screen].mapped = mapped;
+    if (mapped) {
+        /* Don't set these fields if mapped is 0, because PVR2DGetFrameBuffer
+           may have already been called and set them */
+        pvrQwsDisplay.screens[screen].frameBuffer = memInfo;
+        pvrQwsDisplay.screens[screen].mapped = mapped;
+    }
     pvrQwsDisplay.screens[screen].mappedLength = length;
     pvrQwsDisplay.screens[screen].screenStart = start;
+    pvrQwsDisplay.screens[screen].needsUnmap = (mapped != 0);
+    pvrQwsDisplay.screens[screen].initialized = 1;
     return 1;
 }
 
@@ -209,7 +222,7 @@ static int pvrQwsAddDrawable(void)
 
     /* Create the PVR2DMEMINFO blocks for the active framebuffers */
     for (screen = 0; screen < PVRQWS_MAX_SCREENS; ++screen) {
-        if (pvrQwsDisplay.screens[screen].mapped) {
+        if (screen != 0 && pvrQwsDisplay.screens[screen].mapped) {
             pageAddresses[0]
                 = pvrQwsDisplay.screens[screen].screenStart & 0xFFFFF000;
             pageAddresses[1] = 0;
@@ -224,6 +237,17 @@ static int pvrQwsAddDrawable(void)
                 return 0;
             }
             pvrQwsDisplay.screens[screen].frameBuffer = memInfo;
+        } else if (screen == 0) {
+            if (PVR2DGetFrameBuffer
+                    (pvrQwsDisplay.context,
+                     PVR2D_FB_PRIMARY_SURFACE, &memInfo) != PVR2D_OK) {
+                fprintf(stderr, "QWSWSEGL: could not get the primary framebuffer surface\n");
+                PVR2DDestroyDeviceContext(pvrQwsDisplay.context);
+                pvrQwsDisplay.context = 0;
+                return 0;
+            }
+            pvrQwsDisplay.screens[screen].frameBuffer = memInfo;
+            pvrQwsDisplay.screens[screen].mapped = memInfo->pBase;
         }
     }
 
@@ -330,7 +354,7 @@ void pvrQwsDisplayClose(void)
             pvrQwsDestroyDrawableForced(info->screenDrawable);
         if (info->frameBuffer)
             PVR2DMemFree(pvrQwsDisplay.context, info->frameBuffer);
-        if (info->mapped)
+        if (info->mapped && info->needsUnmap)
             munmap(info->mapped, info->mappedLength);
     }
 
diff --git a/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable_p.h b/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable_p.h
index d6c42a6..4f3ea90 100644
--- a/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable_p.h
+++ b/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable_p.h
@@ -76,6 +76,8 @@ typedef struct {
     void               *mapped;
     int                 mappedLength;
     unsigned long       screenStart;
+    int                 needsUnmap;
+    int                 initialized;
 
 } PvrQwsScreenInfo;
 
diff --git a/src/plugins/gfxdrivers/powervr/README b/src/plugins/gfxdrivers/powervr/README
index ec02efb..4dce87f 100644
--- a/src/plugins/gfxdrivers/powervr/README
+++ b/src/plugins/gfxdrivers/powervr/README
@@ -29,12 +29,13 @@ strictly Unix-style markers.
 
 ***************************************************************************
 * IMPORTANT: To build the QScreen plugin and the WSEGL library it depends *
-* on, the pvr2d.h, wsegl.h headers for your platform are required. These  *
-* can be obtained either through your platform provider or directly from  *
-* Imagination Technologies.                                               *
+* on, the pvr2d.h, wsegl.h headers for your platform are required.  You   *
+* can find a copy of these headers in src/3rdparty/powervr for SGX based  *
+* platforms like the TI OMAP3xxx. They may also work on MBX platforms too *
+* depending on how old your libEGL is. You can tell Qt where to find      *
+* these headers by setting QMAKE_INCDIR_POWERVR in the mkspec.            *
 ***************************************************************************
 
-
 When you start a Qt/Embedded application, you should modify the QWS_DISPLAY
 environment variable to use the "powervr" driver instead of "LinuxFb".  For
 example, if your original QWS_DISPLAY variable was:
diff --git a/src/plugins/gfxdrivers/powervr/powervr.pri b/src/plugins/gfxdrivers/powervr/powervr.pri
new file mode 100644
index 0000000..9df8c0e
--- /dev/null
+++ b/src/plugins/gfxdrivers/powervr/powervr.pri
@@ -0,0 +1,2 @@
+
+INCLUDEPATH += $$QMAKE_INCDIR_POWERVR
diff --git a/src/plugins/gfxdrivers/powervr/pvreglscreen/pvreglscreen.pro b/src/plugins/gfxdrivers/powervr/pvreglscreen/pvreglscreen.pro
index 691cd2d..675be85 100644
--- a/src/plugins/gfxdrivers/powervr/pvreglscreen/pvreglscreen.pro
+++ b/src/plugins/gfxdrivers/powervr/pvreglscreen/pvreglscreen.pro
@@ -9,9 +9,10 @@ DEFINES += QT_QWS_CLIENTBLIT
 
 INCLUDEPATH += ../QWSWSEGL
 
+
 HEADERS	= \
-	pvreglscreen.h \
-        pvreglwindowsurface.h
+    pvreglscreen.h \
+    pvreglwindowsurface.h
 
 SOURCES	= \
         pvreglscreenplugin.cpp \
@@ -22,3 +23,5 @@ QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/gfxdrivers
 
 target.path = $$[QT_INSTALL_PLUGINS]/gfxdrivers
 INSTALLS += target
+
+include(../powervr.pri)
\ No newline at end of file
diff --git a/src/plugins/iconengines/svgiconengine/qsvgiconengine.cpp b/src/plugins/iconengines/svgiconengine/qsvgiconengine.cpp
index 7fdf81f..3273513 100644
--- a/src/plugins/iconengines/svgiconengine/qsvgiconengine.cpp
+++ b/src/plugins/iconengines/svgiconengine/qsvgiconengine.cpp
@@ -121,17 +121,11 @@ QSize QSvgIconEngine::actualSize(const QSize &size, QIcon::Mode mode,
         if (!pm.isNull() && pm.size() == size)
             return size;
     }
-    
-    QSvgRenderer renderer;
-    d->loadDataForModeAndState(&renderer, mode, state);
-    if (renderer.isValid()) {
-        QSize defaultSize = renderer.defaultSize();
-        if (!defaultSize.isNull())
-            defaultSize.scale(size, Qt::KeepAspectRatio);
-        return defaultSize;
-    } else {
+
+    QPixmap pm = pixmap(size, mode, state);
+    if (pm.isNull())
         return QSize();
-    }
+    return pm.size();
 }
 
 void QSvgIconEnginePrivate::loadDataForModeAndState(QSvgRenderer *renderer, QIcon::Mode mode, QIcon::State state)
@@ -158,9 +152,13 @@ void QSvgIconEnginePrivate::loadDataForModeAndState(QSvgRenderer *renderer, QIco
 
 QPixmap QSvgIconEngine::pixmap(const QSize &size, QIcon::Mode mode,
                                QIcon::State state)
-{   
+{
     QPixmap pm;
 
+    QString pmckey(d->pmcKey(size, mode, state));
+    if (QPixmapCache::find(pmckey, pm))
+        return pm;
+
     if (d->addedPixmaps) {
         pm = d->addedPixmaps->value(d->hashKey(mode, state));
         if (!pm.isNull() && pm.size() == size)
@@ -176,10 +174,6 @@ QPixmap QSvgIconEngine::pixmap(const QSize &size, QIcon::Mode mode,
     if (!actualSize.isNull())
         actualSize.scale(size, Qt::KeepAspectRatio);
 
-    QString pmckey(d->pmcKey(actualSize, mode, state));
-    if (QPixmapCache::find(pmckey, pm))
-        return pm;
-
     QImage img(actualSize, QImage::Format_ARGB32_Premultiplied);
     img.fill(0x00000000);
     QPainter p(&img);
diff --git a/src/plugins/qpluginbase.pri b/src/plugins/qpluginbase.pri
index 446efab..ae39021 100644
--- a/src/plugins/qpluginbase.pri
+++ b/src/plugins/qpluginbase.pri
@@ -1,6 +1,6 @@
 TEMPLATE = lib
 isEmpty(QT_MAJOR_VERSION) {
-   VERSION=4.5.1
+   VERSION=4.5.2
 } else {
    VERSION=$${QT_MAJOR_VERSION}.$${QT_MINOR_VERSION}.$${QT_PATCH_VERSION}
 }
diff --git a/src/qbase.pri b/src/qbase.pri
index e9da61d..f7c8a95 100644
--- a/src/qbase.pri
+++ b/src/qbase.pri
@@ -4,7 +4,7 @@ INCLUDEPATH *= $$QMAKE_INCDIR_QT/$$TARGET #just for today to have some compat
 isEmpty(QT_ARCH):!isEmpty(ARCH):QT_ARCH=$$ARCH #another compat that will rot for change #215700
 TEMPLATE	= lib
 isEmpty(QT_MAJOR_VERSION) {
-   VERSION=4.5.1
+   VERSION=4.5.2
 } else {
    VERSION=$${QT_MAJOR_VERSION}.$${QT_MINOR_VERSION}.$${QT_PATCH_VERSION}
 }
diff --git a/src/qt3support/dialogs/q3filedialog.cpp b/src/qt3support/dialogs/q3filedialog.cpp
index 4874b6d..1ec0cfc 100644
--- a/src/qt3support/dialogs/q3filedialog.cpp
+++ b/src/qt3support/dialogs/q3filedialog.cpp
@@ -631,6 +631,7 @@ public:
 protected:
     void keyPressEvent(QKeyEvent *e);
     void focusOutEvent(QFocusEvent *e);
+    void emitDoRename();
 
 signals:
     void cancelRename();
@@ -1143,16 +1144,20 @@ void QRenameEdit::keyPressEvent(QKeyEvent *e)
 
 void QRenameEdit::focusOutEvent(QFocusEvent *)
 {
-    if (!doRenameAlreadyEmitted) {
-        doRenameAlreadyEmitted = true;
-        emit doRename();
-    }
+    if (!doRenameAlreadyEmitted)
+        emitDoRename();
 }
 
 void QRenameEdit::slotReturnPressed()
 {
+    emitDoRename();
+}
+
+void QRenameEdit::emitDoRename()
+{
     doRenameAlreadyEmitted = true;
     emit doRename();
+    doRenameAlreadyEmitted = false;
 }
 
 /************************************************************************
diff --git a/src/script/qscriptvalueiterator.cpp b/src/script/qscriptvalueiterator.cpp
index fe5ef9f..1a60632 100644
--- a/src/script/qscriptvalueiterator.cpp
+++ b/src/script/qscriptvalueiterator.cpp
@@ -106,6 +106,7 @@ QScriptValueIteratorPrivate::QScriptValueIteratorPrivate()
 */
 QScriptValueIteratorPrivate::~QScriptValueIteratorPrivate()
 {
+    delete it;
 }
 
 /*!
@@ -130,7 +131,6 @@ QScriptValueIterator::QScriptValueIterator(const QScriptValue &object)
 QScriptValueIterator::~QScriptValueIterator()
 {
     if (d_ptr) {
-        delete d_ptr->it;
         delete d_ptr;
         d_ptr = 0;
     }
@@ -312,7 +312,7 @@ void QScriptValueIterator::remove()
 QScriptValueIterator& QScriptValueIterator::operator=(QScriptValue &object)
 {
     if (d_ptr) {
-        delete d_ptr->it;
+        delete d_ptr;
         d_ptr = 0;
     }
     QScriptValueImpl val = QScriptValuePrivate::valueOf(object);
diff --git a/src/sql/drivers/ibase/qsql_ibase.cpp b/src/sql/drivers/ibase/qsql_ibase.cpp
index 0705722..6834d9a 100644
--- a/src/sql/drivers/ibase/qsql_ibase.cpp
+++ b/src/sql/drivers/ibase/qsql_ibase.cpp
@@ -871,7 +871,7 @@ QIBaseResult::~QIBaseResult()
 
 bool QIBaseResult::prepare(const QString& query)
 {
-    //qDebug("prepare: %s\n", qPrintable(query));
+//     qDebug("prepare: %s", qPrintable(query));
     if (!driver() || !driver()->isOpen() || driver()->isOpenError())
         return false;
     d->cleanup();
@@ -1025,7 +1025,7 @@ bool QIBaseResult::exec()
     }
 
     if (ok) {
-        if (colCount()) {
+        if (colCount() && d->queryType != isc_info_sql_stmt_exec_procedure) {
             isc_dsql_free_statement(d->status, &d->stmt, DSQL_close);
             if (d->isError(QT_TRANSLATE_NOOP("QIBaseResult", "Unable to close statement")))
                 return false;
@@ -1039,7 +1039,7 @@ bool QIBaseResult::exec()
             return false;
 
         // Not all stored procedures necessarily return values.
-        if (d->queryType == isc_info_sql_stmt_exec_procedure && d->sqlda->sqld == 0)
+        if (d->queryType == isc_info_sql_stmt_exec_procedure && d->sqlda && d->sqlda->sqld == 0)
             delDA(d->sqlda);
 
         if (d->sqlda)
@@ -1270,27 +1270,27 @@ QSqlRecord QIBaseResult::record() const
         v = d->sqlda->sqlvar[i];
         QSqlField f(QString::fromLatin1(v.aliasname, v.aliasname_length).simplified(),
                     qIBaseTypeName2(v.sqltype, v.sqlscale < 0));
-        QSqlQuery q(new QIBaseResult(d->db));
-        q.setForwardOnly(true);
-        q.exec(QLatin1String("select b.RDB$FIELD_PRECISION, b.RDB$FIELD_SCALE, b.RDB$FIELD_LENGTH, a.RDB$NULL_FLAG "
-                "FROM RDB$RELATION_FIELDS a, RDB$FIELDS b "
-                "WHERE b.RDB$FIELD_NAME = a.RDB$FIELD_SOURCE "
-                "AND a.RDB$RELATION_NAME = '") + QString::fromAscii(v.relname, v.relname_length).toUpper() + QLatin1String("' "
-                "AND a.RDB$FIELD_NAME = '") + QString::fromAscii(v.sqlname, v.sqlname_length).toUpper() + QLatin1String("' "));
-        if(q.first()) {
-            if(v.sqlscale < 0) {
-                f.setLength(q.value(0).toInt());
-                f.setPrecision(qAbs(q.value(1).toInt()));
-            } else {
-                f.setLength(q.value(2).toInt());
-                f.setPrecision(0);
+        f.setLength(v.sqllen);
+        f.setPrecision(qAbs(v.sqlscale));
+        f.setRequiredStatus((v.sqltype & 1) == 0 ? QSqlField::Required : QSqlField::Optional);
+        if(v.sqlscale < 0) {
+            QSqlQuery q(new QIBaseResult(d->db));
+            q.setForwardOnly(true);
+            q.exec(QLatin1String("select b.RDB$FIELD_PRECISION, b.RDB$FIELD_SCALE, b.RDB$FIELD_LENGTH, a.RDB$NULL_FLAG "
+                    "FROM RDB$RELATION_FIELDS a, RDB$FIELDS b "
+                    "WHERE b.RDB$FIELD_NAME = a.RDB$FIELD_SOURCE "
+                    "AND a.RDB$RELATION_NAME = '") + QString::fromAscii(v.relname, v.relname_length).toUpper() + QLatin1String("' "
+                    "AND a.RDB$FIELD_NAME = '") + QString::fromAscii(v.sqlname, v.sqlname_length).toUpper() + QLatin1String("' "));
+            if(q.first()) {
+                if(v.sqlscale < 0) {
+                    f.setLength(q.value(0).toInt());
+                    f.setPrecision(qAbs(q.value(1).toInt()));
+                } else {
+                    f.setLength(q.value(2).toInt());
+                    f.setPrecision(0);
+                }
+                f.setRequiredStatus(q.value(3).toBool() ? QSqlField::Required : QSqlField::Optional);
             }
-            f.setRequiredStatus(q.value(3).toBool() ? QSqlField::Required : QSqlField::Optional);
-        }
-        else {
-            f.setLength(0);
-            f.setPrecision(0);
-            f.setRequiredStatus(QSqlField::Unknown);
         }
         f.setSqlType(v.sqltype);
         rec.append(f);
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));
diff --git a/src/sql/drivers/oci/qsql_oci.cpp b/src/sql/drivers/oci/qsql_oci.cpp
index fa9b5f0..d63c482 100644
--- a/src/sql/drivers/oci/qsql_oci.cpp
+++ b/src/sql/drivers/oci/qsql_oci.cpp
@@ -2208,7 +2208,7 @@ QStringList QOCIDriver::tables(QSql::TableType type) const
             user = user.toUpper();
 
         while (t.next()) {
-            if (t.value(0).toString() != user)
+            if (t.value(0).toString().toUpper() != user.toUpper())
                 tl.append(t.value(0).toString() + QLatin1String(".") + t.value(1).toString());
             else
                 tl.append(t.value(1).toString());
@@ -2224,7 +2224,7 @@ QStringList QOCIDriver::tables(QSql::TableType type) const
                 "and owner != 'CTXSYS'"
                 "and owner != 'WMSYS'"));
         while (t.next()) {
-            if (t.value(0).toString() != d->user)
+            if (t.value(0).toString().toUpper() != d->user.toUpper())
                 tl.append(t.value(0).toString() + QLatin1String(".") + t.value(1).toString());
             else
                 tl.append(t.value(1).toString());
diff --git a/src/sql/drivers/odbc/qsql_odbc.cpp b/src/sql/drivers/odbc/qsql_odbc.cpp
index 2a83fe6..ee500a0 100644
--- a/src/sql/drivers/odbc/qsql_odbc.cpp
+++ b/src/sql/drivers/odbc/qsql_odbc.cpp
@@ -70,18 +70,15 @@ QT_BEGIN_NAMESPACE
 #endif
 
 // newer platform SDKs use SQLLEN instead of SQLINTEGER
-#if defined(SQLLEN) || defined(Q_OS_WIN64)
-# define QSQLLEN SQLLEN
-#else
+#if defined(WIN32) && (_MSC_VER < 1300)
 # define QSQLLEN SQLINTEGER
-#endif
-
-#if defined(SQLULEN) || defined(Q_OS_WIN64)
-# define QSQLULEN SQLULEN
-#else
 # define QSQLULEN SQLUINTEGER
+#else
+# define QSQLLEN SQLLEN
+# define QSQLULEN SQLULEN
 #endif
 
+
 static const int COLNAMESIZE = 256;
 //Map Qt parameter types to ODBC types
 static const SQLSMALLINT qParamType[4] = { SQL_PARAM_INPUT, SQL_PARAM_INPUT, SQL_PARAM_OUTPUT, SQL_PARAM_INPUT_OUTPUT };
@@ -566,7 +563,6 @@ QChar QODBCDriverPrivate::quoteChar() const
     static QChar quote = QChar::fromLatin1('"');
     if (!isQuoteInitialized) {
         char driverResponse[4];
-        SQLUSMALLINT casing;
         SQLSMALLINT length;
         int r = SQLGetInfo(hDbc,
                 SQL_IDENTIFIER_QUOTE_CHAR,
diff --git a/src/src.pro b/src/src.pro
index fb28882..f40c6ad 100644
--- a/src/src.pro
+++ b/src/src.pro
@@ -13,7 +13,7 @@ wince*:{
         contains(QT_CONFIG, qt3support): SRC_SUBDIRS += src_tools_uic3
     }
 }
-win32:!contains(QT_EDITION, OpenSource|Console): {
+win32:{
     SRC_SUBDIRS += src_activeqt
     !wince*: SRC_SUBDIRS += src_tools_idc
 }
diff --git a/src/svg/qsvgstyle.cpp b/src/svg/qsvgstyle.cpp
index b065395..bd0804c 100644
--- a/src/svg/qsvgstyle.cpp
+++ b/src/svg/qsvgstyle.cpp
@@ -808,6 +808,7 @@ void QSvgGradientStyle::resolveStops()
                     static_cast<QSvgGradientStyle*>(prop);
                 st->resolveStops();
                 m_gradient->setStops(st->qgradient()->stops());
+                m_gradientStopsSet = st->gradientStopsSet();
             }
         }
         m_link = QString();
diff --git a/src/svg/qsvgwidget.cpp b/src/svg/qsvgwidget.cpp
index a4200ca..ac8595f 100644
--- a/src/svg/qsvgwidget.cpp
+++ b/src/svg/qsvgwidget.cpp
@@ -83,18 +83,6 @@ class QSvgWidgetPrivate : public QWidgetPrivate
 {
     Q_DECLARE_PUBLIC(QSvgWidget)
 public:
-    QSvgWidgetPrivate()
-        : QWidgetPrivate()
-    {
-        Q_Q(QSvgWidget);
-        renderer = new QSvgRenderer(q);
-    }
-    QSvgWidgetPrivate(const QString &file)
-        : QWidgetPrivate()
-    {
-        Q_Q(QSvgWidget);
-        renderer = new QSvgRenderer(file, q);
-    }
     QSvgRenderer *renderer;
 };
 
@@ -104,6 +92,7 @@ public:
 QSvgWidget::QSvgWidget(QWidget *parent)
     : QWidget(*new QSvgWidgetPrivate, parent, 0)
 {
+    d_func()->renderer = new QSvgRenderer(this);
     QObject::connect(d_func()->renderer, SIGNAL(repaintNeeded()),
                      this, SLOT(update()));
 }
@@ -113,8 +102,9 @@ QSvgWidget::QSvgWidget(QWidget *parent)
     of the specified \a file.
 */
 QSvgWidget::QSvgWidget(const QString &file, QWidget *parent)
-    : QWidget(*new QSvgWidgetPrivate(file), parent, 0)
+    : QWidget(*new QSvgWidgetPrivate, parent, 0)
 {
+    d_func()->renderer = new QSvgRenderer(file, this);
     QObject::connect(d_func()->renderer, SIGNAL(repaintNeeded()),
                      this, SLOT(update()));
 }
diff --git a/src/testlib/qtestcase.cpp b/src/testlib/qtestcase.cpp
index f17d95d..b5200dc 100644
--- a/src/testlib/qtestcase.cpp
+++ b/src/testlib/qtestcase.cpp
@@ -1481,7 +1481,7 @@ int QTest::qExec(QObject *testObject, int argc, char **argv)
     }
 #endif
 
-#if defined(QTEST_NOEXITCODE) || (defined(QT_BUILD_INTERNAL) && !defined(QTEST_FORCE_EXITCODE))
+#if defined(QTEST_NOEXITCODE)
     return 0;
 #else
 
diff --git a/src/tools/uic/cpp/cppwriteinitialization.cpp b/src/tools/uic/cpp/cppwriteinitialization.cpp
index 3d702dd..47566ad 100644
--- a/src/tools/uic/cpp/cppwriteinitialization.cpp
+++ b/src/tools/uic/cpp/cppwriteinitialization.cpp
@@ -1650,19 +1650,19 @@ QString WriteInitialization::writeIconProperties(const DomResourceIcon *i)
         if (i->hasElementNormalOff())
             m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementNormalOff()->text(), m_dindent) << "), QSize(), QIcon::Normal, QIcon::Off);\n";
         if (i->hasElementNormalOn())
-            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementNormalOff()->text(), m_dindent) << "), QSize(), QIcon::Normal, QIcon::On);\n";
+            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementNormalOn()->text(), m_dindent) << "), QSize(), QIcon::Normal, QIcon::On);\n";
         if (i->hasElementDisabledOff())
-            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementNormalOff()->text(), m_dindent) << "), QSize(), QIcon::Disabled, QIcon::Off);\n";
+            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementDisabledOff()->text(), m_dindent) << "), QSize(), QIcon::Disabled, QIcon::Off);\n";
         if (i->hasElementDisabledOn())
-            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementNormalOff()->text(), m_dindent) << "), QSize(), QIcon::Disabled, QIcon::On);\n";
+            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementDisabledOn()->text(), m_dindent) << "), QSize(), QIcon::Disabled, QIcon::On);\n";
         if (i->hasElementActiveOff())
-            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementNormalOff()->text(), m_dindent) << "), QSize(), QIcon::Active, QIcon::Off);\n";
+            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementActiveOff()->text(), m_dindent) << "), QSize(), QIcon::Active, QIcon::Off);\n";
         if (i->hasElementActiveOn())
-            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementNormalOff()->text(), m_dindent) << "), QSize(), QIcon::Active, QIcon::On);\n";
+            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementActiveOn()->text(), m_dindent) << "), QSize(), QIcon::Active, QIcon::On);\n";
         if (i->hasElementSelectedOff())
-            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementNormalOff()->text(), m_dindent) << "), QSize(), QIcon::Selected, QIcon::Off);\n";
+            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementSelectedOff()->text(), m_dindent) << "), QSize(), QIcon::Selected, QIcon::Off);\n";
         if (i->hasElementSelectedOn())
-            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementNormalOff()->text(), m_dindent) << "), QSize(), QIcon::Selected, QIcon::On);\n";
+            m_output << m_indent << iconName << ".addFile(QString::fromUtf8(" << fixString(i->elementSelectedOn()->text(), m_dindent) << "), QSize(), QIcon::Selected, QIcon::On);\n";
     } else { // pre-4.4 legacy
         m_output <<  m_indent << "const QIcon " << iconName << " = " << pixCall(QLatin1String("QIcon"), i->text())<< ";\n";
     }
diff --git a/src/xmlpatterns/expr/qapplytemplate.cpp b/src/xmlpatterns/expr/qapplytemplate.cpp
index 95f4fdf..b91c2f0 100644
--- a/src/xmlpatterns/expr/qapplytemplate.cpp
+++ b/src/xmlpatterns/expr/qapplytemplate.cpp
@@ -160,8 +160,7 @@ Item::Iterator::Ptr ApplyTemplate::evaluateSequence(const DynamicContext::Ptr &c
             focus->setFocusIterator(focusIterator);
             return makeSequenceMappingIterator<Item>(ConstPtr(this), focusIterator, focus);
         }
-        else
-            return CommonValues::emptyIterator;
+        return CommonValues::emptyIterator;
     }
 }
 
diff --git a/src/xmlpatterns/functions/qsequencefns.cpp b/src/xmlpatterns/functions/qsequencefns.cpp
index f6d5391..faa787e 100644
--- a/src/xmlpatterns/functions/qsequencefns.cpp
+++ b/src/xmlpatterns/functions/qsequencefns.cpp
@@ -246,8 +246,7 @@ Item::Iterator::Ptr SubsequenceFN::evaluateSequence(const DynamicContext::Ptr &c
 
     if(length < 1 && length != -1)
         return CommonValues::emptyIterator;
-    else
-        return Item::Iterator::Ptr(new SubsequenceIterator(it, startingLoc, length));
+    return Item::Iterator::Ptr(new SubsequenceIterator(it, startingLoc, length));
 }
 
 Item SubsequenceFN::evaluateSingleton(const DynamicContext::Ptr &context) const