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

27 files changed, 293 insertions, 734 deletions

diff --git a/src/gui/dialogs/qprintdialog_win.cpp b/src/gui/dialogs/qprintdialog_win.cpp
index 843c4e2..51e83ac 100644
--- a/src/gui/dialogs/qprintdialog_win.cpp
+++ b/src/gui/dialogs/qprintdialog_win.cpp
@@ -139,7 +139,7 @@ static void qt_win_setup_PRINTDLGEX(PRINTDLGEX *pd, QWidget *parent,
     if (d->ep->printToFile)
         pd->Flags |= PD_PRINTTOFILE;
     Q_ASSERT(parent != 0 && parent->testAttribute(Qt::WA_WState_Created));
-    pd->hwndOwner = parent->winId();
+    pd->hwndOwner = parent->window()->winId();
     pd->lpPageRanges[0].nFromPage = qMax(pdlg->fromPage(), pdlg->minPage());
     pd->lpPageRanges[0].nToPage   = (pdlg->toPage() > 0) ? qMin(pdlg->toPage(), pdlg->maxPage()) : 1;
     pd->nCopies = d->ep->num_copies;
diff --git a/src/gui/effects/qgraphicseffect.cpp b/src/gui/effects/qgraphicseffect.cpp
index 96d35b0..3a6bab5 100644
--- a/src/gui/effects/qgraphicseffect.cpp
+++ b/src/gui/effects/qgraphicseffect.cpp
@@ -65,9 +65,6 @@
     \o QGraphicsDropShadowEffect - renders a dropshadow behind the item
     \o QGraphicsColorizeEffect - renders the item in shades of any given color
     \o QGraphicsOpacityEffect - renders the item with an opacity
-    \o QGraphicsPixelizeEffect - pixelizes the item with any pixel size
-    \o QGraphicsGrayscaleEffect - renders the item in shades of gray
-    \o QGraphicsBloomEffect - applies a blooming / glowing effect
     \endlist
 
     \img graphicseffect-effects.png
@@ -100,9 +97,11 @@
 */
 
 #include "qgraphicseffect_p.h"
+#include <QtGui/qgraphicsitem.h>
 
 #include <QtGui/qimage.h>
 #include <QtGui/qpainter.h>
+#include <QtGui/qpaintengine.h>
 #include <QtCore/qrect.h>
 #include <QtCore/qdebug.h>
 #include <private/qdrawhelper_p.h>
@@ -251,17 +250,24 @@ bool QGraphicsEffectSource::isPixmap() const
 
     \sa QGraphicsEffect::draw(), boundingRect(), deviceRect()
 */
-QPixmap QGraphicsEffectSource::pixmap(Qt::CoordinateSystem system, QPoint *offset) const
+QPixmap QGraphicsEffectSource::pixmap(Qt::CoordinateSystem system, QPoint *offset, PixmapPadMode mode) const
 {
     Q_D(const QGraphicsEffectSource);
 
+    // Shortcut, no cache for childless pixmap items...
+    const QGraphicsItem *item = graphicsItem();
+    if (system == Qt::LogicalCoordinates && mode == NoExpandPadMode && item && isPixmap()) {
+        return ((QGraphicsPixmapItem *) item)->pixmap();
+    }
+
     QPixmap pm;
-    if (d->m_cachedSystem == system)
+    if (d->m_cachedSystem == system && d->m_cachedMode == mode)
         QPixmapCache::find(d->m_cacheKey, &pm);
 
     if (pm.isNull()) {
-        pm = d->pixmap(system, &d->m_cachedOffset);
+        pm = d->pixmap(system, &d->m_cachedOffset, mode);
         d->m_cachedSystem = system;
+        d->m_cachedMode = mode;
 
         d->invalidateCache();
         d->m_cacheKey = QPixmapCache::insert(pm);
@@ -353,8 +359,10 @@ void QGraphicsEffect::setEnabled(bool enable)
         return;
 
     d->isEnabled = enable;
-    if (d->source)
+    if (d->source) {
         d->source->d_func()->effectBoundingRectChanged();
+        d->source->d_func()->invalidateCache();
+    }
     emit enabledChanged(enable);
 }
 
@@ -408,8 +416,10 @@ QGraphicsEffectSource *QGraphicsEffect::source() const
 void QGraphicsEffect::updateBoundingRect()
 {
     Q_D(QGraphicsEffect);
-    if (d->source)
+    if (d->source) {
         d->source->d_func()->effectBoundingRectChanged();
+        d->source->d_func()->invalidateCache();
+    }
 }
 
 /*!
@@ -458,96 +468,6 @@ void QGraphicsEffect::sourceChanged(ChangeFlags flags)
 }
 
 /*!
-    \class QGraphicsGrayscaleEffect
-    \brief The QGraphicsGrayscaleEffect class provides a grayscale effect.
-    \since 4.6
-
-    A grayscale effect renders the source in shades of gray.
-
-    \img graphicseffect-grayscale.png
-
-    \sa QGraphicsDropShadowEffect, QGraphicsBlurEffect, QGraphicsPixelizeEffect,
-        QGraphicsColorizeEffect, QGraphicsOpacityEffect
-*/
-
-/*!
-    Constructs a new QGraphicsGrayscale instance.
-    The \a parent parameter is passed to QGraphicsEffect's constructor.
-*/
-QGraphicsGrayscaleEffect::QGraphicsGrayscaleEffect(QObject *parent)
-    : QGraphicsEffect(*new QGraphicsGrayscaleEffectPrivate, parent)
-{
-}
-
-/*!
-    Destroys the effect.
-*/
-QGraphicsGrayscaleEffect::~QGraphicsGrayscaleEffect()
-{
-}
-
-
-/*!
-    \property QGraphicsGrayscaleEffect::strength
-    \brief the strength of the effect.
-
-    By default, the strength is 1.0.
-    A strength 0.0 equals to no effect, while 1.0 means full grayscale.
-*/
-qreal QGraphicsGrayscaleEffect::strength() const
-{
-    Q_D(const QGraphicsGrayscaleEffect);
-    return d->filter->strength();
-}
-
-void QGraphicsGrayscaleEffect::setStrength(qreal strength)
-{
-    Q_D(QGraphicsGrayscaleEffect);
-    if (qFuzzyCompare(d->filter->strength(), strength))
-        return;
-
-    d->filter->setStrength(strength);
-    d->opaque = !qFuzzyIsNull(strength);
-    update();
-    emit strengthChanged(strength);
-}
-
-/*! \fn void QGraphicsGrayscaleEffect::strengthChanged(qreal strength)
-  This signal is emitted whenever setStrength() changes the grayscale
-  strength property. \a strength contains the new strength value of
-  the grayscale effect.
- */
-
-/*!
-    \reimp
-*/
-void QGraphicsGrayscaleEffect::draw(QPainter *painter, QGraphicsEffectSource *source)
-{
-    Q_D(QGraphicsGrayscaleEffect);
-
-    if (!d->opaque) {
-        source->draw(painter);
-        return;
-    }
-
-    QPoint offset;
-    if (source->isPixmap()) {
-        // No point in drawing in device coordinates (pixmap will be scaled anyways).
-        const QPixmap pixmap = source->pixmap(Qt::LogicalCoordinates, &offset);
-        d->filter->draw(painter, offset, pixmap);
-        return;
-    }
-
-    // Draw pixmap in device coordinates to avoid pixmap scaling;
-    const QPixmap pixmap = source->pixmap(Qt::DeviceCoordinates, &offset);
-    QTransform restoreTransform = painter->worldTransform();
-    painter->setWorldTransform(QTransform());
-    d->filter->draw(painter, offset, pixmap);
-    painter->setWorldTransform(restoreTransform);
-
-}
-
-/*!
     \class QGraphicsColorizeEffect
     \brief The QGraphicsColorizeEffect class provides a colorize effect.
     \since 4.6
@@ -559,8 +479,7 @@ void QGraphicsGrayscaleEffect::draw(QPainter *painter, QGraphicsEffectSource *so
 
     \img graphicseffect-colorize.png
 
-    \sa QGraphicsDropShadowEffect, QGraphicsBlurEffect, QGraphicsPixelizeEffect,
-        QGraphicsGrayscaleEffect, QGraphicsOpacityEffect
+    \sa QGraphicsDropShadowEffect, QGraphicsBlurEffect, QGraphicsOpacityEffect
 */
 
 /*!
@@ -655,7 +574,8 @@ void QGraphicsColorizeEffect::draw(QPainter *painter, QGraphicsEffectSource *sou
     QPoint offset;
     if (source->isPixmap()) {
         // No point in drawing in device coordinates (pixmap will be scaled anyways).
-        const QPixmap pixmap = source->pixmap(Qt::LogicalCoordinates, &offset);
+        const QPixmap pixmap = source->pixmap(Qt::LogicalCoordinates, &offset,
+                                              QGraphicsEffectSource::NoExpandPadMode);
         d->filter->draw(painter, offset, pixmap);
         return;
     }
@@ -669,126 +589,6 @@ void QGraphicsColorizeEffect::draw(QPainter *painter, QGraphicsEffectSource *sou
 }
 
 /*!
-    \class QGraphicsPixelizeEffect
-    \brief The QGraphicsPixelizeEffect class provides a pixelize effect.
-    \since 4.6
-
-    A pixelize effect renders the source in lower resolution. This effect is
-    useful for reducing details, like censorship. The resolution can be
-    modified using the setPixelSize() function.
-
-    By default, the pixel size is 3.
-
-    \img graphicseffect-pixelize.png
-
-    \sa QGraphicsDropShadowEffect, QGraphicsBlurEffect, QGraphicsGrayscaleEffect,
-        QGraphicsColorizeEffect, QGraphicsOpacityEffect
-*/
-
-/*!
-    Constructs a new QGraphicsPixelizeEffect instance.
-    The \a parent parameter is passed to QGraphicsEffect's constructor.
-*/
-QGraphicsPixelizeEffect::QGraphicsPixelizeEffect(QObject *parent)
-    : QGraphicsEffect(*new QGraphicsPixelizeEffectPrivate, parent)
-{
-}
-
-/*!
-    Destroys the effect.
-*/
-QGraphicsPixelizeEffect::~QGraphicsPixelizeEffect()
-{
-}
-
-/*!
-    \property QGraphicsPixelizeEffect::pixelSize
-    \brief the size of a pixel in the effect.
-
-    Setting the pixel size to 2 means two pixels in the source will be used to
-    represent one pixel. Using a bigger size results in lower resolution.
-
-    By default, the pixel size is 3.
-*/
-int QGraphicsPixelizeEffect::pixelSize() const
-{
-    Q_D(const QGraphicsPixelizeEffect);
-    return d->pixelSize;
-}
-
-void QGraphicsPixelizeEffect::setPixelSize(int size)
-{
-    Q_D(QGraphicsPixelizeEffect);
-    if (d->pixelSize == size)
-        return;
-
-    d->pixelSize = size;
-    update();
-    emit pixelSizeChanged(size);
-}
-
-/*!
-    \fn void QGraphicsPixelizeEffect::pixelSizeChanged(int size)
-
-    This signal is emitted whenever the effect's pixel size changes.
-    The \a size parameter holds the effect's new pixel size.
-*/
-
-static inline void pixelize(QImage *image, int pixelSize)
-{
-    Q_ASSERT(pixelSize > 0);
-    Q_ASSERT(image);
-    int width = image->width();
-    int height = image->height();
-    for (int y = 0; y < height; y += pixelSize) {
-        int ys = qMin(height - 1, y + pixelSize / 2);
-        QRgb *sbuf = reinterpret_cast<QRgb*>(image->scanLine(ys));
-        for (int x = 0; x < width; x += pixelSize) {
-            int xs = qMin(width - 1, x + pixelSize / 2);
-            QRgb color = sbuf[xs];
-            for (int yi = 0; yi < qMin(pixelSize, height - y); ++yi) {
-                QRgb *buf = reinterpret_cast<QRgb*>(image->scanLine(y + yi));
-                for (int xi = 0; xi < qMin(pixelSize, width - x); ++xi)
-                    buf[x + xi] = color;
-            }
-        }
-    }
-}
-
-/*!
-    \reimp
-*/
-void QGraphicsPixelizeEffect::draw(QPainter *painter, QGraphicsEffectSource *source)
-{
-    Q_D(QGraphicsPixelizeEffect);
-    if (d->pixelSize <= 0) {
-        source->draw(painter);
-        return;
-    }
-
-    QPoint offset;
-    if (source->isPixmap()) {
-        const QPixmap pixmap = source->pixmap(Qt::LogicalCoordinates, &offset);
-        QImage image = pixmap.toImage().convertToFormat(QImage::Format_ARGB32);
-        pixelize(&image, d->pixelSize);
-        painter->drawImage(offset, image);
-        return;
-    }
-
-    // Draw pixmap in device coordinates to avoid pixmap scaling.
-    const QPixmap pixmap = source->pixmap(Qt::DeviceCoordinates, &offset);
-
-    // pixelize routine
-    QImage image = pixmap.toImage().convertToFormat(QImage::Format_ARGB32);
-    pixelize(&image, d->pixelSize);
-
-    QTransform restoreTransform = painter->worldTransform();
-    painter->setWorldTransform(QTransform());
-    painter->drawImage(offset, image);
-    painter->setWorldTransform(restoreTransform);
-}
-
-/*!
     \class QGraphicsBlurEffect
     \brief The QGraphicsBlurEffect class provides a blur effect.
     \since 4.6
@@ -802,8 +602,7 @@ void QGraphicsPixelizeEffect::draw(QPainter *painter, QGraphicsEffectSource *sou
 
     \img graphicseffect-blur.png
 
-    \sa QGraphicsDropShadowEffect, QGraphicsPixelizeEffect, QGraphicsGrayscaleEffect,
-        QGraphicsColorizeEffect, QGraphicsOpacityEffect
+    \sa QGraphicsDropShadowEffect, QGraphicsColorizeEffect, QGraphicsOpacityEffect
 */
 
 /*!
@@ -833,16 +632,16 @@ QGraphicsBlurEffect::~QGraphicsBlurEffect()
 
     By default, the blur radius is 5 pixels.
 */
-int QGraphicsBlurEffect::blurRadius() const
+qreal QGraphicsBlurEffect::blurRadius() const
 {
     Q_D(const QGraphicsBlurEffect);
     return d->filter->radius();
 }
 
-void QGraphicsBlurEffect::setBlurRadius(int radius)
+void QGraphicsBlurEffect::setBlurRadius(qreal radius)
 {
     Q_D(QGraphicsBlurEffect);
-    if (d->filter->radius() == radius)
+    if (qFuzzyCompare(d->filter->radius(), radius))
         return;
 
     d->filter->setRadius(radius);
@@ -851,7 +650,7 @@ void QGraphicsBlurEffect::setBlurRadius(int radius)
 }
 
 /*!
-    \fn void QGraphicsBlurEffect::blurRadiusChanged(int radius)
+    \fn void QGraphicsBlurEffect::blurRadiusChanged(qreal radius)
 
     This signal is emitted whenever the effect's blur radius changes.
     The \a radius parameter holds the effect's new blur radius.
@@ -911,9 +710,13 @@ void QGraphicsBlurEffect::draw(QPainter *painter, QGraphicsEffectSource *source)
         return;
     }
 
+    QGraphicsEffectSource::PixmapPadMode mode = QGraphicsEffectSource::ExpandToEffectRectPadMode;
+    if (painter->paintEngine()->type() == QPaintEngine::OpenGL2)
+        mode = QGraphicsEffectSource::ExpandToTransparentBorderPadMode;
+
     // Draw pixmap in device coordinates to avoid pixmap scaling.
     QPoint offset;
-    const QPixmap pixmap = source->pixmap(Qt::DeviceCoordinates, &offset);
+    const QPixmap pixmap = source->pixmap(Qt::DeviceCoordinates, &offset, mode);
     QTransform restoreTransform = painter->worldTransform();
     painter->setWorldTransform(QTransform());
     d->filter->draw(painter, offset, pixmap);
@@ -937,8 +740,7 @@ void QGraphicsBlurEffect::draw(QPainter *painter, QGraphicsEffectSource *source)
 
     \img graphicseffect-drop-shadow.png
 
-    \sa QGraphicsBlurEffect, QGraphicsPixelizeEffect, QGraphicsGrayscaleEffect,
-        QGraphicsColorizeEffect, QGraphicsOpacityEffect
+    \sa QGraphicsBlurEffect, QGraphicsColorizeEffect, QGraphicsOpacityEffect
 */
 
 /*!
@@ -988,6 +790,8 @@ void QGraphicsDropShadowEffect::setOffset(const QPointF &offset)
 
     By default, the horizontal shadow offset is 8 pixels.
 
+
+
     \sa yOffset(), offset()
 */
 
@@ -1018,16 +822,16 @@ void QGraphicsDropShadowEffect::setOffset(const QPointF &offset)
 
     \sa color(), offset().
 */
-int QGraphicsDropShadowEffect::blurRadius() const
+qreal QGraphicsDropShadowEffect::blurRadius() const
 {
     Q_D(const QGraphicsDropShadowEffect);
     return d->filter->blurRadius();
 }
 
-void QGraphicsDropShadowEffect::setBlurRadius(int blurRadius)
+void QGraphicsDropShadowEffect::setBlurRadius(qreal blurRadius)
 {
     Q_D(QGraphicsDropShadowEffect);
-    if (d->filter->blurRadius() == blurRadius)
+    if (qFuzzyCompare(d->filter->blurRadius(), blurRadius))
         return;
 
     d->filter->setBlurRadius(blurRadius);
@@ -1036,7 +840,7 @@ void QGraphicsDropShadowEffect::setBlurRadius(int blurRadius)
 }
 
 /*!
-    \fn void QGraphicsDropShadowEffect::blurRadiusChanged(int blurRadius)
+    \fn void QGraphicsDropShadowEffect::blurRadiusChanged(qreal blurRadius)
 
     This signal is emitted whenever the effect's blur radius changes.
     The \a blurRadius parameter holds the effect's new blur radius.
@@ -1095,9 +899,13 @@ void QGraphicsDropShadowEffect::draw(QPainter *painter, QGraphicsEffectSource *s
         return;
     }
 
+    QGraphicsEffectSource::PixmapPadMode mode = QGraphicsEffectSource::ExpandToEffectRectPadMode;
+    if (painter->paintEngine()->type() == QPaintEngine::OpenGL2)
+        mode = QGraphicsEffectSource::ExpandToTransparentBorderPadMode;
+
     // Draw pixmap in device coordinates to avoid pixmap scaling.
     QPoint offset;
-    const QPixmap pixmap = source->pixmap(Qt::DeviceCoordinates, &offset);
+    const QPixmap pixmap = source->pixmap(Qt::DeviceCoordinates, &offset, mode);
     QTransform restoreTransform = painter->worldTransform();
     painter->setWorldTransform(QTransform());
     d->filter->draw(painter, offset, pixmap);
@@ -1117,8 +925,7 @@ void QGraphicsDropShadowEffect::draw(QPainter *painter, QGraphicsEffectSource *s
 
     \img graphicseffect-opacity.png
 
-    \sa QGraphicsDropShadowEffect, QGraphicsBlurEffect, QGraphicsPixelizeEffect,
-        QGraphicsGrayscaleEffect, QGraphicsColorizeEffect
+    \sa QGraphicsDropShadowEffect, QGraphicsBlurEffect, QGraphicsColorizeEffect
 */
 
 /*!
@@ -1242,7 +1049,8 @@ void QGraphicsOpacityEffect::draw(QPainter *painter, QGraphicsEffectSource *sour
     if (source->isPixmap()) {
         // No point in drawing in device coordinates (pixmap will be scaled anyways).
         if (!d->hasOpacityMask) {
-            const QPixmap pixmap = source->pixmap(Qt::LogicalCoordinates, &offset);
+            const QPixmap pixmap = source->pixmap(Qt::LogicalCoordinates, &offset,
+                                                  QGraphicsEffectSource::NoExpandPadMode);
             painter->drawPixmap(offset, pixmap);
         } else {
             QRect srcBrect = source->boundingRect().toAlignedRect();
@@ -1263,7 +1071,8 @@ void QGraphicsOpacityEffect::draw(QPainter *painter, QGraphicsEffectSource *sour
     } else {
         // Draw pixmap in device coordinates to avoid pixmap scaling;
         if (!d->hasOpacityMask) {
-            const QPixmap pixmap = source->pixmap(Qt::DeviceCoordinates, &offset);
+            const QPixmap pixmap = source->pixmap(Qt::DeviceCoordinates, &offset,
+                                                  QGraphicsEffectSource::NoExpandPadMode);
             painter->setWorldTransform(QTransform());
             painter->drawPixmap(offset, pixmap);
         } else {
@@ -1296,234 +1105,6 @@ void QGraphicsOpacityEffect::draw(QPainter *painter, QGraphicsEffectSource *sour
     painter->restore();
 }
 
-/*!
-    \class QGraphicsBloomEffect
-    \brief The QGraphicsBloomEffect class provides a bloom/glow effect.
-    \since 4.6
-
-    A bloom/glow effect adds fringes of light around bright areas in the source.
-
-    \img graphicseffect-bloom.png
-
-    \sa QGraphicsDropShadowEffect, QGraphicsBlurEffect, QGraphicsPixelizeEffect,
-        QGraphicsGrayscaleEffect, QGraphicsColorizeEffect
-*/
-
-/*!
-    Constructs a new QGraphicsBloomEffect instance.
-    The \a parent parameter is passed to QGraphicsEffect's constructor.
-*/
-QGraphicsBloomEffect::QGraphicsBloomEffect(QObject *parent)
-    : QGraphicsEffect(*new QGraphicsBloomEffectPrivate, parent)
-{
-    Q_D(QGraphicsBloomEffect);
-    for (int i = 0; i < 256; ++i)
-        d->colorTable[i] = qMin(i + d->brightness, 255);
-}
-
-/*!
-    Destroys the effect.
-*/
-QGraphicsBloomEffect::~QGraphicsBloomEffect()
-{
-}
-
-/*!
-    \reimp
-*/
-QRectF QGraphicsBloomEffect::boundingRectFor(const QRectF &rect) const
-{
-    Q_D(const QGraphicsBloomEffect);
-    const qreal delta = d->blurFilter.radius() * 2;
-    return rect.adjusted(-delta, -delta, delta, delta);
-}
-
-/*!
-    \property QGraphicsBloomEffect::blurRadius
-    \brief the blur radius in pixels of the effect.
-
-    Using a smaller radius results in a sharper appearance, whereas a bigger
-    radius results in a more blurred appearance.
-
-    By default, the blur radius is 5 pixels.
-
-    \sa strength(), brightness()
-*/
-int QGraphicsBloomEffect::blurRadius() const
-{
-    Q_D(const QGraphicsBloomEffect);
-    return d->blurFilter.radius();
-}
-
-void QGraphicsBloomEffect::setBlurRadius(int radius)
-{
-    Q_D(QGraphicsBloomEffect);
-    if (d->blurFilter.radius() == radius)
-        return;
-
-    d->blurFilter.setRadius(radius);
-    updateBoundingRect();
-    emit blurRadiusChanged(radius);
-}
-
-/*!
-    \fn void QGraphicsBloomEffect::blurRadiusChanged(int blurRadius)
-
-    This signal is emitted whenever the effect's blur radius changes.
-    The \a blurRadius parameter holds the effect's new blur radius.
-*/
-
-/*!
-    \property QGraphicsBloomEffect::blurHint
-    \brief the blur hint of the effect.
-
-    Use the Qt::PerformanceHint hint to say that you want a faster blur,
-    and the Qt::QualityHint hint to say that you prefer a higher quality blur.
-
-    When animating the blur radius it's recommended to use Qt::PerformanceHint.
-
-    By default, the blur hint is Qt::PerformanceHint.
-*/
-Qt::RenderHint QGraphicsBloomEffect::blurHint() const
-{
-    Q_D(const QGraphicsBloomEffect);
-    return d->blurFilter.blurHint();
-}
-
-void QGraphicsBloomEffect::setBlurHint(Qt::RenderHint hint)
-{
-    Q_D(QGraphicsBloomEffect);
-    if (d->blurFilter.blurHint() == hint)
-        return;
-
-    d->blurFilter.setBlurHint(hint);
-    emit blurHintChanged(hint);
-}
-
-/*!
-    \fn void QGraphicsBloomEffect::blurHintChanged(Qt::RenderHint hint)
-
-    This signal is emitted whenever the effect's blur hint changes.
-    The \a hint parameter holds the effect's new blur hint.
-*/
-
-/*!
-    \property QGraphicsBloomEffect::brightness
-    \brief the brightness of the glow.
-
-    The value should be in the range of 0 to 255, where 0 is dark
-    and 255 is bright.
-
-    By default, the brightness is 70.
-
-    \sa strength(), blurRadius()
-*/
-int QGraphicsBloomEffect::brightness() const
-{
-    Q_D(const QGraphicsBloomEffect);
-    return d->brightness;
-}
-
-void QGraphicsBloomEffect::setBrightness(int brightness)
-{
-    Q_D(QGraphicsBloomEffect);
-    brightness = qBound(0, brightness, 255);
-    if (d->brightness == brightness)
-        return;
-
-    d->brightness = brightness;
-    for (int i = 0; i < 256; ++i)
-        d->colorTable[i] = qMin(i + brightness, 255);
-
-    update();
-    emit brightnessChanged(brightness);
-}
-
-/*!
-    \fn void QGraphicsBloomEffect::brightnessChanged(int brightness)
-
-    This signal is emitted whenever the effect's brightness changes.
-    The \a brightness parameter holds the effect's new brightness.
-*/
-
-/*!
-    \property QGraphicsBloomEffect::strength
-    \brief the strength of the effect.
-
-    A strength 0.0 equals to no effect, while 1.0 means maximum glow.
-
-    By default, the strength is 0.7.
-*/
-qreal QGraphicsBloomEffect::strength() const
-{
-    Q_D(const QGraphicsBloomEffect);
-    return d->strength;
-}
-
-void QGraphicsBloomEffect::setStrength(qreal strength)
-{
-    Q_D(QGraphicsBloomEffect);
-    strength = qBound(qreal(0.0), strength, qreal(1.0));
-    if (qFuzzyCompare(d->strength, strength))
-        return;
-
-    d->strength = strength;
-    update();
-    emit strengthChanged(strength);
-}
-
-/*!
-    \fn void QGraphicsBloomEffect::strengthChanged(qreal strength)
-
-    This signal is emitted whenever the effect's strength changes.
-    The \a strength parameter holds the effect's new strength.
-*/
-
-extern QPixmap qt_toRasterPixmap(const QPixmap &pixmap);
-
-/*!
-    \reimp
-*/
-void QGraphicsBloomEffect::draw(QPainter *painter, QGraphicsEffectSource *source)
-{
-    Q_D(QGraphicsBloomEffect);
-    if (d->strength < 0.001) {
-        source->draw(painter);
-        return;
-    }
-
-    QPoint offset;
-    QPixmap pixmap = qt_toRasterPixmap(source->pixmap(Qt::DeviceCoordinates, &offset));
-
-    // Blur.
-    QImage overlay(pixmap.size(), QImage::Format_ARGB32_Premultiplied);
-    overlay.fill(0);
-
-    QPainter blurPainter(&overlay);
-    d->blurFilter.draw(&blurPainter, QPointF(), pixmap);
-    blurPainter.end();
-
-    // Brighten.
-    const int numBits = overlay.width() * overlay.height();
-    QRgb *bits = reinterpret_cast<QRgb *>(overlay.bits());
-    for (int i = 0; i < numBits; ++i) {
-        const QRgb pixel = INV_PREMUL(bits[i]);
-        bits[i] = PREMUL(qRgba(d->colorTable[qRed(pixel)], d->colorTable[qGreen(pixel)],
-                               d->colorTable[qBlue(pixel)], qAlpha(pixel)));
-    }
-
-    // Composite.
-    QPainter compPainter(&pixmap);
-    compPainter.setCompositionMode(QPainter::CompositionMode_Overlay);
-    compPainter.setOpacity(d->strength);
-    compPainter.drawImage(0, 0, overlay);
-    compPainter.end();
-
-    QTransform restoreTransform = painter->worldTransform();
-    painter->setWorldTransform(QTransform());
-    painter->drawPixmap(offset, pixmap);
-    painter->setWorldTransform(restoreTransform);
-}
 
 QT_END_NAMESPACE
 
diff --git a/src/gui/effects/qgraphicseffect.h b/src/gui/effects/qgraphicseffect.h
index c89851e..bf18581 100644
--- a/src/gui/effects/qgraphicseffect.h
+++ b/src/gui/effects/qgraphicseffect.h
@@ -64,6 +64,12 @@ class Q_GUI_EXPORT QGraphicsEffectSource : public QObject
 {
     Q_OBJECT
 public:
+    enum PixmapPadMode {
+        NoExpandPadMode,
+        ExpandToTransparentBorderPadMode,
+        ExpandToEffectRectPadMode
+    };
+
     ~QGraphicsEffectSource();
     const QGraphicsItem *graphicsItem() const;
     const QWidget *widget() const;
@@ -75,7 +81,9 @@ public:
 
     QRectF boundingRect(Qt::CoordinateSystem coordinateSystem = Qt::LogicalCoordinates) const;
     QRect deviceRect() const;
-    QPixmap pixmap(Qt::CoordinateSystem system = Qt::LogicalCoordinates, QPoint *offset = 0) const;
+    QPixmap pixmap(Qt::CoordinateSystem system = Qt::LogicalCoordinates,
+                   QPoint *offset = 0,
+                   PixmapPadMode mode = ExpandToEffectRectPadMode) const;
 
 protected:
     QGraphicsEffectSource(QGraphicsEffectSourcePrivate &dd, QObject *parent = 0);
@@ -141,31 +149,6 @@ private:
 };
 Q_DECLARE_OPERATORS_FOR_FLAGS(QGraphicsEffect::ChangeFlags)
 
-class QGraphicsGrayscaleEffectPrivate;
-class Q_GUI_EXPORT QGraphicsGrayscaleEffect: public QGraphicsEffect
-{
-    Q_OBJECT
-    Q_PROPERTY(qreal strength READ strength WRITE setStrength NOTIFY strengthChanged)
-public:
-    QGraphicsGrayscaleEffect(QObject *parent = 0);
-    ~QGraphicsGrayscaleEffect();
-
-    qreal strength() const;
-
-protected:
-    void draw(QPainter *painter, QGraphicsEffectSource *source);
-
-public Q_SLOTS:
-    void setStrength(qreal strength);
-
-Q_SIGNALS:
-    void strengthChanged(qreal strength);
-
-private:
-    Q_DECLARE_PRIVATE(QGraphicsGrayscaleEffect)
-    Q_DISABLE_COPY(QGraphicsGrayscaleEffect)
-};
-
 class QGraphicsColorizeEffectPrivate;
 class Q_GUI_EXPORT QGraphicsColorizeEffect: public QGraphicsEffect
 {
@@ -195,51 +178,26 @@ private:
     Q_DISABLE_COPY(QGraphicsColorizeEffect)
 };
 
-class QGraphicsPixelizeEffectPrivate;
-class Q_GUI_EXPORT QGraphicsPixelizeEffect: public QGraphicsEffect
-{
-    Q_OBJECT
-    Q_PROPERTY(int pixelSize READ pixelSize WRITE setPixelSize NOTIFY pixelSizeChanged)
-public:
-    QGraphicsPixelizeEffect(QObject *parent = 0);
-    ~QGraphicsPixelizeEffect();
-
-    int pixelSize() const;
-
-public Q_SLOTS:
-    void setPixelSize(int pixelSize);
-
-Q_SIGNALS:
-    void pixelSizeChanged(int pixelSize);
-
-protected:
-    void draw(QPainter *painter, QGraphicsEffectSource *source);
-
-private:
-    Q_DECLARE_PRIVATE(QGraphicsPixelizeEffect)
-    Q_DISABLE_COPY(QGraphicsPixelizeEffect)
-};
-
 class QGraphicsBlurEffectPrivate;
 class Q_GUI_EXPORT QGraphicsBlurEffect: public QGraphicsEffect
 {
     Q_OBJECT
-    Q_PROPERTY(int blurRadius READ blurRadius WRITE setBlurRadius NOTIFY blurRadiusChanged)
+    Q_PROPERTY(qreal blurRadius READ blurRadius WRITE setBlurRadius NOTIFY blurRadiusChanged)
     Q_PROPERTY(Qt::RenderHint blurHint READ blurHint WRITE setBlurHint NOTIFY blurHintChanged)
 public:
     QGraphicsBlurEffect(QObject *parent = 0);
     ~QGraphicsBlurEffect();
 
     QRectF boundingRectFor(const QRectF &rect) const;
-    int blurRadius() const;
+    qreal blurRadius() const;
     Qt::RenderHint blurHint() const;
 
 public Q_SLOTS:
-    void setBlurRadius(int blurRadius);
+    void setBlurRadius(qreal blurRadius);
     void setBlurHint(Qt::RenderHint hint);
 
 Q_SIGNALS:
-    void blurRadiusChanged(int blurRadius);
+    void blurRadiusChanged(qreal blurRadius);
     void blurHintChanged(Qt::RenderHint hint);
 
 protected:
@@ -257,7 +215,7 @@ class Q_GUI_EXPORT QGraphicsDropShadowEffect: public QGraphicsEffect
     Q_PROPERTY(QPointF offset READ offset WRITE setOffset NOTIFY offsetChanged)
     Q_PROPERTY(qreal xOffset READ xOffset WRITE setXOffset NOTIFY offsetChanged)
     Q_PROPERTY(qreal yOffset READ yOffset WRITE setYOffset NOTIFY offsetChanged)
-    Q_PROPERTY(int blurRadius READ blurRadius WRITE setBlurRadius NOTIFY blurRadiusChanged)
+    Q_PROPERTY(qreal blurRadius READ blurRadius WRITE setBlurRadius NOTIFY blurRadiusChanged)
     Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
 public:
     QGraphicsDropShadowEffect(QObject *parent = 0);
@@ -272,7 +230,7 @@ public:
     inline qreal yOffset() const
     { return offset().y(); }
 
-    int blurRadius() const;
+    qreal blurRadius() const;
     QColor color() const;
 
 public Q_SLOTS:
@@ -290,12 +248,12 @@ public Q_SLOTS:
     inline void setYOffset(qreal dy)
     { setOffset(QPointF(xOffset(), dy)); }
 
-    void setBlurRadius(int blurRadius);
+    void setBlurRadius(qreal blurRadius);
     void setColor(const QColor &color);
 
 Q_SIGNALS:
     void offsetChanged(const QPointF &offset);
-    void blurRadiusChanged(int blurRadius);
+    void blurRadiusChanged(qreal blurRadius);
     void colorChanged(const QColor &color);
 
 protected:
@@ -335,44 +293,6 @@ private:
     Q_DISABLE_COPY(QGraphicsOpacityEffect)
 };
 
-class QGraphicsBloomEffectPrivate;
-class Q_GUI_EXPORT QGraphicsBloomEffect: public QGraphicsEffect
-{
-    Q_OBJECT
-    Q_PROPERTY(int blurRadius READ blurRadius WRITE setBlurRadius NOTIFY blurRadiusChanged)
-    Q_PROPERTY(Qt::RenderHint blurHint READ blurHint WRITE setBlurHint NOTIFY blurHintChanged)
-    Q_PROPERTY(int brightness READ brightness WRITE setBrightness NOTIFY brightnessChanged)
-    Q_PROPERTY(qreal strength READ strength WRITE setStrength NOTIFY strengthChanged)
-public:
-    QGraphicsBloomEffect(QObject *parent = 0);
-    ~QGraphicsBloomEffect();
-
-    QRectF boundingRectFor(const QRectF &rect) const;
-    int blurRadius() const;
-    Qt::RenderHint blurHint() const;
-    int brightness() const;
-    qreal strength() const;
-
-public Q_SLOTS:
-    void setBlurRadius(int blurRadius);
-    void setBlurHint(Qt::RenderHint hint);
-    void setBrightness(int brightness);
-    void setStrength(qreal strength);
-
-Q_SIGNALS:
-    void blurRadiusChanged(int blurRadius);
-    void blurHintChanged(Qt::RenderHint hint);
-    void brightnessChanged(int brightness);
-    void strengthChanged(qreal strength);
-
-protected:
-    void draw(QPainter *painter, QGraphicsEffectSource *source);
-
-private:
-    Q_DECLARE_PRIVATE(QGraphicsBloomEffect)
-    Q_DISABLE_COPY(QGraphicsBloomEffect)
-};
-
 QT_END_NAMESPACE
 
 QT_END_HEADER
diff --git a/src/gui/effects/qgraphicseffect_p.h b/src/gui/effects/qgraphicseffect_p.h
index fc925f2..1ed7103 100644
--- a/src/gui/effects/qgraphicseffect_p.h
+++ b/src/gui/effects/qgraphicseffect_p.h
@@ -66,7 +66,12 @@ class QGraphicsEffectSourcePrivate : public QObjectPrivate
 {
     Q_DECLARE_PUBLIC(QGraphicsEffectSource)
 public:
-    QGraphicsEffectSourcePrivate() : QObjectPrivate() {}
+    QGraphicsEffectSourcePrivate()
+        : QObjectPrivate()
+        , m_cachedSystem(Qt::DeviceCoordinates)
+        , m_cachedMode(QGraphicsEffectSource::ExpandToTransparentBorderPadMode)
+    {}
+
     virtual ~QGraphicsEffectSourcePrivate() { invalidateCache(); }
     virtual void detach() = 0;
     virtual QRectF boundingRect(Qt::CoordinateSystem system) const = 0;
@@ -77,7 +82,8 @@ public:
     virtual void draw(QPainter *p) = 0;
     virtual void update() = 0;
     virtual bool isPixmap() const = 0;
-    virtual QPixmap pixmap(Qt::CoordinateSystem system, QPoint *offset = 0) const = 0;
+    virtual QPixmap pixmap(Qt::CoordinateSystem system, QPoint *offset = 0,
+                           QGraphicsEffectSource::PixmapPadMode mode = QGraphicsEffectSource::ExpandToTransparentBorderPadMode) const = 0;
     virtual void effectBoundingRectChanged() = 0;
     void invalidateCache() const { QPixmapCache::remove(m_cacheKey); }
 
@@ -87,6 +93,7 @@ public:
 
 private:
     mutable Qt::CoordinateSystem m_cachedSystem;
+    mutable QGraphicsEffectSource::PixmapPadMode m_cachedMode;
     mutable QPoint m_cachedOffset;
     mutable QPixmapCache::Key m_cacheKey;
 };
@@ -118,22 +125,6 @@ public:
     quint32 padding : 31; // feel free to use
 };
 
-class QGraphicsGrayscaleEffectPrivate : public QGraphicsEffectPrivate
-{
-    Q_DECLARE_PUBLIC(QGraphicsGrayscaleEffect)
-public:
-    QGraphicsGrayscaleEffectPrivate()
-        : opaque(true)
-    {
-        filter = new QPixmapColorizeFilter;
-        filter->setColor(Qt::black);
-    }
-    ~QGraphicsGrayscaleEffectPrivate() { delete filter; }
-
-    QPixmapColorizeFilter *filter;
-    quint32 opaque : 1;
-    quint32 padding : 31;
-};
 
 class QGraphicsColorizeEffectPrivate : public QGraphicsEffectPrivate
 {
@@ -151,15 +142,6 @@ public:
     quint32 padding : 31;
 };
 
-class QGraphicsPixelizeEffectPrivate : public QGraphicsEffectPrivate
-{
-    Q_DECLARE_PUBLIC(QGraphicsPixelizeEffect)
-public:
-    QGraphicsPixelizeEffectPrivate() : pixelSize(3) {}
-
-    int pixelSize;
-};
-
 class QGraphicsBlurEffectPrivate : public QGraphicsEffectPrivate
 {
     Q_DECLARE_PUBLIC(QGraphicsBlurEffect)
@@ -195,18 +177,6 @@ public:
     uint hasOpacityMask : 1;
 };
 
-class QGraphicsBloomEffectPrivate : public QGraphicsEffectPrivate
-{
-    Q_DECLARE_PUBLIC(QGraphicsBlurEffect)
-public:
-    QGraphicsBloomEffectPrivate() : brightness(70), strength(qreal(0.7)) {}
-
-    QPixmapBlurFilter blurFilter;
-    int colorTable[256];
-    int brightness;
-    qreal strength;
-};
-
 QT_END_NAMESPACE
 
 #endif // QGRAPHICSEFFECT_P_H
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index 2685b86..738c6e3 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -1658,7 +1658,7 @@ void QGraphicsItem::setFlags(GraphicsItemFlags flags)
         d_ptr->scene->d_func()->index->itemChange(this, ItemFlagsChange, quint32(flags));
 
     // Flags that alter the geometry of the item (or its children).
-    const quint32 geomChangeFlagsMask = (ItemClipsChildrenToShape | ItemClipsToShape | ItemIgnoresTransformations);
+    const quint32 geomChangeFlagsMask = (ItemClipsChildrenToShape | ItemClipsToShape | ItemIgnoresTransformations | ItemIsSelectable);
     bool fullUpdate = (quint32(flags) & geomChangeFlagsMask) != (d_ptr->flags & geomChangeFlagsMask);
     if (fullUpdate)
         d_ptr->paintedViewBoundingRectsNeedRepaint = 1;
@@ -9157,10 +9157,14 @@ void QGraphicsPixmapItem::setOffset(const QPointF &offset)
 QRectF QGraphicsPixmapItem::boundingRect() const
 {
     Q_D(const QGraphicsPixmapItem);
-    qreal pw = 1.0;
     if (d->pixmap.isNull())
         return QRectF();
-    return QRectF(d->offset, d->pixmap.size()).adjusted(-pw/2, -pw/2, pw/2, pw/2);
+    if (d->flags & ItemIsSelectable) {
+        qreal pw = 1.0;
+        return QRectF(d->offset, d->pixmap.size()).adjusted(-pw/2, -pw/2, pw/2, pw/2);
+    } else {
+        return QRectF(d->offset, d->pixmap.size());
+    }
 }
 
 /*!
@@ -10679,7 +10683,8 @@ void QGraphicsItemEffectSourcePrivate::draw(QPainter *painter)
     }
 }
 
-QPixmap QGraphicsItemEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset) const
+QPixmap QGraphicsItemEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset,
+                                                 QGraphicsEffectSource::PixmapPadMode mode) const
 {
     const bool deviceCoordinates = (system == Qt::DeviceCoordinates);
     if (!info && deviceCoordinates) {
@@ -10693,7 +10698,17 @@ QPixmap QGraphicsItemEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QP
     QGraphicsScenePrivate *scened = item->d_ptr->scene->d_func();
 
     const QRectF sourceRect = boundingRect(system);
-    QRect effectRect = item->graphicsEffect()->boundingRectFor(sourceRect).toAlignedRect();
+    QRect effectRect;
+
+    if (mode == QGraphicsEffectSource::ExpandToEffectRectPadMode) {
+        effectRect = item->graphicsEffect()->boundingRectFor(sourceRect).toAlignedRect();
+    } else if (mode == QGraphicsEffectSource::ExpandToTransparentBorderPadMode) {
+        // adjust by 1.5 to account for cosmetic pens
+        effectRect = sourceRect.adjusted(-1.5, -1.5, 1.5, 1.5).toAlignedRect();
+    } else {
+        effectRect = sourceRect.toAlignedRect();
+    }
+
     if (offset)
         *offset = effectRect.topLeft();
 
@@ -10721,10 +10736,15 @@ QPixmap QGraphicsItemEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QP
             effectRect.setBottom(deviceHeight -1);
 
     }
-
     if (effectRect.isEmpty())
         return QPixmap();
 
+    if (system == Qt::LogicalCoordinates
+        && effectRect.size() == sourceRect.size()
+        && isPixmap()) {
+        return static_cast<QGraphicsPixmapItem *>(item)->pixmap();
+    }
+
     QPixmap pixmap(effectRect.size());
     pixmap.fill(Qt::transparent);
     QPainter pixmapPainter(&pixmap);
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index 7c3c4f0..183e95b 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -61,6 +61,7 @@
 #include <private/qgraphicstransform_p.h>
 
 #include <private/qgraphicseffect_p.h>
+#include <qgraphicseffect.h>
 
 #include <QtCore/qpoint.h>
 
@@ -603,7 +604,9 @@ public:
 
     inline bool isPixmap() const
     {
-        return (item->type() == QGraphicsPixmapItem::Type);
+        return item->type() == QGraphicsPixmapItem::Type
+               && !(item->flags() & QGraphicsItem::ItemIsSelectable)
+               && item->d_ptr->children.size() == 0;
             //|| (item->d_ptr->isObject && qobject_cast<QFxImage *>(q_func()));
     }
 
@@ -621,7 +624,9 @@ public:
 
     QRectF boundingRect(Qt::CoordinateSystem system) const;
     void draw(QPainter *);
-    QPixmap pixmap(Qt::CoordinateSystem system, QPoint *offset) const;
+    QPixmap pixmap(Qt::CoordinateSystem system,
+                   QPoint *offset,
+                   QGraphicsEffectSource::PixmapPadMode mode) const;
 
     QGraphicsItem *item;
     QGraphicsItemPaintInfo *info;
diff --git a/src/gui/image/qnativeimage.cpp b/src/gui/image/qnativeimage.cpp
index 88faea8..e4ea2e9 100644
--- a/src/gui/image/qnativeimage.cpp
+++ b/src/gui/image/qnativeimage.cpp
@@ -199,10 +199,12 @@ QNativeImage::QNativeImage(int width, int height, QImage::Format format,bool /*
             shmctl(xshminfo.shmid, IPC_RMID, 0);
         return;
     }
-    xshmpm = XShmCreatePixmap(X11->display, DefaultRootWindow(X11->display), xshmimg->data,
-                              &xshminfo, width, height, dd);
-    if (!xshmpm) {
-        qWarning() << "QNativeImage: Unable to create shared Pixmap.";
+    if (X11->use_mitshm_pixmaps) {
+        xshmpm = XShmCreatePixmap(X11->display, DefaultRootWindow(X11->display), xshmimg->data,
+                                  &xshminfo, width, height, dd);
+        if (!xshmpm) {
+            qWarning() << "QNativeImage: Unable to create shared Pixmap.";
+        }
     }
 }
 
diff --git a/src/gui/image/qpixmapfilter.cpp b/src/gui/image/qpixmapfilter.cpp
index 9fcf776..d0de03e 100644
--- a/src/gui/image/qpixmapfilter.cpp
+++ b/src/gui/image/qpixmapfilter.cpp
@@ -506,7 +506,7 @@ class QPixmapBlurFilterPrivate : public QPixmapFilterPrivate
 public:
     QPixmapBlurFilterPrivate() : radius(5), hint(Qt::PerformanceHint) {}
 
-    int radius;
+    qreal radius;
     Qt::RenderHint hint;
 };
 
@@ -535,7 +535,7 @@ QPixmapBlurFilter::~QPixmapBlurFilter()
 
     \internal
 */
-void QPixmapBlurFilter::setRadius(int radius)
+void QPixmapBlurFilter::setRadius(qreal radius)
 {
     Q_D(QPixmapBlurFilter);
     d->radius = radius;
@@ -546,7 +546,7 @@ void QPixmapBlurFilter::setRadius(int radius)
 
     \internal
 */
-int QPixmapBlurFilter::radius() const
+qreal QPixmapBlurFilter::radius() const
 {
     Q_D(const QPixmapBlurFilter);
     return d->radius;
@@ -584,7 +584,7 @@ Qt::RenderHint QPixmapBlurFilter::blurHint() const
 QRectF QPixmapBlurFilter::boundingRectFor(const QRectF &rect) const
 {
     Q_D(const QPixmapBlurFilter);
-    const qreal delta = d->radius * 2;
+    const qreal delta = d->radius + 1;
     return rect.adjusted(-delta, -delta, delta, delta);
 }
 
@@ -668,7 +668,7 @@ void QPixmapBlurFilter::draw(QPainter *painter, const QPointF &p, const QPixmap
     if (!painter->isActive())
         return;
 
-    if (d->radius == 0) {
+    if (d->radius <= 0) {
         painter->drawPixmap(srcRect.translated(p), src, srcRect);
         return;
     }
@@ -688,12 +688,12 @@ void QPixmapBlurFilter::draw(QPainter *painter, const QPointF &p, const QPixmap
 
     if (srcRect.isNull()) {
         srcImage = src.toImage();
-        destImage = blurred(srcImage, srcImage.rect(), d->radius);
+        destImage = blurred(srcImage, srcImage.rect(), qRound(d->radius));
     } else {
         QRect rect = srcRect.toAlignedRect().intersected(src.rect());
 
         srcImage = src.copy(rect).toImage();
-        destImage = blurred(srcImage, srcImage.rect(), d->radius);
+        destImage = blurred(srcImage, srcImage.rect(), qRound(d->radius));
     }
 
     painter->drawImage(p, destImage);
@@ -902,7 +902,7 @@ public:
 
     QPointF offset;
     QColor color;
-    int radius;
+    qreal radius;
 };
 
 /*!
@@ -966,7 +966,7 @@ QPixmapDropShadowFilter::~QPixmapDropShadowFilter()
 
     \internal
 */
-int QPixmapDropShadowFilter::blurRadius() const
+qreal QPixmapDropShadowFilter::blurRadius() const
 {
     Q_D(const QPixmapDropShadowFilter);
     return d->radius;
@@ -981,7 +981,7 @@ int QPixmapDropShadowFilter::blurRadius() const
 
     \internal
 */
-void QPixmapDropShadowFilter::setBlurRadius(int radius)
+void QPixmapDropShadowFilter::setBlurRadius(qreal radius)
 {
     Q_D(QPixmapDropShadowFilter);
     d->radius = radius;
@@ -1057,14 +1057,9 @@ void QPixmapDropShadowFilter::setOffset(const QPointF &offset)
 QRectF QPixmapDropShadowFilter::boundingRectFor(const QRectF &rect) const
 {
     Q_D(const QPixmapDropShadowFilter);
-
-    const qreal delta = qreal(d->radius * 2);
-    qreal x1 = qMin(rect.left(), rect.left() + d->offset.x() - delta);
-    qreal y1 = qMin(rect.top(), rect.top() + d->offset.y() - delta);
-    qreal x2 = qMax(rect.right(), rect.right() + d->offset.x() + delta);
-    qreal y2 = qMax(rect.bottom(), rect.bottom() + d->offset.y() + delta);
-
-    return QRectF(x1, y1, x2 - x1, y2 - y1);
+    qreal delta = d->radius + 1;
+    return rect.adjusted(-2, -2, 2, 2).united(
+            rect.translated(d->offset).adjusted(-delta, -delta, delta, delta));
 }
 
 /*!
@@ -1090,7 +1085,7 @@ void QPixmapDropShadowFilter::draw(QPainter *p,
     QImage tmp = src.isNull() ? px.toImage() : px.copy(src.toAlignedRect()).toImage();
 
     // blur the alpha channel
-    tmp = blurred(tmp, tmp.rect(), d->radius, true);
+    tmp = blurred(tmp, tmp.rect(), qRound(d->radius), true);
 
     // blacken the image...
     QPainter tmpPainter(&tmp);
diff --git a/src/gui/image/qpixmapfilter_p.h b/src/gui/image/qpixmapfilter_p.h
index 8a2207a..fc70795 100644
--- a/src/gui/image/qpixmapfilter_p.h
+++ b/src/gui/image/qpixmapfilter_p.h
@@ -129,10 +129,10 @@ public:
     QPixmapBlurFilter(QObject *parent = 0);
     ~QPixmapBlurFilter();
 
-    void setRadius(int radius);
+    void setRadius(qreal radius);
     void setBlurHint(Qt::RenderHint hint);
 
-    int radius() const;
+    qreal radius() const;
     Qt::RenderHint blurHint() const;
 
     QRectF boundingRectFor(const QRectF &rect) const;
@@ -175,8 +175,8 @@ public:
     QRectF boundingRectFor(const QRectF &rect) const;
     void draw(QPainter *p, const QPointF &pos, const QPixmap &px, const QRectF &src = QRectF()) const;
 
-    int blurRadius() const;
-    void setBlurRadius(int radius);
+    qreal blurRadius() const;
+    void setBlurRadius(qreal radius);
 
     QColor color() const;
     void setColor(const QColor &color);
diff --git a/src/gui/inputmethod/qwininputcontext_win.cpp b/src/gui/inputmethod/qwininputcontext_win.cpp
index e9ab870..ef2f5c0 100644
--- a/src/gui/inputmethod/qwininputcontext_win.cpp
+++ b/src/gui/inputmethod/qwininputcontext_win.cpp
@@ -327,28 +327,13 @@ static int getCursorPosition(HIMC himc)
 
 static QString getString(HIMC himc, DWORD dwindex, int *selStart = 0, int *selLength = 0)
 {
-    static wchar_t *buffer = 0;
-    static int buflen = 0;
-
-    int len = getCompositionString(himc, dwindex, 0, 0) + 1;
-    if (!buffer || len > buflen) {
-        delete [] buffer;
-        buflen = qMin(len, 256);
-        buffer = new wchar_t[buflen];
-    }
-
-    len = getCompositionString(himc, dwindex, buffer, buflen * sizeof(wchar_t));
+    const int bufferSize = 256;
+    wchar_t buffer[bufferSize];
+    int len = getCompositionString(himc, dwindex, buffer, bufferSize * sizeof(wchar_t));
 
     if (selStart) {
-        static wchar_t *attrbuffer = 0;
-        static int attrbuflen = 0;
-        int attrlen = getCompositionString(himc, dwindex, 0, 0) + 1;
-        if (!attrbuffer || attrlen> attrbuflen) {
-            delete [] attrbuffer;
-            attrbuflen = qMin(attrlen, 256);
-            attrbuffer = new wchar_t[attrbuflen];
-        }
-        attrlen = getCompositionString(himc, GCS_COMPATTR, attrbuffer, attrbuflen * sizeof(wchar_t));
+        char attrbuffer[bufferSize];
+        int attrlen = getCompositionString(himc, GCS_COMPATTR, attrbuffer, bufferSize);
         *selStart = attrlen+1;
         *selLength = -1;
         for (int i = 0; i < attrlen; i++) {
diff --git a/src/gui/kernel/qapplication_x11.cpp b/src/gui/kernel/qapplication_x11.cpp
index bf95684..7f11faa 100644
--- a/src/gui/kernel/qapplication_x11.cpp
+++ b/src/gui/kernel/qapplication_x11.cpp
@@ -1625,6 +1625,7 @@ void qt_init(QApplicationPrivate *priv, int,
 
     // MIT-SHM
     X11->use_mitshm = false;
+    X11->use_mitshm_pixmaps = false;
     X11->mitshm_major = 0;
 
     X11->sip_serial = 0;
@@ -1918,12 +1919,13 @@ void qt_init(QApplicationPrivate *priv, int,
             bool local = displayName.isEmpty() || displayName.lastIndexOf(QLatin1Char(':')) == 0;
             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->red_mask == 0xf800)
-                                                     && (defaultVisual->green_mask == 0xff00
-                                                         || defaultVisual->green_mask == 0x7e0)
-                                                     && (defaultVisual->blue_mask == 0xff
-                                                         || defaultVisual->blue_mask == 0x1f));
+                X11->use_mitshm = ((defaultVisual->red_mask == 0xff0000
+                                    || defaultVisual->red_mask == 0xf800)
+                                   && (defaultVisual->green_mask == 0xff00
+                                       || defaultVisual->green_mask == 0x7e0)
+                                   && (defaultVisual->blue_mask == 0xff
+                                       || defaultVisual->blue_mask == 0x1f));
+                X11->use_mitshm_pixmaps = X11->use_mitshm && mitshm_pixmaps;
             }
         }
 #endif // QT_NO_MITSHM
diff --git a/src/gui/kernel/qt_cocoa_helpers_mac_p.h b/src/gui/kernel/qt_cocoa_helpers_mac_p.h
index 62db064..5318d31 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac_p.h
+++ b/src/gui/kernel/qt_cocoa_helpers_mac_p.h
@@ -116,7 +116,7 @@ typedef struct CGPoint NSPoint;
 QT_BEGIN_NAMESPACE
 Qt::MouseButtons qt_mac_get_buttons(int buttons);
 Qt::MouseButton qt_mac_get_button(EventMouseButton button);
-void macWindowFade(void * /*OSWindowRef*/ window, float durationSeconds = 0);
+void macWindowFade(void * /*OSWindowRef*/ window, float durationSeconds = 0.15);
 bool macWindowIsTextured(void * /*OSWindowRef*/ window);
 void macWindowToolbarShow(const QWidget *widget, bool show );
 void macWindowToolbarSet( void * /*OSWindowRef*/ window, void* toolbarRef );
diff --git a/src/gui/kernel/qt_x11_p.h b/src/gui/kernel/qt_x11_p.h
index 61acbac..9f08dc6 100644
--- a/src/gui/kernel/qt_x11_p.h
+++ b/src/gui/kernel/qt_x11_p.h
@@ -428,6 +428,7 @@ struct QX11Data
 
     // true if Qt is compiled w/ MIT-SHM support and MIT-SHM is supported on the connected Display
     bool use_mitshm;
+    bool use_mitshm_pixmaps;
     int mitshm_major;
 
     // true if Qt is compiled w/ Tablet support and we have a tablet.
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index 5fa9a92..27e73e0 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -5437,7 +5437,8 @@ void QWidgetEffectSourcePrivate::draw(QPainter *painter)
                    context->sharedPainter, context->backingStore);
 }
 
-QPixmap QWidgetEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset) const
+QPixmap QWidgetEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset,
+                                           QGraphicsEffectSource::PixmapPadMode mode) const
 {
     const bool deviceCoordinates = (system == Qt::DeviceCoordinates);
     if (!context && deviceCoordinates) {
@@ -5455,7 +5456,20 @@ QPixmap QWidgetEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *
         pixmapOffset = painterTransform.map(pixmapOffset);
     }
 
-    QRect effectRect = m_widget->graphicsEffect()->boundingRectFor(sourceRect).toAlignedRect();
+
+    QRect effectRect;
+
+    if (mode == QGraphicsEffectSource::ExpandToEffectRectPadMode) {
+        effectRect = m_widget->graphicsEffect()->boundingRectFor(sourceRect).toAlignedRect();
+
+    } else if (mode == QGraphicsEffectSource::ExpandToTransparentBorderPadMode) {
+        effectRect = sourceRect.adjusted(-1, -1, 1, 1).toAlignedRect();
+
+    } else {
+        effectRect = sourceRect.toAlignedRect();
+
+    }
+
     if (offset)
         *offset = effectRect.topLeft();
 
diff --git a/src/gui/kernel/qwidget_mac.mm b/src/gui/kernel/qwidget_mac.mm
index 95c0bed..58252ca 100644
--- a/src/gui/kernel/qwidget_mac.mm
+++ b/src/gui/kernel/qwidget_mac.mm
@@ -2896,6 +2896,7 @@ void QWidgetPrivate::setCursor_sys(const QCursor &)
 #else
      Q_Q(QWidget);
     if (q->testAttribute(Qt::WA_WState_Created)) {
+        QMacCocoaAutoReleasePool pool;
         [qt_mac_window_for(q) invalidateCursorRectsForView:qt_mac_nativeview_for(q)];
     }
 #endif
@@ -2908,6 +2909,7 @@ void QWidgetPrivate::unsetCursor_sys()
 #else
      Q_Q(QWidget);
     if (q->testAttribute(Qt::WA_WState_Created)) {
+        QMacCocoaAutoReleasePool pool;
         [qt_mac_window_for(q) invalidateCursorRectsForView:qt_mac_nativeview_for(q)];
     }
 #endif
diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h
index 159a3f2..616a972 100644
--- a/src/gui/kernel/qwidget_p.h
+++ b/src/gui/kernel/qwidget_p.h
@@ -819,7 +819,8 @@ public:
 
     QRectF boundingRect(Qt::CoordinateSystem system) const;
     void draw(QPainter *p);
-    QPixmap pixmap(Qt::CoordinateSystem system, QPoint *offset) const;
+    QPixmap pixmap(Qt::CoordinateSystem system, QPoint *offset,
+                   QGraphicsEffectSource::PixmapPadMode mode) const;
 
     QWidget *m_widget;
     QWidgetPaintContext *context;
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index fd0e810..8d0b961 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -1686,7 +1686,7 @@ void QRasterPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
     if (!s->penData.blend)
         return;
 
-    if (s->flags.fast_pen && path.shape() <= QVectorPath::NonCurvedShapeHint
+    if (s->flags.fast_pen && !path.isCurved()
         && s->lastPen.brush().isOpaque()) {
         int count = path.elementCount();
         QPointF *points = (QPointF *) path.points();
@@ -1739,8 +1739,7 @@ void QRasterPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
         const QLineF *lines = reinterpret_cast<const QLineF *>(path.points());
 
         for (int i = 0; i < lineCount; ++i) {
-            if (path.shape() == QVectorPath::LinesHint)
-                dashOffset = s->lastPen.dashOffset();
+            dashOffset = s->lastPen.dashOffset();
             if (lines[i].p1() == lines[i].p2()) {
                 if (s->lastPen.capStyle() != Qt::FlatCap) {
                     QPointF p = lines[i].p1();
@@ -5120,6 +5119,9 @@ void QSpanData::adjustSpanMethods()
 #else
         unclipped_blend = qBlendTexture;
 #endif
+        if (!texture.imageData)
+            unclipped_blend = 0;
+
         break;
     }
     // setup clipping
diff --git a/src/gui/painting/qpaintengine_x11.cpp b/src/gui/painting/qpaintengine_x11.cpp
index 59482c6..35b77f7 100644
--- a/src/gui/painting/qpaintengine_x11.cpp
+++ b/src/gui/painting/qpaintengine_x11.cpp
@@ -146,7 +146,7 @@ static inline int qpainterOpToXrender(QPainter::CompositionMode mode)
 
 // hack, so we don't have to make QRegion::clipRectangles() public or include
 // X11 headers in qregion.h
-Q_AUTOTEST_EXPORT void *qt_getClipRects(const QRegion &r, int &num)
+Q_GUI_EXPORT void *qt_getClipRects(const QRegion &r, int &num)
 {
     return r.clipRectangles(num);
 }
diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp
index 195be0a..9e21182 100644
--- a/src/gui/painting/qpaintengineex.cpp
+++ b/src/gui/painting/qpaintengineex.cpp
@@ -92,6 +92,24 @@ QRectF QVectorPath::controlPointRect() const
     return QRectF(QPointF(m_cp_rect.x1, m_cp_rect.y1), QPointF(m_cp_rect.x2, m_cp_rect.y2));
 }
 
+
+QVectorPath::CacheEntry *QVectorPath::addCacheData(QPaintEngineEx *engine, void *data,
+                                                   qvectorpath_cache_cleanup cleanup) {
+    Q_ASSERT(!lookupCacheData(engine));
+    if ((m_hints & IsCachedHint) == 0) {
+        m_cache = 0;
+        m_hints |= IsCachedHint;
+    }
+    CacheEntry *e = new CacheEntry;
+    e->engine = engine;
+    e->data = data;
+    e->cleanup = cleanup;
+    e->next = m_cache;
+    m_cache = e;
+    return m_cache;
+}
+
+
 const QVectorPath &qtVectorPathForPath(const QPainterPath &path)
 {
     Q_ASSERT(path.d_func());
@@ -414,7 +432,7 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
     // Some engines might decide to optimize for the non-shape hint later on...
     uint flags = QVectorPath::WindingFill;
     if (d->stroker.capStyle() == Qt::RoundCap || d->stroker.joinStyle() == Qt::RoundJoin)
-        flags |= QVectorPath::CurvedShapeHint;
+        flags |= QVectorPath::CurvedShapeMask;
 
     // ### Perspective Xforms are currently not supported...
     if (!pen.isCosmetic()) {
@@ -442,7 +460,7 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
                                               points[4], points[5]);
                     points += 6;
                     types += 3;
-                    flags |= QVectorPath::CurvedShapeHint;
+                    flags |= QVectorPath::CurvedShapeMask;
                     break;
                 default:
                     break;
@@ -504,7 +522,7 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
                         d->activeStroker->cubicTo(c1.x(), c1.y(), c2.x(), c2.y(), e.x(), e.y());
                         points += 6;
                         types += 3;
-                        flags |= QVectorPath::CurvedShapeHint;
+                        flags |= QVectorPath::CurvedShapeMask;
                         break;
                     }
                     default:
@@ -736,7 +754,7 @@ void QPaintEngineEx::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yR
         x1 + xRadius, y1
     };
 
-    QVectorPath path(pts, 17, qpaintengineex_roundedrect_types);
+    QVectorPath path(pts, 17, qpaintengineex_roundedrect_types, QVectorPath::RoundedRectHint);
     draw(path);
 }
 
@@ -827,7 +845,7 @@ void QPaintEngineEx::drawPoints(const QPointF *points, int pointCount)
                 pts[++oset] = points[i].x() + 0.001;
                 pts[++oset] = points[i].y();
             }
-            QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::NonCurvedShapeHint);
+            QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::LinesHint);
             stroke(path, pen);
             pointCount -= 16;
             points += 16;
@@ -858,7 +876,7 @@ void QPaintEngineEx::drawPoints(const QPoint *points, int pointCount)
                 pts[++oset] = points[i].x() + 0.001;
                 pts[++oset] = points[i].y();
             }
-            QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::NonCurvedShapeHint);
+            QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::LinesHint);
             stroke(path, pen);
             pointCount -= 16;
             points += 16;
diff --git a/src/gui/painting/qpaintengineex_p.h b/src/gui/painting/qpaintengineex_p.h
index 3ec9bd6..02d77f4 100644
--- a/src/gui/painting/qpaintengineex_p.h
+++ b/src/gui/painting/qpaintengineex_p.h
@@ -250,9 +250,9 @@ public:
 inline uint QVectorPath::polygonFlags(QPaintEngine::PolygonDrawMode mode) {
     switch (mode) {
     case QPaintEngine::ConvexMode: return ConvexPolygonHint | ImplicitClose;
-    case QPaintEngine::OddEvenMode: return NonCurvedShapeHint | OddEvenFill | ImplicitClose;
-    case QPaintEngine::WindingMode: return NonCurvedShapeHint | WindingFill | ImplicitClose;
-    case QPaintEngine::PolylineMode: return NonCurvedShapeHint;
+    case QPaintEngine::OddEvenMode: return PolygonHint | OddEvenFill | ImplicitClose;
+    case QPaintEngine::WindingMode: return PolygonHint | WindingFill | ImplicitClose;
+    case QPaintEngine::PolylineMode: return PolygonHint;
     default: return 0;
     }
 }
diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp
index 69e189c..c40bcee 100644
--- a/src/gui/painting/qpainterpath.cpp
+++ b/src/gui/painting/qpainterpath.cpp
@@ -688,6 +688,8 @@ void QPainterPath::lineTo(const QPointF &p)
         return;
     Element elm = { p.x(), p.y(), LineToElement };
     d->elements.append(elm);
+
+    d->convex = d->elements.size() == 3 || (d->elements.size() == 4 && d->isClosed());
 }
 
 /*!
@@ -960,6 +962,8 @@ void QPainterPath::addRect(const QRectF &r)
     ensureData();
     detach();
 
+    bool first = d_func()->elements.size() < 2;
+
     d_func()->elements.reserve(d_func()->elements.size() + 5);
     moveTo(r.x(), r.y());
 
@@ -970,6 +974,7 @@ void QPainterPath::addRect(const QRectF &r)
 
     d_func()->elements << l1 << l2 << l3 << l4;
     d_func()->require_moveTo = true;
+    d_func()->convex = first;
 }
 
 /*!
@@ -1039,6 +1044,7 @@ void QPainterPath::addEllipse(const QRectF &boundingRect)
     detach();
 
     Q_D(QPainterPath);
+    bool first = d_func()->elements.size() < 2;
     d->elements.reserve(d->elements.size() + 13);
 
     QPointF pts[12];
@@ -1051,6 +1057,8 @@ void QPainterPath::addEllipse(const QRectF &boundingRect)
     cubicTo(pts[6], pts[7], pts[8]);           // 180 -> 90
     cubicTo(pts[9], pts[10], pts[11]);         // 90 - >0
     d_func()->require_moveTo = true;
+
+    d_func()->convex = first;
 }
 
 /*!
@@ -3027,6 +3035,8 @@ void QPainterPath::addRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadi
     ensureData();
     detach();
 
+    bool first = d_func()->elements.size() < 2;
+
     arcMoveTo(x, y, rxx2, ryy2, 90);
     arcTo(x, y, rxx2, ryy2, 90, 90);
     arcTo(x, y+h-ryy2, rxx2, ryy2, 2*90, 90);
@@ -3035,6 +3045,7 @@ void QPainterPath::addRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadi
     closeSubpath();
 
     d_func()->require_moveTo = true;
+    d_func()->convex = first;
 }
 
 /*!
@@ -3081,6 +3092,8 @@ void QPainterPath::addRoundRect(const QRectF &r, int xRnd, int yRnd)
     ensureData();
     detach();
 
+    bool first = d_func()->elements.size() < 2;
+
     arcMoveTo(x, y, rxx2, ryy2, 90);
     arcTo(x, y, rxx2, ryy2, 90, 90);
     arcTo(x, y+h-ryy2, rxx2, ryy2, 2*90, 90);
@@ -3089,6 +3102,7 @@ void QPainterPath::addRoundRect(const QRectF &r, int xRnd, int yRnd)
     closeSubpath();
 
     d_func()->require_moveTo = true;
+    d_func()->convex = first;
 }
 
 /*!
@@ -3269,6 +3283,7 @@ void QPainterPath::setDirty(bool dirty)
     d_func()->dirtyControlBounds = dirty;
     delete d_func()->pathConverter;
     d_func()->pathConverter = 0;
+    d_func()->convex = false;
 }
 
 void QPainterPath::computeBoundingRect() const
diff --git a/src/gui/painting/qpainterpath_p.h b/src/gui/painting/qpainterpath_p.h
index 54c182d..112c2bd 100644
--- a/src/gui/painting/qpainterpath_p.h
+++ b/src/gui/painting/qpainterpath_p.h
@@ -81,8 +81,8 @@ class QVectorPathConverter;
 class QVectorPathConverter
 {
 public:
-    QVectorPathConverter(const QVector<QPainterPath::Element> &path, uint fillRule)
-        : pathData(path, fillRule),
+    QVectorPathConverter(const QVector<QPainterPath::Element> &path, uint fillRule, bool convex)
+        : pathData(path, fillRule, convex),
           path(pathData.points.data(), path.size(),
                pathData.elements.data(), pathData.flags) {}
 
@@ -91,7 +91,7 @@ public:
     }
 
     struct QVectorPathData {
-        QVectorPathData(const QVector<QPainterPath::Element> &path, uint fillRule)
+        QVectorPathData(const QVector<QPainterPath::Element> &path, uint fillRule, bool convex)
             : elements(path.size()),
               points(path.size() * 2),
               flags(0)
@@ -103,7 +103,7 @@ public:
                 points[ptsPos++] = e.x;
                 points[ptsPos++] = e.y;
                 if (e.type == QPainterPath::CurveToElement)
-                    flags |= QVectorPath::CurvedShapeHint;
+                    flags |= QVectorPath::CurvedShapeMask;
             }
 
             if (fillRule == Qt::WindingFill)
@@ -111,6 +111,8 @@ public:
             else
                 flags |= QVectorPath::OddEvenFill;
 
+            if (!convex)
+                flags |= QVectorPath::NonConvexShapeMask;
         }
         QVarLengthArray<QPainterPath::ElementType> elements;
         QVarLengthArray<qreal> points;
@@ -128,20 +130,26 @@ class QPainterPathData : public QPainterPathPrivate
 {
 public:
     QPainterPathData() :
-        cStart(0), fillRule(Qt::OddEvenFill),
-        dirtyBounds(false), dirtyControlBounds(false),
-        pathConverter(0)
+        cStart(0),
+        fillRule(Qt::OddEvenFill),
+        pathConverter(0),
+        dirtyBounds(false),
+        dirtyControlBounds(false)
+
     {
         ref = 1;
         require_moveTo = false;
+        convex = false;
     }
 
     QPainterPathData(const QPainterPathData &other) :
         QPainterPathPrivate(), cStart(other.cStart), fillRule(other.fillRule),
-        dirtyBounds(other.dirtyBounds), bounds(other.bounds),
-        dirtyControlBounds(other.dirtyControlBounds),
+        bounds(other.bounds),
         controlBounds(other.controlBounds),
-        pathConverter(0)
+        pathConverter(0),
+        dirtyBounds(other.dirtyBounds),
+        dirtyControlBounds(other.dirtyControlBounds),
+        convex(other.convex)
     {
         ref = 1;
         require_moveTo = false;
@@ -158,20 +166,21 @@ public:
 
     const QVectorPath &vectorPath() {
         if (!pathConverter)
-            pathConverter = new QVectorPathConverter(elements, fillRule);
+            pathConverter = new QVectorPathConverter(elements, fillRule, convex);
         return pathConverter->path;
     }
 
     int cStart;
     Qt::FillRule fillRule;
 
-    bool require_moveTo;
-
-    bool   dirtyBounds;
     QRectF bounds;
-    bool   dirtyControlBounds;
     QRectF controlBounds;
 
+    uint require_moveTo : 1;
+    uint dirtyBounds : 1;
+    uint dirtyControlBounds : 1;
+    uint convex : 1;
+
     QVectorPathConverter *pathConverter;
 };
 
diff --git a/src/gui/painting/qvectorpath_p.h b/src/gui/painting/qvectorpath_p.h
index d023131..ec27970 100644
--- a/src/gui/painting/qvectorpath_p.h
+++ b/src/gui/painting/qvectorpath_p.h
@@ -66,8 +66,9 @@ QT_BEGIN_NAMESPACE
 
 QT_MODULE(Gui)
 
+class QPaintEngineEx;
 
-#define QVECTORPATH_NO_CACHE
+typedef void (*qvectorpath_cache_cleanup)(void *data);
 
 struct QRealRect {
     qreal x1, y1, x2, y2;
@@ -77,19 +78,27 @@ class Q_GUI_EXPORT QVectorPath
 {
 public:
     enum Hint {
-        // Basic shapes...
-        LinesHint               = 0x0001, // Just plain lines...
-        RectangleHint           = 0x0002,
-        ConvexPolygonHint       = 0x0003, // Convex polygon...
-        NonISectPolygonHint     = 0x0004, // concave polygon, but not intersecting..
-        NonCurvedShapeHint      = 0x0005, // Generic polygon, possibly self-intersecting...
-        CurvedShapeHint         = 0x0006, // Generic vector path..
-        EllipseHint             = 0x0007,
-        ShapeHintMask           = 0x000f,
+        // Shape hints, in 0x000000ff, access using shape()
+        AreaShapeMask           = 0x0001,       // shape covers an area
+        NonConvexShapeMask      = 0x0002,       // shape is not convex
+        CurvedShapeMask         = 0x0004,       // shape contains curves...
+        LinesShapeMask          = 0x0008,
+        RectangleShapeMask      = 0x0010,
+        ShapeMask               = 0x001f,
+
+        // Shape hints merged into basic shapes..
+        LinesHint               = LinesShapeMask,
+        RectangleHint           = AreaShapeMask | RectangleShapeMask,
+        EllipseHint             = AreaShapeMask | CurvedShapeMask,
+        ConvexPolygonHint       = AreaShapeMask,
+        PolygonHint             = AreaShapeMask | NonConvexShapeMask,
+        RoundedRectHint         = AreaShapeMask | CurvedShapeMask,
+        ArbitraryShapeHint      = AreaShapeMask | NonConvexShapeMask | CurvedShapeMask,
 
         // Other hints
-        CacheHint               = 0x0100,
-        ControlPointRect        = 0x0200, // Set if the control point rect has been calculated...
+        IsCachedHint            = 0x0100, // Set if the cache hint is set
+        ShouldUseCacheHint      = 0x0200, // Set if the path should be cached when possible..
+        ControlPointRect        = 0x0400, // Set if the control point rect has been calculated...
 
         // Shape rendering specifiers...
         OddEvenFill             = 0x1000,
@@ -101,22 +110,21 @@ public:
     QVectorPath(const qreal *points,
                 int count,
                 const QPainterPath::ElementType *elements = 0,
-                uint hints = CurvedShapeHint)
+                uint hints = ArbitraryShapeHint)
         : m_elements(elements),
           m_points(points),
           m_count(count),
           m_hints(hints)
-#ifndef QVECTORPATH_NO_CACHE
-        , m_cache(0)
-#endif
     {
     }
 
     QRectF controlPointRect() const;
 
-    inline Hint shape() const { return (Hint) (m_hints & ShapeHintMask); }
+    inline Hint shape() const { return (Hint) (m_hints & ShapeMask); }
+    inline bool isConvex() const { return (m_hints & NonConvexShapeMask) == 0; }
+    inline bool isCurved() const { return m_hints & CurvedShapeMask; }
 
-    inline bool hasCacheHint() const { return m_hints & CacheHint; }
+    inline bool isCacheable() const { return m_hints & ShouldUseCacheHint; }
     inline bool hasImplicitClose() const { return m_hints & ImplicitClose; }
     inline bool hasWindingFill() const { return m_hints & WindingFill; }
 
@@ -131,24 +139,30 @@ public:
 
     static inline uint polygonFlags(QPaintEngine::PolygonDrawMode mode);
 
-private:
-    Q_DISABLE_COPY(QVectorPath)
-
-#ifndef QVECTORPATH_NO_CACHE
     struct CacheEntry {
-        void *engine;
-        int id;
-        void *extra;
+        QPaintEngineEx *engine;
+        void *data;
+        qvectorpath_cache_cleanup cleanup;
         CacheEntry *next;
     };
 
-    void addCacheData(CacheEntry *d) {
-        d->next = m_cache;
-        m_cache = d;
+    CacheEntry *addCacheData(QPaintEngineEx *engine, void *data, qvectorpath_cache_cleanup cleanup);
+    inline CacheEntry *lookupCacheData(QPaintEngineEx *engine) const {
+        Q_ASSERT(m_hints & IsCachedHint);
+        CacheEntry *e = m_cache;
+        while (e) {
+            if (e->engine == engine)
+                return e;
+            e = e->next;
+        }
+        return 0;
     }
 
+
+private:
+    Q_DISABLE_COPY(QVectorPath)
+
     CacheEntry *m_cache;
-#endif
 
     const QPainterPath::ElementType *m_elements;
     const qreal *m_points;
diff --git a/src/gui/painting/qwindowsurface_raster.cpp b/src/gui/painting/qwindowsurface_raster.cpp
index 3a118bd..d412040 100644
--- a/src/gui/painting/qwindowsurface_raster.cpp
+++ b/src/gui/painting/qwindowsurface_raster.cpp
@@ -215,6 +215,12 @@ void QRasterWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoi
         XCopyArea(X11->display, d_ptr->image->xshmpm, widget->handle(), d_ptr->gc,
                   br.x(), br.y(), br.width(), br.height(), wbr.x(), wbr.y());
         XSync(X11->display, False);
+    } else if (d_ptr->image->xshmimg) {
+        const QImage &src = d->image->image;
+        br = br.intersected(src.rect());
+        XShmPutImage(X11->display, widget->handle(), d_ptr->gc, d_ptr->image->xshmimg,
+                     br.x(), br.y(), wbr.x(), wbr.y(), br.width(), br.height(), False);
+        XSync(X11->display, False);
     } else
 #endif
     {
diff --git a/src/gui/styles/qgtkstyle.cpp b/src/gui/styles/qgtkstyle.cpp
index d315c98..b8d3674 100644
--- a/src/gui/styles/qgtkstyle.cpp
+++ b/src/gui/styles/qgtkstyle.cpp
@@ -1933,9 +1933,6 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
                 QRect grooveRect = option->rect.adjusted(focusFrameMargin, outerSize + focusFrameMargin,
                                    -focusFrameMargin, -outerSize - focusFrameMargin);
 
-                gtkPainter.paintBox( scaleWidget, "trough", grooveRect, state,
-                                     GTK_SHADOW_IN, style, QString(QLS("p%0")).arg(slider->sliderPosition));
-
                 gboolean trough_side_details = false; // Indicates if the upper or lower scale background differs
                 if (!QGtk::gtk_check_version(2, 10, 0))
                     QGtk::gtk_widget_style_get((GtkWidget*)(scaleWidget), "trough-side-details",   &trough_side_details, NULL);
diff --git a/src/gui/text/qfontengine_mac.mm b/src/gui/text/qfontengine_mac.mm
index 8ce437d..a4e7c04 100644
--- a/src/gui/text/qfontengine_mac.mm
+++ b/src/gui/text/qfontengine_mac.mm
@@ -546,7 +546,7 @@ void QCoreTextFontEngine::addGlyphsToPath(glyph_t *glyphs, QFixedPoint *position
     cgMatrix = CGAffineTransformScale(cgMatrix, 1, -1);
 
     if (synthesisFlags & QFontEngine::SynthesizedItalic)
-        cgMatrix = CGAffineTransformConcat(cgMatrix, CGAffineTransformMake(1, 0, tanf(14 * acosf(0) / 90), 1, 0, 0));
+        cgMatrix = CGAffineTransformConcat(cgMatrix, CGAffineTransformMake(1, 0, -tanf(14 * acosf(0) / 90), 1, 0, 0));
 
 
     for (int i = 0; i < nGlyphs; ++i) {
diff --git a/src/gui/text/qfontengine_win.cpp b/src/gui/text/qfontengine_win.cpp
index fd34d0f..6c367ab 100644
--- a/src/gui/text/qfontengine_win.cpp
+++ b/src/gui/text/qfontengine_win.cpp
@@ -208,7 +208,7 @@ void QFontEngineWin::getCMap()
         unitsPerEm = otm->otmEMSquare;
         x_height = (int)otm->otmsXHeight;
         loadKerningPairs(designToDevice);
-        _faceId.filename = (char *)otm + (int)otm->otmpFullName;
+        _faceId.filename = QString::fromWCharArray((wchar_t *)((char *)otm + (int)otm->otmpFullName)).toLatin1();
         lineWidth = otm->otmsUnderscoreSize;
         fsType = otm->otmfsType;
         free(otm);
@@ -987,8 +987,8 @@ QFontEngine::Properties QFontEngineWin::properties() const
     Properties p;
     p.emSquare = unitsPerEm;
     p.italicAngle = otm->otmItalicAngle;
-    p.postscriptName = (char *)otm + (int)otm->otmpFamilyName;
-    p.postscriptName += (char *)otm + (int)otm->otmpStyleName;
+    p.postscriptName = QString::fromWCharArray((wchar_t *)((char *)otm + (int)otm->otmpFamilyName)).toLatin1();
+    p.postscriptName += QString::fromWCharArray((wchar_t *)((char *)otm + (int)otm->otmpStyleName)).toLatin1();
 #ifndef QT_NO_PRINTER
     p.postscriptName = QPdf::stripSpecialCharacters(p.postscriptName);
 #endif
@@ -1110,7 +1110,7 @@ QNativeImage *QFontEngineWin::drawGDIGlyph(HFONT font, glyph_t glyph, int margin
                                         ih + 2 * margin + 4,
                                         QNativeImage::systemFormat(), !qt_cleartype_enabled);
 
-    /*If cleartype is enabled we use the standard system format even on Windows CE 
+    /*If cleartype is enabled we use the standard system format even on Windows CE
       and not the special textbuffer format we have to use if cleartype is disabled*/
 
     ni->image.fill(0xffffffff);