Merge branch '4.6' of ../qt into kinetic-declarativeui

76 files changed, 862 insertions, 761 deletions

diff --git a/src/3rdparty/phonon/mmf/abstractaudioeffect.h b/src/3rdparty/phonon/mmf/abstractaudioeffect.h
index 9878472..436e8e4 100644
--- a/src/3rdparty/phonon/mmf/abstractaudioeffect.h
+++ b/src/3rdparty/phonon/mmf/abstractaudioeffect.h
@@ -23,7 +23,7 @@ along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
 #include <AudioEffectBase.h>
 
-#include <Phonon/EffectInterface>
+#include <phonon/effectinterface.h>
 
 #include "audioplayer.h"
 #include "effectparameter.h"
diff --git a/src/3rdparty/phonon/mmf/abstractplayer.h b/src/3rdparty/phonon/mmf/abstractplayer.h
index dbcbe63..cec5568 100644
--- a/src/3rdparty/phonon/mmf/abstractplayer.h
+++ b/src/3rdparty/phonon/mmf/abstractplayer.h
@@ -19,8 +19,8 @@ along with this library.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef PHONON_MMF_ABSTRACTPLAYER_H
 #define PHONON_MMF_ABSTRACTPLAYER_H
 
-#include <Phonon/phononnamespace.h>
-#include <Phonon/MediaSource.h>
+#include <phonon/phononnamespace.h>
+#include <phonon/mediasource.h>
 
 #include <QObject>
 
diff --git a/src/3rdparty/phonon/mmf/backend.h b/src/3rdparty/phonon/mmf/backend.h
index 6b85625..9361544 100644
--- a/src/3rdparty/phonon/mmf/backend.h
+++ b/src/3rdparty/phonon/mmf/backend.h
@@ -22,8 +22,8 @@ along with this library.  If not, see <http://www.gnu.org/licenses/>.
 #include "ancestormovemonitor.h"
 #include "effectfactory.h"
 
-#include <Phonon/MediaSource>
-#include <Phonon/BackendInterface>
+#include <phonon/mediasource.h>
+#include <phonon/backendinterface.h>
 #include <QScopedPointer>
 
 QT_BEGIN_NAMESPACE
diff --git a/src/3rdparty/phonon/mmf/effectparameter.h b/src/3rdparty/phonon/mmf/effectparameter.h
index 27cc018..892ed4d 100644
--- a/src/3rdparty/phonon/mmf/effectparameter.h
+++ b/src/3rdparty/phonon/mmf/effectparameter.h
@@ -19,7 +19,7 @@ along with this library.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef PHONON_MMF_EFFECTPARAMETER_H
 #define PHONON_MMF_EFFECTPARAMETER_H
 
-#include <Phonon/EffectParameter>
+#include <phonon/effectparameter.h>
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/3rdparty/phonon/mmf/mediaobject.h b/src/3rdparty/phonon/mmf/mediaobject.h
index c87d755..d6248e2 100644
--- a/src/3rdparty/phonon/mmf/mediaobject.h
+++ b/src/3rdparty/phonon/mmf/mediaobject.h
@@ -19,8 +19,8 @@ along with this library.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef PHONON_MMF_MEDIAOBJECT_H
 #define PHONON_MMF_MEDIAOBJECT_H
 
-#include <Phonon/MediaSource>
-#include <Phonon/MediaObjectInterface>
+#include <phonon/mediasource.h>
+#include <phonon/mediaobjectinterface.h>
 #include <QScopedPointer>
 #include <QTimer>
 
diff --git a/src/3rdparty/phonon/mmf/mmf_medianode.h b/src/3rdparty/phonon/mmf/mmf_medianode.h
index 0ed21c4..f2f64e0 100644
--- a/src/3rdparty/phonon/mmf/mmf_medianode.h
+++ b/src/3rdparty/phonon/mmf/mmf_medianode.h
@@ -20,7 +20,7 @@ along with this library.  If not, see <http://www.gnu.org/licenses/>.
 #define PHONON_MMF_MEDIANODE_H
 
 #include <QObject>
-#include <Phonon/EffectInterface>
+#include <phonon/effectinterface.h>
 #include "audioplayer.h"
 
 QT_BEGIN_NAMESPACE
diff --git a/src/3rdparty/phonon/mmf/videooutput.h b/src/3rdparty/phonon/mmf/videooutput.h
index 2788401..3e9c036 100644
--- a/src/3rdparty/phonon/mmf/videooutput.h
+++ b/src/3rdparty/phonon/mmf/videooutput.h
@@ -24,7 +24,7 @@ along with this library.  If not, see <http://www.gnu.org/licenses/>.
 #include <QRect>
 #include "defs.h"
 
-#include <Phonon/VideoWidget>
+#include <phonon/videowidget.h>
 
 #include <e32std.h>
 class RWindowBase;
diff --git a/src/3rdparty/phonon/mmf/videowidget.h b/src/3rdparty/phonon/mmf/videowidget.h
index a876748..899dca6 100644
--- a/src/3rdparty/phonon/mmf/videowidget.h
+++ b/src/3rdparty/phonon/mmf/videowidget.h
@@ -23,8 +23,8 @@ along with this library.  If not, see <http://www.gnu.org/licenses/>.
 #include "videooutput.h"
 
 #include <QtGui/QWidget>
-#include <Phonon/VideoWidget>
-#include <Phonon/VideoWidgetInterface>
+#include <phonon/videowidget.h>
+#include <phonon/videowidgetinterface.h>
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/3rdparty/webkit/VERSION b/src/3rdparty/webkit/VERSION
index bc6d661..4f33e22 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
 
-        8b9165d3bc84d1c8cc7df49a191cc3857b5530d4
+        8f6992f4e8f027818429d428393b08068eca9ffa
diff --git a/src/3rdparty/webkit/WebCore/WebCore.pro b/src/3rdparty/webkit/WebCore/WebCore.pro
index 9432217..1489fa0 100644
--- a/src/3rdparty/webkit/WebCore/WebCore.pro
+++ b/src/3rdparty/webkit/WebCore/WebCore.pro
@@ -23,7 +23,7 @@ symbian: {
     TARGET.UID3 = 0x200267C2
     # RO text (code) section in qtwebkit.dll exceeds allocated space for gcce udeb target.
     # Move RW-section base address to start from 0xE00000 instead of the toolchain default 0x400000.
-    MMP_RULES += "LINKEROPTION  armcc --rw-base 0xE00000"
+    QMAKE_LFLAGS.ARMCC += --rw-base 0xE00000
 }
 
 include($$PWD/../WebKit.pri)
diff --git a/src/3rdparty/webkit/WebKit/qt/ChangeLog b/src/3rdparty/webkit/WebKit/qt/ChangeLog
index 357b787..cd47982 100644
--- a/src/3rdparty/webkit/WebKit/qt/ChangeLog
+++ b/src/3rdparty/webkit/WebKit/qt/ChangeLog
@@ -1,3 +1,12 @@
+2010-01-14  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Qt] Update Symbian .def symbol export files after private API additions.
+
+        * symbian/bwins/QtWebKitu.def:
+        * symbian/eabi/QtWebKitu.def:
+
 2009-12-18  Joe Ligman  <joseph.ligman@nokia.com>
 
         Reviewed by Kenneth Rohde Christiansen.
diff --git a/src/3rdparty/webkit/WebKit/qt/symbian/bwins/QtWebKitu.def b/src/3rdparty/webkit/WebKit/qt/symbian/bwins/QtWebKitu.def
index e5631f8..086e986 100644
--- a/src/3rdparty/webkit/WebKit/qt/symbian/bwins/QtWebKitu.def
+++ b/src/3rdparty/webkit/WebKit/qt/symbian/bwins/QtWebKitu.def
@@ -620,4 +620,8 @@ EXPORTS
 	?staticMetaObject@QWebPage@@2UQMetaObject@@B @ 619 NONAME ; struct QMetaObject const QWebPage::staticMetaObject
 	?staticMetaObject@QWebView@@2UQMetaObject@@B @ 620 NONAME ; struct QMetaObject const QWebView::staticMetaObject
 	?attributeNames@QWebElement@@QBE?AVQStringList@@ABVQString@@@Z @ 621 NONAME ; class QStringList QWebElement::attributeNames(class QString const &) const
+	?qt_networkAccessAllowed@@YAX_N@Z @ 622 NONAME ; void qt_networkAccessAllowed(bool)
+	?qt_resumeActiveDOMObjects@@YAXPAVQWebFrame@@@Z @ 623 NONAME ; void qt_resumeActiveDOMObjects(class QWebFrame *)
+	?qt_suspendActiveDOMObjects@@YAXPAVQWebFrame@@@Z @ 624 NONAME ; void qt_suspendActiveDOMObjects(class QWebFrame *)
+	?qtwebkit_webframe_scrollRecursively@@YA_NPAVQWebFrame@@HH@Z @ 625 NONAME ; bool qtwebkit_webframe_scrollRecursively(class QWebFrame *, int, int)
 
diff --git a/src/3rdparty/webkit/WebKit/qt/symbian/eabi/QtWebKitu.def b/src/3rdparty/webkit/WebKit/qt/symbian/eabi/QtWebKitu.def
index 4aad884..5dd2e20 100644
--- a/src/3rdparty/webkit/WebKit/qt/symbian/eabi/QtWebKitu.def
+++ b/src/3rdparty/webkit/WebKit/qt/symbian/eabi/QtWebKitu.def
@@ -690,4 +690,8 @@ EXPORTS
 	_ZThn8_N16QGraphicsWebView10itemChangeEN13QGraphicsItem18GraphicsItemChangeERK8QVariant @ 689 NONAME
 	_ZThn8_NK16QGraphicsWebView16inputMethodQueryEN2Qt16InputMethodQueryE @ 690 NONAME
 	_ZNK11QWebElement14attributeNamesERK7QString @ 691 NONAME
+	_Z23qt_networkAccessAllowedb @ 692 NONAME
+	_Z25qt_resumeActiveDOMObjectsP9QWebFrame @ 693 NONAME
+	_Z26qt_suspendActiveDOMObjectsP9QWebFrame @ 694 NONAME
+	_Z35qtwebkit_webframe_scrollRecursivelyP9QWebFrameii @ 695 NONAME
 
diff --git a/src/corelib/arch/qatomic_ia64.h b/src/corelib/arch/qatomic_ia64.h
index e015863..8c824f3 100644
--- a/src/corelib/arch/qatomic_ia64.h
+++ b/src/corelib/arch/qatomic_ia64.h
@@ -205,7 +205,7 @@ inline bool QBasicAtomicInt::deref()
 template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
 {
-    return (T *)_InterlockedExchangePointer(&_q_value, newValue);
+    return (T *)_InterlockedExchangePointer(reinterpret_cast<void * volatile*>(&_q_value), newValue);
 }
 
 template <typename T>
diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index 52e9845..f350d1a 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -2419,6 +2419,10 @@ QT3_SUPPORT Q_CORE_EXPORT const char *qInstallPathSysconf();
 //enabling new graphics resources
 #define QT_SYMBIAN_SUPPORTS_SGIMAGE
 #define QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
+
+#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+#define Q_SYMBIAN_SEMITRANSPARENT_BG_SURFACE
+#endif
 #endif
 
 
diff --git a/src/corelib/io/qfile.cpp b/src/corelib/io/qfile.cpp
index 6395cc7..728c316 100644
--- a/src/corelib/io/qfile.cpp
+++ b/src/corelib/io/qfile.cpp
@@ -643,13 +643,14 @@ QFile::remove()
         qWarning("QFile::remove: Empty or null file name");
         return false;
     }
+    unsetError();
     close();
     if(error() == QFile::NoError) {
         if(fileEngine()->remove()) {
             unsetError();
             return true;
         }
-        d->setError(QFile::RemoveError, fileEngine()->errorString());
+        d->setError(QFile::RemoveError, d->fileEngine->errorString());
     }
     return false;
 }
@@ -703,7 +704,7 @@ QFile::rename(const QString &newName)
         if (fileEngine()->rename(newName)) {
             unsetError();
             // engine was able to handle the new name so we just reset it
-            fileEngine()->setFileName(newName);
+            d->fileEngine->setFileName(newName);
             d->fileName = newName;
             return true;
         }
@@ -739,7 +740,7 @@ QFile::rename(const QString &newName)
                 if (error) {
                     out.remove();
                 } else {
-                    fileEngine()->setFileName(newName);
+                    d->fileEngine->setFileName(newName);
                     setPermissions(permissions());
                     unsetError();
                     setFileName(newName);
@@ -804,7 +805,7 @@ QFile::link(const QString &linkName)
         unsetError();
         return true;
     }
-    d->setError(QFile::RenameError, fileEngine()->errorString());
+    d->setError(QFile::RenameError, d->fileEngine->errorString());
     return false;
 }
 
@@ -993,10 +994,10 @@ bool QFile::open(OpenMode mode)
             seek(size());
         return true;
     }
-    QFile::FileError err = fileEngine()->error();
+    QFile::FileError err = d->fileEngine->error();
     if(err == QFile::UnspecifiedError)
         err = QFile::OpenError;
-    d->setError(err, fileEngine()->errorString());
+    d->setError(err, d->fileEngine->errorString());
     return false;
 }
 
@@ -1151,12 +1152,11 @@ bool QFile::open(int fd, OpenMode mode)
 int
 QFile::handle() const
 {
-    if (!isOpen())
+    Q_D(const QFile);
+    if (!isOpen() || !d->fileEngine)
         return -1;
 
-    if (QAbstractFileEngine *engine = fileEngine())
-        return engine->handle();
-    return -1;
+    return d->fileEngine->handle();
 }
 
 /*!
@@ -1188,13 +1188,12 @@ QFile::handle() const
 uchar *QFile::map(qint64 offset, qint64 size, MemoryMapFlags flags)
 {
     Q_D(QFile);
-    QAbstractFileEngine *engine = fileEngine();
-    if (engine
-        && engine->supportsExtension(QAbstractFileEngine::MapExtension)) {
+    if (fileEngine()
+            && d->fileEngine->supportsExtension(QAbstractFileEngine::MapExtension)) {
         unsetError();
-        uchar *address = engine->map(offset, size, flags);
+        uchar *address = d->fileEngine->map(offset, size, flags);
         if (address == 0)
-            d->setError(engine->error(), engine->errorString());
+            d->setError(d->fileEngine->error(), d->fileEngine->errorString());
         return address;
     }
     return 0;
@@ -1211,13 +1210,12 @@ uchar *QFile::map(qint64 offset, qint64 size, MemoryMapFlags flags)
 bool QFile::unmap(uchar *address)
 {
     Q_D(QFile);
-    QAbstractFileEngine *engine = fileEngine();
-    if (engine
-        && engine->supportsExtension(QAbstractFileEngine::UnMapExtension)) {
+    if (fileEngine()
+        && d->fileEngine->supportsExtension(QAbstractFileEngine::UnMapExtension)) {
         unsetError();
-        bool success = engine->unmap(address);
+        bool success = d->fileEngine->unmap(address);
         if (!success)
-            d->setError(engine->error(), engine->errorString());
+            d->setError(d->fileEngine->error(), d->fileEngine->errorString());
         return success;
     }
     return false;
@@ -1250,13 +1248,14 @@ QFile::resize(qint64 sz)
     Q_D(QFile);
     if (!d->ensureFlushed())
         return false;
-    if (isOpen() && fileEngine()->pos() > sz)
+    fileEngine();
+    if (isOpen() && d->fileEngine->pos() > sz)
         seek(sz);
-    if(fileEngine()->setSize(sz)) {
+    if(d->fileEngine->setSize(sz)) {
         unsetError();
         return true;
     }
-    d->setError(QFile::ResizeError, fileEngine()->errorString());
+    d->setError(QFile::ResizeError, d->fileEngine->errorString());
     return false;
 }
 
@@ -1320,7 +1319,7 @@ QFile::setPermissions(Permissions permissions)
         unsetError();
         return true;
     }
-    d->setError(QFile::PermissionsError, fileEngine()->errorString());
+    d->setError(QFile::PermissionsError, d->fileEngine->errorString());
     return false;
 }
 
@@ -1353,23 +1352,27 @@ bool
 QFile::flush()
 {
     Q_D(QFile);
+    if (!d->fileEngine) {
+        qWarning("QFile::flush: No file engine. Is IODevice open?");
+        return false;
+    }
+
     if (!d->writeBuffer.isEmpty()) {
         qint64 size = d->writeBuffer.size();
-        if (_qfile_writeData(d->fileEngine ? d->fileEngine : fileEngine(),
-                             &d->writeBuffer) != size) {
-            QFile::FileError err = fileEngine()->error();
+        if (_qfile_writeData(d->fileEngine, &d->writeBuffer) != size) {
+            QFile::FileError err = d->fileEngine->error();
             if(err == QFile::UnspecifiedError)
                 err = QFile::WriteError;
-            d->setError(err, fileEngine()->errorString());
+            d->setError(err, d->fileEngine->errorString());
             return false;
         }
     }
 
-    if (!fileEngine()->flush()) {
-        QFile::FileError err = fileEngine()->error();
+    if (!d->fileEngine->flush()) {
+        QFile::FileError err = d->fileEngine->error();
         if(err == QFile::UnspecifiedError)
             err = QFile::WriteError;
-        d->setError(err, fileEngine()->errorString());
+        d->setError(err, d->fileEngine->errorString());
         return false;
     }
     return true;
@@ -1394,10 +1397,10 @@ QFile::close()
     d->writeBuffer.clear();
 
     // keep earlier error from flush
-    if (fileEngine()->close() && flushed)
+    if (d->fileEngine->close() && flushed)
         unsetError();
     else if (flushed)
-        d->setError(fileEngine()->error(), fileEngine()->errorString());
+        d->setError(d->fileEngine->error(), d->fileEngine->errorString());
 }
 
 /*!
@@ -1450,10 +1453,10 @@ bool QFile::atEnd() const
         return false;
 
     // If the file engine knows best, say what it says.
-    if (fileEngine()->supportsExtension(QAbstractFileEngine::AtEndExtension)) {
+    if (d->fileEngine->supportsExtension(QAbstractFileEngine::AtEndExtension)) {
         // Check if the file engine supports AtEndExtension, and if it does,
         // check if the file engine claims to be at the end.
-        return fileEngine()->atEnd();
+        return d->fileEngine->atEnd();
     }
 
     // Fall back to checking how much is available (will stat files).
@@ -1475,11 +1478,11 @@ bool QFile::seek(qint64 off)
     if (!d->ensureFlushed())
         return false;
 
-    if (!fileEngine()->seek(off) || !QIODevice::seek(off)) {
-        QFile::FileError err = fileEngine()->error();
+    if (!d->fileEngine->seek(off) || !QIODevice::seek(off)) {
+        QFile::FileError err = d->fileEngine->error();
         if(err == QFile::UnspecifiedError)
             err = QFile::PositionError;
-        d->setError(err, fileEngine()->errorString());
+        d->setError(err, d->fileEngine->errorString());
         return false;
     }
     unsetError();
@@ -1495,8 +1498,8 @@ qint64 QFile::readLineData(char *data, qint64 maxlen)
     if (!d->ensureFlushed())
         return -1;
 
-    if (fileEngine()->supportsExtension(QAbstractFileEngine::FastReadLineExtension))
-        return fileEngine()->readLine(data, maxlen);
+    if (d->fileEngine->supportsExtension(QAbstractFileEngine::FastReadLineExtension))
+        return d->fileEngine->readLine(data, maxlen);
 
     // Fall back to QIODevice's readLine implementation if the engine
     // cannot do it faster.
@@ -1514,18 +1517,14 @@ qint64 QFile::readData(char *data, qint64 len)
     if (!d->ensureFlushed())
         return -1;
 
-    qint64 ret = -1;
-    qint64 read = fileEngine()->read(data, len);
-    if (read != -1)
-        ret = read;
-
-    if(ret < 0) {
-        QFile::FileError err = fileEngine()->error();
+    qint64 read = d->fileEngine->read(data, len);
+    if(read < 0) {
+        QFile::FileError err = d->fileEngine->error();
         if(err == QFile::UnspecifiedError)
             err = QFile::ReadError;
-        d->setError(err, fileEngine()->errorString());
+        d->setError(err, d->fileEngine->errorString());
     }
-    return ret;
+    return read;
 }
 
 /*!
@@ -1605,13 +1604,12 @@ QFile::writeData(const char *data, qint64 len)
     // Write directly to the engine if the block size is larger than
     // the write buffer size.
     if (!buffered || len > QFILE_WRITEBUFFER_SIZE) {
-        QAbstractFileEngine *fe = d->fileEngine ? d->fileEngine : fileEngine();
-        qint64 ret = fe->write(data, len);
+        qint64 ret = d->fileEngine->write(data, len);
         if(ret < 0) {
-            QFile::FileError err = fileEngine()->error();
+            QFile::FileError err = d->fileEngine->error();
             if(err == QFile::UnspecifiedError)
                 err = QFile::WriteError;
-            d->setError(err, fileEngine()->errorString());
+            d->setError(err, d->fileEngine->errorString());
         }
         return ret;
     }
diff --git a/src/gui/dialogs/qfiledialog.cpp b/src/gui/dialogs/qfiledialog.cpp
index 3d59463..21650bb 100644
--- a/src/gui/dialogs/qfiledialog.cpp
+++ b/src/gui/dialogs/qfiledialog.cpp
@@ -1222,12 +1222,6 @@ QFileDialog::ViewMode QFileDialog::viewMode() const
 void QFileDialog::setFileMode(QFileDialog::FileMode mode)
 {
     Q_D(QFileDialog);
-    if (d->nativeDialogInUse){
-        d->model->setFilter(d->filterForMode(filter()));
-        d->setFilter_sys();
-        return;
-    }
-
     d->fileMode = mode;
     d->retranslateWindowTitle();
 
@@ -1263,6 +1257,11 @@ void QFileDialog::setFileMode(QFileDialog::FileMode mode)
         }
     }
     setLabelText(Accept, buttonText);
+    if (d->nativeDialogInUse){
+        d->setFilter_sys();
+        return;
+    }
+
     d->qFileDialogUi->fileTypeCombo->setEnabled(!testOption(ShowDirsOnly));
     d->_q_updateOkButton();
 }
@@ -1300,6 +1299,10 @@ void QFileDialog::setAcceptMode(QFileDialog::AcceptMode mode)
         d->qFileDialogUi->lookInCombo->setEditable(false);
     }
     d->retranslateWindowTitle();
+#if defined(Q_WS_MAC)
+    d->deleteNativeDialog_sys();
+    setAttribute(Qt::WA_DontShowOnScreen, false);
+#endif
 }
 
 /*
diff --git a/src/gui/dialogs/qfiledialog_mac.mm b/src/gui/dialogs/qfiledialog_mac.mm
index db5c356..67daced 100644
--- a/src/gui/dialogs/qfiledialog_mac.mm
+++ b/src/gui/dialogs/qfiledialog_mac.mm
@@ -639,9 +639,16 @@ void QFileDialogPrivate::setFilter_sys()
 {
 #ifndef QT_MAC_USE_COCOA
 #else
+    Q_Q(QFileDialog);
     QMacCocoaAutoReleasePool pool;
     QNSOpenSavePanelDelegate *delegate = static_cast<QNSOpenSavePanelDelegate *>(mDelegate);
     *(delegate->mQDirFilter) = model->filter();
+    delegate->mFileMode = fileMode;
+    [delegate->mSavePanel setTitle:qt_mac_QStringToNSString(q->windowTitle())];
+    [delegate->mSavePanel setPrompt:[delegate strip:acceptLabel]];
+    if (fileNameLabelExplicitlySat)
+        [delegate->mSavePanel setNameFieldLabel:[delegate strip:qFileDialogUi->fileNameLabel->text()]];
+
     [delegate updateProperties];
 #endif
 }
diff --git a/src/gui/effects/qgraphicseffect.cpp b/src/gui/effects/qgraphicseffect.cpp
index 90145fe..ad23df3 100644
--- a/src/gui/effects/qgraphicseffect.cpp
+++ b/src/gui/effects/qgraphicseffect.cpp
@@ -374,6 +374,11 @@ QGraphicsEffectSourcePrivate::~QGraphicsEffectSourcePrivate()
     invalidateCache();
 }
 
+void QGraphicsEffectSourcePrivate::setCachedOffset(const QPoint &offset)
+{
+    m_cachedOffset = offset;
+}
+
 void QGraphicsEffectSourcePrivate::invalidateCache(InvalidateReason reason) const
 {
     if (m_cachedMode != QGraphicsEffect::PadToEffectiveBoundingRect
diff --git a/src/gui/effects/qgraphicseffect_p.h b/src/gui/effects/qgraphicseffect_p.h
index 91ad74a..e34dbf9 100644
--- a/src/gui/effects/qgraphicseffect_p.h
+++ b/src/gui/effects/qgraphicseffect_p.h
@@ -129,8 +129,10 @@ public:
                            QGraphicsEffect::PixmapPadMode mode = QGraphicsEffect::PadToTransparentBorder) const = 0;
     virtual void effectBoundingRectChanged() = 0;
 
+    void setCachedOffset(const QPoint &offset);
     void invalidateCache(InvalidateReason reason = SourceChanged) const;
     Qt::CoordinateSystem currentCachedSystem() const { return m_cachedSystem; }
+    QGraphicsEffect::PixmapPadMode currentCachedMode() const { return m_cachedMode; }
 
     friend class QGraphicsScenePrivate;
     friend class QGraphicsItem;
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index ebe04e3..616daaa 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -10716,27 +10716,18 @@ void QGraphicsItemEffectSourcePrivate::draw(QPainter *painter)
     }
 }
 
-QPixmap QGraphicsItemEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset,
-                                                 QGraphicsEffect::PixmapPadMode mode) const
+QRect QGraphicsItemEffectSourcePrivate::paddedEffectRect(Qt::CoordinateSystem system, QGraphicsEffect::PixmapPadMode mode, const QRectF &sourceRect, bool *unpadded) const
 {
-    const bool deviceCoordinates = (system == Qt::DeviceCoordinates);
-    if (!info && deviceCoordinates) {
-        // Device coordinates without info not yet supported.
-        qWarning("QGraphicsEffectSource::pixmap: Not yet implemented, lacking device context");
-        return QPixmap();
-    }
-    if (!item->d_ptr->scene)
-        return QPixmap();
-    QGraphicsScenePrivate *scened = item->d_ptr->scene->d_func();
-
-    const QRectF sourceRect = boundingRect(system);
     QRectF effectRectF;
 
-    bool unpadded = false;
+    if (unpadded)
+        *unpadded = false;
+
     if (mode == QGraphicsEffect::PadToEffectiveBoundingRect) {
         if (info) {
             effectRectF = item->graphicsEffect()->boundingRectFor(boundingRect(Qt::DeviceCoordinates));
-            unpadded = (effectRectF.size() == sourceRect.size());
+            if (unpadded)
+                *unpadded = (effectRectF.size() == sourceRect.size());
             if (info && system == Qt::LogicalCoordinates)
                 effectRectF = info->painter->worldTransform().inverted().mapRect(effectRectF);
         } else {
@@ -10748,10 +10739,29 @@ QPixmap QGraphicsItemEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QP
         effectRectF = sourceRect.adjusted(-1.5, -1.5, 1.5, 1.5);
     } else {
         effectRectF = sourceRect;
-        unpadded = true;
+        if (unpadded)
+            *unpadded = true;
+    }
+
+    return effectRectF.toAlignedRect();
+}
+
+QPixmap QGraphicsItemEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset,
+                                                 QGraphicsEffect::PixmapPadMode mode) const
+{
+    const bool deviceCoordinates = (system == Qt::DeviceCoordinates);
+    if (!info && deviceCoordinates) {
+        // Device coordinates without info not yet supported.
+        qWarning("QGraphicsEffectSource::pixmap: Not yet implemented, lacking device context");
+        return QPixmap();
     }
+    if (!item->d_ptr->scene)
+        return QPixmap();
+    QGraphicsScenePrivate *scened = item->d_ptr->scene->d_func();
 
-    QRect effectRect = effectRectF.toAlignedRect();
+    bool unpadded;
+    const QRectF sourceRect = boundingRect(system);
+    QRect effectRect = paddedEffectRect(system, mode, sourceRect, &unpadded);
 
     if (offset)
         *offset = effectRect.topLeft();
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index 7949a02..67dc898 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -608,6 +608,7 @@ public:
     QPixmap pixmap(Qt::CoordinateSystem system,
                    QPoint *offset,
                    QGraphicsEffect::PixmapPadMode mode) const;
+    QRect paddedEffectRect(Qt::CoordinateSystem system, QGraphicsEffect::PixmapPadMode mode, const QRectF &sourceRect, bool *unpadded = 0) const;
 
     QGraphicsItem *item;
     QGraphicsItemPaintInfo *info;
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index 5c6a8ae..cea723c 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -4686,8 +4686,31 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
         if (sourced->currentCachedSystem() != Qt::LogicalCoordinates
             && sourced->lastEffectTransform != painter->worldTransform())
         {
+            bool unclipped = false;
+            if (sourced->lastEffectTransform.type() <= QTransform::TxTranslate
+                && painter->worldTransform().type() <= QTransform::TxTranslate)
+            {
+                QRectF itemRect = item->boundingRect();
+                if (!item->d_ptr->children.isEmpty())
+                    itemRect |= item->childrenBoundingRect();
+
+                QRectF oldSourceRect = sourced->lastEffectTransform.mapRect(itemRect);
+                QRectF newSourceRect = painter->worldTransform().mapRect(itemRect);
+
+                QRect oldEffectRect = sourced->paddedEffectRect(sourced->currentCachedSystem(), sourced->currentCachedMode(), oldSourceRect);
+                QRect newEffectRect = sourced->paddedEffectRect(sourced->currentCachedSystem(), sourced->currentCachedMode(), newSourceRect);
+
+                QRect deviceRect(0, 0, painter->device()->width(), painter->device()->height());
+                if (deviceRect.contains(oldEffectRect) && deviceRect.contains(newEffectRect)) {
+                    sourced->setCachedOffset(newEffectRect.topLeft());
+                    unclipped = true;
+                }
+            }
+
             sourced->lastEffectTransform = painter->worldTransform();
-            sourced->invalidateCache(QGraphicsEffectSourcePrivate::TransformChanged);
+
+            if (!unclipped)
+                sourced->invalidateCache(QGraphicsEffectSourcePrivate::TransformChanged);
         }
 
         item->d_ptr->graphicsEffect->draw(painter);
diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index 4e10b5b..4f5efa1 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -3992,7 +3992,7 @@ QImage QImage::scaled(const QSize& s, Qt::AspectRatioMode aspectMode, Qt::Transf
     QSize newSize = size();
     newSize.scale(s, aspectMode);
     if (newSize == size())
-        return copy();
+        return *this;
 
     QTransform wm = QTransform::fromScale((qreal)newSize.width() / width(), (qreal)newSize.height() / height());
     QImage img = transformed(wm, mode);
diff --git a/src/gui/image/qpixmapfilter.cpp b/src/gui/image/qpixmapfilter.cpp
index 30fb7a3..37a6a18 100644
--- a/src/gui/image/qpixmapfilter.cpp
+++ b/src/gui/image/qpixmapfilter.cpp
@@ -953,7 +953,7 @@ static void grayscale(const QImage &image, QImage &dest, const QRect& rect = QRe
         srcRect = dest.rect();
         destRect = dest.rect();
     }
-    if (image != dest) {
+    if (&image != &dest) {
         destRect.moveTo(QPoint(0, 0));
     }
 
diff --git a/src/gui/itemviews/qlistview.cpp b/src/gui/itemviews/qlistview.cpp
index f289c7d..19b1e8c 100644
--- a/src/gui/itemviews/qlistview.cpp
+++ b/src/gui/itemviews/qlistview.cpp
@@ -2621,6 +2621,13 @@ bool QIconModeViewBase::filterDropEvent(QDropEvent *e)
     const QSize contents = contentsSize;
     QPoint offset(horizontalOffset(), verticalOffset());
     QPoint end = e->pos() + offset;
+    if (qq->acceptDrops()) {
+        const Qt::ItemFlags dropableFlags = Qt::ItemIsDropEnabled|Qt::ItemIsEnabled;
+        const QVector<QModelIndex> &dropIndices = intersectingSet(QRect(end, QSize(1, 1)));
+        foreach (const QModelIndex &index, dropIndices)
+            if ((index.flags() & dropableFlags) == dropableFlags)
+                return false;
+    }
     QPoint start = dd->pressedPosition;
     QPoint delta = (dd->movement == QListView::Snap ? snapToGrid(end) - snapToGrid(start) : end - start);
     QList<QModelIndex> indexes = dd->selectionModel->selectedIndexes();
diff --git a/src/gui/kernel/qapplication_s60.cpp b/src/gui/kernel/qapplication_s60.cpp
index 3ee0a71..8c77728 100644
--- a/src/gui/kernel/qapplication_s60.cpp
+++ b/src/gui/kernel/qapplication_s60.cpp
@@ -807,6 +807,15 @@ TCoeInputCapabilities QSymbianControl::InputCapabilities() const
 
 void QSymbianControl::Draw(const TRect& controlRect) const
 {
+    // Set flag to avoid calling DrawNow in window surface
+    QWExtra *extra = qwidget->d_func()->extraData();
+    if (extra && !extra->inExpose) {
+        extra->inExpose = true;
+        QRect exposeRect = qt_TRect2QRect(controlRect);
+        qwidget->d_func()->syncBackingStore(exposeRect);
+        extra->inExpose = false;
+    }
+
     QWindowSurface *surface = qwidget->windowSurface();
     QPaintEngine *engine = surface ? surface->paintDevice()->paintEngine() : NULL;
 
@@ -855,8 +864,6 @@ void QSymbianControl::Draw(const TRect& controlRect) const
         default:
             Q_ASSERT(false);
         }
-    } else {
-        surface->flush(qwidget, QRegion(qt_TRect2QRect(backingStoreRect)), QPoint());
     }
 
     if (sendNativePaintEvents) {
diff --git a/src/gui/kernel/qdesktopwidget.cpp b/src/gui/kernel/qdesktopwidget.cpp
index c8a4373..24b4e57 100644
--- a/src/gui/kernel/qdesktopwidget.cpp
+++ b/src/gui/kernel/qdesktopwidget.cpp
@@ -47,6 +47,11 @@ QT_BEGIN_NAMESPACE
 
 const QRect QDesktopWidget::screenGeometry(const QWidget *widget) const
 {
+    if (!widget) {
+        qWarning("QDesktopWidget::screenGeometry(): Attempt "
+                 "to get the screen geometry of a null widget");
+        return QRect();
+    }
     QRect rect = QWidgetPrivate::screenGeometry(widget);
     if (rect.isNull())
         return screenGeometry(screenNumber(widget));
@@ -55,6 +60,11 @@ const QRect QDesktopWidget::screenGeometry(const QWidget *widget) const
 
 const QRect QDesktopWidget::availableGeometry(const QWidget *widget) const
 {
+    if (!widget) {
+        qWarning("QDesktopWidget::availableGeometry(): Attempt "
+                 "to get the available geometry of a null widget");
+        return QRect();
+    }
     QRect rect = QWidgetPrivate::screenGeometry(widget);
     if (rect.isNull())
         return availableGeometry(screenNumber(widget));
diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h
index ec8d20f..b1eb3c3 100644
--- a/src/gui/kernel/qwidget_p.h
+++ b/src/gui/kernel/qwidget_p.h
@@ -229,6 +229,7 @@ struct QWExtra {
 #endif
 #elif defined(Q_OS_SYMBIAN) // <----------------------------------------------------- Symbian
     uint activated : 1; // RWindowBase::Activated has been called
+    uint inExpose : 1; // Prevents drawing recursion
 
     /**
      * Defines the behaviour of QSymbianControl::Draw.
diff --git a/src/gui/kernel/qwidget_s60.cpp b/src/gui/kernel/qwidget_s60.cpp
index c65a162..00f2213 100644
--- a/src/gui/kernel/qwidget_s60.cpp
+++ b/src/gui/kernel/qwidget_s60.cpp
@@ -389,9 +389,13 @@ void QWidgetPrivate::create_sys(WId window, bool /* initializeWindow */, bool de
 
             if (!isOpaque) {
                 RWindow *const window = static_cast<RWindow *>(drawableWindow);
+#ifdef Q_SYMBIAN_SEMITRANSPARENT_BG_SURFACE
+                window->SetSurfaceTransparency(true);
+#else
                 const TDisplayMode displayMode = static_cast<TDisplayMode>(window->SetRequiredDisplayMode(EColor16MA));
                 if (window->SetTransparencyAlphaChannel() == KErrNone)
                     window->SetBackgroundColor(TRgb(255, 255, 255, 0));
+#endif
             }
         }
 
@@ -707,12 +711,16 @@ void QWidgetPrivate::s60UpdateIsOpaque()
 
     RWindow *const window = static_cast<RWindow *>(q->effectiveWinId()->DrawableWindow());
 
+#ifdef Q_SYMBIAN_SEMITRANSPARENT_BG_SURFACE
+    window->SetSurfaceTransparency(!isOpaque);
+#else
     if (!isOpaque) {
         const TDisplayMode displayMode = static_cast<TDisplayMode>(window->SetRequiredDisplayMode(EColor16MA));
         if (window->SetTransparencyAlphaChannel() == KErrNone)
             window->SetBackgroundColor(TRgb(255, 255, 255, 0));
     } else
         window->SetTransparentRegion(TRegionFix<1>());
+#endif
 }
 
 void QWidgetPrivate::setWindowIcon_sys(bool forceReset)
@@ -883,6 +891,7 @@ void QWidgetPrivate::createSysExtra()
     extra->activated = 0;
     extra->nativePaintMode = QWExtra::Default;
     extra->receiveNativePaintEvents = 0;
+    extra->inExpose = 0;
 }
 
 void QWidgetPrivate::deleteSysExtra()
diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp
index 058f226..4f2fffa 100644
--- a/src/gui/painting/qpaintengineex.cpp
+++ b/src/gui/painting/qpaintengineex.cpp
@@ -417,13 +417,6 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
         } else if (style == Qt::NoPen) {
             d->activeStroker = 0;
         } else {
-            // ### re-enable...
-            if (pen.isCosmetic()) {
-                d->dasher.setClipRect(d->exDeviceRect);
-            } else {
-                QRectF clipRect = state()->matrix.inverted().mapRect(QRectF(d->exDeviceRect));
-                d->dasher.setClipRect(clipRect);
-            }
             d->dasher.setDashPattern(pen.dashPattern());
             d->dasher.setDashOffset(pen.dashOffset());
             d->activeStroker = &d->dasher;
@@ -434,6 +427,15 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
         return;
     }
 
+    if (pen.style() > Qt::SolidLine) {
+        if (pen.isCosmetic()) {
+            d->activeStroker->setClipRect(d->exDeviceRect);
+        } else {
+            QRectF clipRect = state()->matrix.inverted().mapRect(QRectF(d->exDeviceRect));
+            d->activeStroker->setClipRect(clipRect);
+        }
+    }
+
     const QPainterPath::ElementType *types = path.elements();
     const qreal *points = path.points();
     int pointCount = path.elementCount();
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index a98ac10..a9dcea0 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -1984,9 +1984,14 @@ QPaintEngine *QPainter::paintEngine() const
 /*!
     \since 4.6
 
-    Flushes the painting pipeline and prepares for the user issuing
-    commands directly to the underlying graphics context. Must be
-    followed by a call to endNativePainting().
+    Flushes the painting pipeline and prepares for the user issuing commands
+    directly to the underlying graphics context. Must be followed by a call to
+    endNativePainting().
+
+    Note that only the states the underlying paint engine changes will be reset
+    to their respective default states. If, for example, the OpenGL polygon
+    mode is changed by the user inside a beginNativePaint()/endNativePainting()
+    block, it will not be reset to the default state by endNativePainting().
 
     Here is an example that shows intermixing of painter commands
     and raw OpenGL commands:
@@ -2010,9 +2015,9 @@ void QPainter::beginNativePainting()
 /*!
     \since 4.6
 
-    Restores the painter after manually issuing native painting commands.
-    Lets the painter restore any native state that it relies on before
-    calling any other painter commands.
+    Restores the painter after manually issuing native painting commands. Lets
+    the painter restore any native state that it relies on before calling any
+    other painter commands.
 
     \sa beginNativePainting()
 */
diff --git a/src/gui/painting/qprintengine_pdf.cpp b/src/gui/painting/qprintengine_pdf.cpp
index e3a2461..b8bf15e 100644
--- a/src/gui/painting/qprintengine_pdf.cpp
+++ b/src/gui/painting/qprintengine_pdf.cpp
@@ -931,14 +931,24 @@ void QPdfEnginePrivate::writeHeader()
 void QPdfEnginePrivate::writeInfo()
 {
     info = addXrefEntry(-1);
-    xprintf("<<\n"
-            "/Title (%s)\n"
-//            "/Author (%s)\n"
-            "/Creator (%s)\n"
-            "/Producer (Qt " QT_VERSION_STR " (C) 2009 Nokia Corporation and/or its subsidiary(-ies))\n",
-            title.toUtf8().constData(),
-//            author.toUtf8().constData(),
-            creator.toUtf8().constData());
+
+    // The 'text string' type in PDF is encoded either as PDFDocEncoding, or
+    // Unicode UTF-16 with a Unicode byte order mark as the first character
+    // (0xfeff), with the high-order byte first.
+    QByteArray array("<<\n/Title (\xfe\xff");
+    const ushort *utf16Title = title.utf16();
+    for (int i=0; i < title.size(); ++i) {
+        array.append((*(utf16Title + i)) >> 8);
+        array.append((*(utf16Title + i)) & 0xff);
+    }
+    array.append(")\n/Creator (\xfe\xff");
+    const ushort *utf16Creator = creator.utf16();
+    for (int i=0; i < creator.size(); ++i) {
+        array.append((*(utf16Creator + i)) >> 8);
+        array.append((*(utf16Creator + i)) & 0xff);
+    }
+    array.append(")\n/Producer (Qt " QT_VERSION_STR " (C) 2010 Nokia Corporation and/or its subsidiary(-ies))\n");
+    write(array);
 
     QDateTime now = QDateTime::currentDateTime().toUTC();
     QTime t = now.time();
diff --git a/src/gui/painting/qwindowsurface_s60.cpp b/src/gui/painting/qwindowsurface_s60.cpp
index b8eaead..b41dc2c 100644
--- a/src/gui/painting/qwindowsurface_s60.cpp
+++ b/src/gui/painting/qwindowsurface_s60.cpp
@@ -145,10 +145,12 @@ QImage* QS60WindowSurface::buffer(const QWidget *widget)
 
 void QS60WindowSurface::flush(QWidget *widget, const QRegion &region, const QPoint &)
 {
-    const QVector<QRect> subRects = region.rects();
-    for (int i = 0; i < subRects.count(); ++i) {
-        TRect tr = qt_QRect2TRect(subRects[i]);
+    QWExtra *extra = widget->d_func()->extraData();
+    if (extra && !extra->inExpose) {
+        extra->inExpose = true; // Prevent DrawNow() from calling syncBackingStore() again
+        TRect tr = qt_QRect2TRect(region.boundingRect());
         widget->winId()->DrawNow(tr);
+        extra->inExpose = false;
     }
 }
 
diff --git a/src/gui/styles/qgtkstyle.cpp b/src/gui/styles/qgtkstyle.cpp
index abb9e1e..211f4ce 100644
--- a/src/gui/styles/qgtkstyle.cpp
+++ b/src/gui/styles/qgtkstyle.cpp
@@ -1377,7 +1377,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
                     else {
                         gtkCachedPainter.paintFlatBox(gtkEntry, "entry_bg", contentRect,
                                                 option->state & State_Enabled ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE,
-                                                GTK_SHADOW_NONE, gtkCombo->style, entryPath + QString::number(focus));
+                                                GTK_SHADOW_NONE, gtkEntry->style, entryPath + QString::number(focus));
                     }
 
                     gtkCachedPainter.paintShadow(gtkEntry, comboBox->editable ? "entry" : "frame", frameRect, frameState,
diff --git a/src/gui/widgets/qabstractspinbox.cpp b/src/gui/widgets/qabstractspinbox.cpp
index 13e67e9..4a6235c 100644
--- a/src/gui/widgets/qabstractspinbox.cpp
+++ b/src/gui/widgets/qabstractspinbox.cpp
@@ -66,7 +66,7 @@
 #endif
 
 #if defined(Q_OS_SYMBIAN)
-#include <W32STD.H>
+#include <w32std.h>
 #include <private/qt_s60_p.h>
 #endif
 
diff --git a/src/gui/widgets/qlinecontrol.cpp b/src/gui/widgets/qlinecontrol.cpp
index 070091a..414c2ed 100644
--- a/src/gui/widgets/qlinecontrol.cpp
+++ b/src/gui/widgets/qlinecontrol.cpp
@@ -510,10 +510,12 @@ void QLineControl::draw(QPainter *painter, const QPoint &offset, const QRect &cl
             o.format.setForeground(m_palette.brush(QPalette::HighlightedText));
         } else {
             // mask selection
-            o.start = m_cursor;
-            o.length = 1;
-            o.format.setBackground(m_palette.brush(QPalette::Text));
-            o.format.setForeground(m_palette.brush(QPalette::Window));
+            if(!m_blinkPeriod || m_blinkStatus){
+                o.start = m_cursor;
+                o.length = 1;
+                o.format.setBackground(m_palette.brush(QPalette::Text));
+                o.format.setForeground(m_palette.brush(QPalette::Window));
+            }
         }
         selections.append(o);
     }
diff --git a/src/gui/widgets/qstackedwidget.cpp b/src/gui/widgets/qstackedwidget.cpp
index 396e233..2509a21 100644
--- a/src/gui/widgets/qstackedwidget.cpp
+++ b/src/gui/widgets/qstackedwidget.cpp
@@ -186,8 +186,11 @@ int QStackedWidget::insertWidget(int index, QWidget *widget)
 }
 
 /*!
-    Removes the given \a widget from the QStackedWidget. The widget
-    is \e not deleted.
+    Removes the given \a widget from the QStackedWidget.
+
+    \bold{Note:} The ownership of \a widget remains the same.
+    The widget is \e not deleted, but simply removed from the widget's
+    stacked layout, causing it to be hidden.
 
     \sa addWidget(), insertWidget(), currentWidget()
 */
diff --git a/src/multimedia/audio/qaudio_mac.cpp b/src/multimedia/audio/qaudio_mac.cpp
index 61a00ce..14fee8b 100644
--- a/src/multimedia/audio/qaudio_mac.cpp
+++ b/src/multimedia/audio/qaudio_mac.cpp
@@ -48,8 +48,8 @@ QT_BEGIN_NAMESPACE
 QDebug operator<<(QDebug dbg, const QAudioFormat& audioFormat)
 {
     dbg.nospace() << "QAudioFormat(" <<
-            audioFormat.sampleRate() << "," <<
-            audioFormat.channelCount() << "," <<
+            audioFormat.frequency() << "," <<
+            audioFormat.channels() << "," <<
             audioFormat.sampleSize()<< "," <<
             audioFormat.codec() << "," <<
             audioFormat.byteOrder() << "," <<
@@ -64,8 +64,8 @@ QAudioFormat toQAudioFormat(AudioStreamBasicDescription const& sf)
 {
     QAudioFormat    audioFormat;
 
-    audioFormat.setSampleRate(sf.mSampleRate);
-    audioFormat.setChannelCount(sf.mChannelsPerFrame);
+    audioFormat.setFrequency(sf.mSampleRate);
+    audioFormat.setChannels(sf.mChannelsPerFrame);
     audioFormat.setSampleSize(sf.mBitsPerChannel);
     audioFormat.setCodec(QString::fromLatin1("audio/pcm"));
     audioFormat.setByteOrder(sf.mFormatFlags & kLinearPCMFormatFlagIsBigEndian != 0 ? QAudioFormat::BigEndian : QAudioFormat::LittleEndian);
@@ -84,9 +84,9 @@ AudioStreamBasicDescription toAudioStreamBasicDescription(QAudioFormat const& au
     AudioStreamBasicDescription sf;
 
     sf.mFormatFlags         = kAudioFormatFlagIsPacked;
-    sf.mSampleRate          = audioFormat.sampleRate();
+    sf.mSampleRate          = audioFormat.frequency();
     sf.mFramesPerPacket     = 1;
-    sf.mChannelsPerFrame    = audioFormat.channelCount();
+    sf.mChannelsPerFrame    = audioFormat.channels();
     sf.mBitsPerChannel      = audioFormat.sampleSize();
     sf.mBytesPerFrame       = sf.mChannelsPerFrame * (sf.mBitsPerChannel / 8);
     sf.mBytesPerPacket      = sf.mFramesPerPacket * sf.mBytesPerFrame;
diff --git a/src/multimedia/audio/qaudiodeviceinfo.cpp b/src/multimedia/audio/qaudiodeviceinfo.cpp
index ca20eda..092efc5 100644
--- a/src/multimedia/audio/qaudiodeviceinfo.cpp
+++ b/src/multimedia/audio/qaudiodeviceinfo.cpp
@@ -100,13 +100,13 @@ public:
 
     You can also query each device for the formats it supports. A
     format in this context is a set consisting of a specific byte
-    order, channel, codec, sample rate, sample size and sample type.  A
+    order, channel, codec, frequency, sample rate, and sample type.  A
     format is represented by the QAudioFormat class.
 
     The values supported by the the device for each of these
     parameters can be fetched with
     supportedByteOrders(), supportedChannels(), supportedCodecs(),
-    supportedSampleRates(), supportedSampleSizes(), and
+    supportedFrequencies(), supportedSampleSizes(), and
     supportedSampleTypes(). The combinations supported are dependent on the platform,
     audio plugins installed and the audio device capabilities. If you need a specific format, you can check if
     the device supports it with isFormatSupported(), or fetch a
@@ -259,16 +259,7 @@ QStringList QAudioDeviceInfo::supportedCodecs() const
 }
 
 /*!
-    Returns a list of supported sample rates.
-*/
-
-QList<int> QAudioDeviceInfo::supportedSampleRates() const
-{
-    return supportedFrequencies();
-}
-
-/*!
-    \internal
+    Returns a list of supported frequencies.
 */
 
 QList<int> QAudioDeviceInfo::supportedFrequencies() const
@@ -277,16 +268,7 @@ QList<int> QAudioDeviceInfo::supportedFrequencies() const
 }
 
 /*!
-    Returns a list of supported channel counts.
-*/
-
-QList<int> QAudioDeviceInfo::supportedChannelCounts() const
-{
-    return supportedChannels();
-}
-
-/*!
-    \internal
+    Returns a list of supported channels.
 */
 
 QList<int> QAudioDeviceInfo::supportedChannels() const
diff --git a/src/multimedia/audio/qaudiodeviceinfo.h b/src/multimedia/audio/qaudiodeviceinfo.h
index 1cc0731..62dc8a2 100644
--- a/src/multimedia/audio/qaudiodeviceinfo.h
+++ b/src/multimedia/audio/qaudiodeviceinfo.h
@@ -84,9 +84,7 @@ public:
 
     QStringList supportedCodecs() const;
     QList<int> supportedFrequencies() const;
-    QList<int> supportedSampleRates() const;
     QList<int> supportedChannels() const;
-    QList<int> supportedChannelCounts() const;
     QList<int> supportedSampleSizes() const;
     QList<QAudioFormat::Endian> supportedByteOrders() const;
     QList<QAudioFormat::SampleType> supportedSampleTypes() const;
diff --git a/src/multimedia/audio/qaudiodeviceinfo_alsa_p.cpp b/src/multimedia/audio/qaudiodeviceinfo_alsa_p.cpp
index a77a428..36270a7 100644
--- a/src/multimedia/audio/qaudiodeviceinfo_alsa_p.cpp
+++ b/src/multimedia/audio/qaudiodeviceinfo_alsa_p.cpp
@@ -78,20 +78,20 @@ QAudioFormat QAudioDeviceInfoInternal::preferredFormat() const
 {
     QAudioFormat nearest;
     if(mode == QAudio::AudioOutput) {
-        nearest.setSampleRate(44100);
-        nearest.setChannelCount(2);
+        nearest.setFrequency(44100);
+        nearest.setChannels(2);
         nearest.setByteOrder(QAudioFormat::LittleEndian);
         nearest.setSampleType(QAudioFormat::SignedInt);
         nearest.setSampleSize(16);
         nearest.setCodec(QLatin1String("audio/pcm"));
     } else {
-        nearest.setSampleRate(8000);
-        nearest.setChannelCount(1);
+        nearest.setFrequency(8000);
+        nearest.setChannels(1);
         nearest.setSampleType(QAudioFormat::UnSignedInt);
         nearest.setSampleSize(8);
         nearest.setCodec(QLatin1String("audio/pcm"));
         if(!testSettings(nearest)) {
-            nearest.setChannelCount(2);
+            nearest.setChannels(2);
             nearest.setSampleSize(16);
             nearest.setSampleType(QAudioFormat::SignedInt);
         }
@@ -253,8 +253,8 @@ bool QAudioDeviceInfoInternal::testSettings(const QAudioFormat& format) const
     snd_pcm_hw_params_any( handle, params );
 
     // set the values!
-    snd_pcm_hw_params_set_channels(handle,params,format.channelCount());
-    snd_pcm_hw_params_set_rate(handle,params,format.sampleRate(),dir);
+    snd_pcm_hw_params_set_channels(handle,params,format.channels());
+    snd_pcm_hw_params_set_rate(handle,params,format.frequency(),dir);
     switch(format.sampleSize()) {
         case 8:
             if(format.sampleType() == QAudioFormat::SignedInt)
@@ -295,18 +295,18 @@ bool QAudioDeviceInfoInternal::testSettings(const QAudioFormat& format) const
     } else
         testCodec = true;
 
-    if(err>=0 && format.channelCount() != -1) {
-        err = snd_pcm_hw_params_test_channels(handle,params,format.channelCount());
+    if(err>=0 && format.channels() != -1) {
+        err = snd_pcm_hw_params_test_channels(handle,params,format.channels());
         if(err>=0)
-            err = snd_pcm_hw_params_set_channels(handle,params,format.channelCount());
+            err = snd_pcm_hw_params_set_channels(handle,params,format.channels());
         if(err>=0)
             testChannel = true;
     }
 
-    if(err>=0 && format.sampleRate() != -1) {
-        err = snd_pcm_hw_params_test_rate(handle,params,format.sampleRate(),0);
+    if(err>=0 && format.frequency() != -1) {
+        err = snd_pcm_hw_params_test_rate(handle,params,format.frequency(),0);
         if(err>=0)
-            err = snd_pcm_hw_params_set_rate(handle,params,format.sampleRate(),dir);
+            err = snd_pcm_hw_params_set_rate(handle,params,format.frequency(),dir);
         if(err>=0)
             testFreq = true;
     }
diff --git a/src/multimedia/audio/qaudiodeviceinfo_mac_p.cpp b/src/multimedia/audio/qaudiodeviceinfo_mac_p.cpp
index 9334069..ecd03e5 100644
--- a/src/multimedia/audio/qaudiodeviceinfo_mac_p.cpp
+++ b/src/multimedia/audio/qaudiodeviceinfo_mac_p.cpp
@@ -144,10 +144,10 @@ QAudioFormat QAudioDeviceInfoInternal::nearestFormat(const QAudioFormat& format)
 
     rc.setCodec(QString::fromLatin1("audio/pcm"));
 
-    if (rc.sampleRate() != target.sampleRate())
-        rc.setSampleRate(target.sampleRate());
-    if (rc.channelCount() != target.channelCount())
-        rc.setChannelCount(target.channelCount());
+    if (rc.frequency() != target.frequency())
+        rc.setFrequency(target.frequency());
+    if (rc.channels() != target.channels())
+        rc.setChannels(target.channels());
     if (rc.sampleSize() != target.sampleSize())
         rc.setSampleSize(target.sampleSize());
     if (rc.byteOrder() != target.byteOrder())
diff --git a/src/multimedia/audio/qaudiodeviceinfo_win32_p.cpp b/src/multimedia/audio/qaudiodeviceinfo_win32_p.cpp
index 373e23d..f6b8154 100644
--- a/src/multimedia/audio/qaudiodeviceinfo_win32_p.cpp
+++ b/src/multimedia/audio/qaudiodeviceinfo_win32_p.cpp
@@ -94,15 +94,15 @@ QAudioFormat QAudioDeviceInfoInternal::preferredFormat() const
 {
     QAudioFormat nearest;
     if(mode == QAudio::AudioOutput) {
-        nearest.setSampleRate(44100);
-        nearest.setChannelCount(2);
+        nearest.setFrequency(44100);
+        nearest.setChannels(2);
         nearest.setByteOrder(QAudioFormat::LittleEndian);
         nearest.setSampleType(QAudioFormat::SignedInt);
         nearest.setSampleSize(16);
         nearest.setCodec(QLatin1String("audio/pcm"));
     } else {
-        nearest.setSampleRate(11025);
-        nearest.setChannelCount(1);
+        nearest.setFrequency(11025);
+        nearest.setChannels(1);
         nearest.setByteOrder(QAudioFormat::LittleEndian);
         nearest.setSampleType(QAudioFormat::SignedInt);
         nearest.setSampleSize(8);
@@ -181,12 +181,12 @@ bool QAudioDeviceInfoInternal::testSettings(const QAudioFormat& format) const
     if(!format.codec().startsWith(QLatin1String("audio/pcm")))
         failed = true;
 
-    if(!failed && !(format.channelCount() == 1 || format.channelCount() == 2))
+    if(!failed && !(format.channels() == 1 || format.channels() == 2))
         failed = true;
 
     if(!failed) {
-        if(!(format.sampleRate() == 8000 || format.sampleRate() == 11025 || format.sampleRate() == 22050 ||
-	   format.sampleRate() == 44100 || format.sampleRate() == 48000 || format.sampleRate() == 96000))
+        if(!(format.frequency() == 8000 || format.frequency() == 11025 || format.frequency() == 22050 ||
+	   format.frequency() == 44100 || format.frequency() == 48000 || format.frequency() == 96000))
 	    failed = true;
     }
 
diff --git a/src/multimedia/audio/qaudioformat.cpp b/src/multimedia/audio/qaudioformat.cpp
index 58bb571..89ae0ff 100644
--- a/src/multimedia/audio/qaudioformat.cpp
+++ b/src/multimedia/audio/qaudioformat.cpp
@@ -144,7 +144,7 @@ public:
     Values are initialized as follows:
     \list
     \o frequency()  = -1
-    \o channelCount() = -1
+    \o channels()   = -1
     \o sampleSize() = -1
     \o byteOrder()  = QAudioFormat::Endian(QSysInfo::ByteOrder)
     \o sampleType() = QAudioFormat::Unknown
@@ -224,16 +224,7 @@ bool QAudioFormat::isValid() const
 }
 
 /*!
-   Sets the sample rate to \a samplerate Hertz.
-*/
-
-void QAudioFormat::setSampleRate(int samplerate)
-{
-    d->frequency = samplerate;
-}
-
-/*!
-   \internal
+   Sets the frequency to \a frequency.
 */
 
 void QAudioFormat::setFrequency(int frequency)
@@ -242,16 +233,7 @@ void QAudioFormat::setFrequency(int frequency)
 }
 
 /*!
-    Returns the current sample rate in Hertz.
-*/
-
-int QAudioFormat::sampleRate() const
-{
-    return d->frequency;
-}
-
-/*!
-   \internal
+    Returns the current frequency value.
 */
 
 int QAudioFormat::frequency() const
@@ -260,16 +242,7 @@ int QAudioFormat::frequency() const
 }
 
 /*!
-   Sets the channel count to \a channels.
-*/
-
-void QAudioFormat::setChannelCount(int channels)
-{
-    d->channels = channels;
-}
-
-/*!
-   \internal
+   Sets the channels to \a channels.
 */
 
 void QAudioFormat::setChannels(int channels)
@@ -278,16 +251,7 @@ void QAudioFormat::setChannels(int channels)
 }
 
 /*!
-    Returns the current channel count value.
-*/
-
-int QAudioFormat::channelCount() const
-{
-    return d->channels;
-}
-
-/*!
-    \internal
+    Returns the current channel value.
 */
 
 int QAudioFormat::channels() const
diff --git a/src/multimedia/audio/qaudioformat.h b/src/multimedia/audio/qaudioformat.h
index b255907..cb58d1c 100644
--- a/src/multimedia/audio/qaudioformat.h
+++ b/src/multimedia/audio/qaudioformat.h
@@ -76,12 +76,6 @@ public:
     void setFrequency(int frequency);
     int frequency() const;
 
-    void setSampleRate(int samplerate);
-    int sampleRate() const;
-
-    void setChannelCount(int channels);
-    int channelCount() const;
-
     void setChannels(int channels);
     int channels() const;
 
diff --git a/src/multimedia/audio/qaudioinput.cpp b/src/multimedia/audio/qaudioinput.cpp
index da39c4a..45cafc1 100644
--- a/src/multimedia/audio/qaudioinput.cpp
+++ b/src/multimedia/audio/qaudioinput.cpp
@@ -88,8 +88,8 @@ QT_BEGIN_NAMESPACE
 
       QAudioFormat format;
       // set up the format you want, eg.
-      format.setSampleRate(8000);
-      format.setChannelCount(1);
+      format.setFrequency(8000);
+      format.setChannels(1);
       format.setSampleSize(8);
       format.setCodec("audio/pcm");
       format.setByteOrder(QAudioFormat::LittleEndian);
diff --git a/src/multimedia/audio/qaudioinput_alsa_p.cpp b/src/multimedia/audio/qaudioinput_alsa_p.cpp
index ea68c8d6..26e46b3 100644
--- a/src/multimedia/audio/qaudioinput_alsa_p.cpp
+++ b/src/multimedia/audio/qaudioinput_alsa_p.cpp
@@ -256,7 +256,7 @@ bool QAudioInputPrivate::open()
     int dir;
     int err=-1;
     int count=0;
-    unsigned int freakuency=settings.sampleRate();
+    unsigned int freakuency=settings.frequency();
 
     QString dev = QString(QLatin1String(m_device.constData()));
     QList<QByteArray> devices = QAudioDeviceInfoInternal::availableDevices(QAudio::AudioInput);
@@ -332,7 +332,7 @@ bool QAudioInputPrivate::open()
         }
     }
     if ( !fatal ) {
-        err = snd_pcm_hw_params_set_channels( handle, hwparams, (unsigned int)settings.channelCount() );
+        err = snd_pcm_hw_params_set_channels( handle, hwparams, (unsigned int)settings.channels() );
         if ( err < 0 ) {
             fatal = true;
             errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_channels: err = %1").arg(err);
@@ -505,7 +505,7 @@ qint64 QAudioInputPrivate::read(char* data, qint64 len)
             errorState = QAudio::NoError;
             deviceState = QAudio::IdleState;
         } else {
-            totalTimeValue += snd_pcm_bytes_to_frames(handle, err)*1000000/settings.sampleRate();
+            totalTimeValue += snd_pcm_bytes_to_frames(handle, err)*1000000/settings.frequency();
             resuming = false;
             errorState = QAudio::NoError;
             deviceState = QAudio::ActiveState;
@@ -702,7 +702,7 @@ qint64 InputPrivate::readData( char* data, qint64 len)
         count++;
     }
     if(err > 0 && readFrames > 0) {
-        audioDevice->totalTimeValue += readFrames*1000/audioDevice->settings.sampleRate()*1000;
+        audioDevice->totalTimeValue += readFrames*1000/audioDevice->settings.frequency()*1000;
         audioDevice->deviceState = QAudio::ActiveState;
         return err;
     }
diff --git a/src/multimedia/audio/qaudioinput_mac_p.cpp b/src/multimedia/audio/qaudioinput_mac_p.cpp
index f5be8ee..7251513 100644
--- a/src/multimedia/audio/qaudioinput_mac_p.cpp
+++ b/src/multimedia/audio/qaudioinput_mac_p.cpp
@@ -814,7 +814,7 @@ int QAudioInputPrivate::notifyInterval() const
 
 qint64 QAudioInputPrivate::processedUSecs() const
 {
-    return totalFrames * 1000000 / audioFormat.sampleRate();
+    return totalFrames * 1000000 / audioFormat.frequency();
 }
 
 qint64 QAudioInputPrivate::elapsedUSecs() const
diff --git a/src/multimedia/audio/qaudioinput_win32_p.cpp b/src/multimedia/audio/qaudioinput_win32_p.cpp
index 5c597ef..17e8bfb 100644
--- a/src/multimedia/audio/qaudioinput_win32_p.cpp
+++ b/src/multimedia/audio/qaudioinput_win32_p.cpp
@@ -225,16 +225,16 @@ bool QAudioInputPrivate::open()
     header = 0;
     if(buffer_size == 0) {
         // Default buffer size, 100ms, default period size is 20ms
-        buffer_size = settings.sampleRate()*settings.channelCount()*(settings.sampleSize()/8)*0.1;
+        buffer_size = settings.frequency()*settings.channels()*(settings.sampleSize()/8)*0.1;
 	period_size = buffer_size/5;
     } else {
         period_size = buffer_size/5;
     }
     timeStamp.restart();
     elapsedTimeOffset = 0;
-    wfx.nSamplesPerSec = settings.sampleRate();
+    wfx.nSamplesPerSec = settings.frequency();
     wfx.wBitsPerSample = settings.sampleSize();
-    wfx.nChannels = settings.channelCount();
+    wfx.nChannels = settings.channels();
     wfx.cbSize = 0;
 
     wfx.wFormatTag = WAVE_FORMAT_PCM;
@@ -374,8 +374,8 @@ qint64 QAudioInputPrivate::read(char* data, qint64 len)
 
                 } else {
                     totalTimeValue += waveBlocks[header].dwBytesRecorded
-                        /((settings.channelCount()*settings.sampleSize()/8))
-                        *10000/settings.sampleRate()*100;
+                        /((settings.channels()*settings.sampleSize()/8))
+                        *10000/settings.frequency()*100;
                     errorState = QAudio::NoError;
                     deviceState = QAudio::ActiveState;
 		    resuming = false;
@@ -388,8 +388,8 @@ qint64 QAudioInputPrivate::read(char* data, qint64 len)
                 qDebug()<<"IN: "<<waveBlocks[header].dwBytesRecorded<<", OUT: "<<l;
 #endif
                 totalTimeValue += waveBlocks[header].dwBytesRecorded
-                    /((settings.channelCount()*settings.sampleSize()/8))
-                    *10000/settings.sampleRate()*100;
+                    /((settings.channels()*settings.sampleSize()/8))
+                    *10000/settings.frequency()*100;
                 errorState = QAudio::NoError;
                 deviceState = QAudio::ActiveState;
 		resuming = false;
diff --git a/src/multimedia/audio/qaudiooutput.cpp b/src/multimedia/audio/qaudiooutput.cpp
index b61aa4f..afd8a84 100644
--- a/src/multimedia/audio/qaudiooutput.cpp
+++ b/src/multimedia/audio/qaudiooutput.cpp
@@ -83,8 +83,8 @@ QT_BEGIN_NAMESPACE
 
       QAudioFormat format;
       // Set up the format, eg.
-      format.setSampleRate(8000);
-      format.setChannelCount(1);
+      format.setFrequency(8000);
+      format.setChannels(1);
       format.setSampleSize(8);
       format.setCodec("audio/pcm");
       format.setByteOrder(QAudioFormat::LittleEndian);
diff --git a/src/multimedia/audio/qaudiooutput_alsa_p.cpp b/src/multimedia/audio/qaudiooutput_alsa_p.cpp
index 43b65ec..7b89cef 100644
--- a/src/multimedia/audio/qaudiooutput_alsa_p.cpp
+++ b/src/multimedia/audio/qaudiooutput_alsa_p.cpp
@@ -279,7 +279,7 @@ bool QAudioOutputPrivate::open()
     int dir;
     int err=-1;
     int count=0;
-    unsigned int freakuency=settings.sampleRate();
+    unsigned int freakuency=settings.frequency();
 
     QString dev = QLatin1String(m_device.constData());
     QList<QByteArray> devices = QAudioDeviceInfoInternal::availableDevices(QAudio::AudioOutput);
@@ -354,7 +354,7 @@ bool QAudioOutputPrivate::open()
         }
     }
     if ( !fatal ) {
-        err = snd_pcm_hw_params_set_channels( handle, hwparams, (unsigned int)settings.channelCount() );
+        err = snd_pcm_hw_params_set_channels( handle, hwparams, (unsigned int)settings.channels() );
         if ( err < 0 ) {
             fatal = true;
             errMessage = QString::fromLatin1("QAudioOutput: snd_pcm_hw_params_set_channels: err = %1").arg(err);
@@ -494,7 +494,7 @@ qint64 QAudioOutputPrivate::write( const char *data, qint64 len )
         err = snd_pcm_writei( handle, data, frames );
     }
     if(err > 0) {
-        totalTimeValue += err*1000000/settings.sampleRate();
+        totalTimeValue += err*1000000/settings.frequency();
         resuming = false;
         errorState = QAudio::NoError;
         deviceState = QAudio::ActiveState;
diff --git a/src/multimedia/audio/qaudiooutput_mac_p.cpp b/src/multimedia/audio/qaudiooutput_mac_p.cpp
index 4367ee7..518f78f 100644
--- a/src/multimedia/audio/qaudiooutput_mac_p.cpp
+++ b/src/multimedia/audio/qaudiooutput_mac_p.cpp
@@ -87,8 +87,8 @@ public:
         m_device(0)
     {
         m_buffer = new QAudioRingBuffer(bufferSize + (bufferSize % maxPeriodSize == 0 ? 0 : maxPeriodSize - (bufferSize % maxPeriodSize)));
-        m_bytesPerFrame = (audioFormat.sampleSize() / 8) * audioFormat.channelCount();
-        m_periodTime = m_maxPeriodSize / m_bytesPerFrame * 1000 / audioFormat.sampleRate();
+        m_bytesPerFrame = (audioFormat.sampleSize() / 8) * audioFormat.channels();
+        m_periodTime = m_maxPeriodSize / m_bytesPerFrame * 1000 / audioFormat.frequency();
 
         m_fillTimer = new QTimer(this);
         connect(m_fillTimer, SIGNAL(timeout()), SLOT(fillBuffer()));
@@ -546,7 +546,7 @@ int QAudioOutputPrivate::notifyInterval() const
 
 qint64 QAudioOutputPrivate::processedUSecs() const
 {
-    return totalFrames * 1000000 / audioFormat.sampleRate();
+    return totalFrames * 1000000 / audioFormat.frequency();
 }
 
 qint64 QAudioOutputPrivate::elapsedUSecs() const
diff --git a/src/multimedia/audio/qaudiooutput_win32_p.cpp b/src/multimedia/audio/qaudiooutput_win32_p.cpp
index b6e9762..c31e048 100644
--- a/src/multimedia/audio/qaudiooutput_win32_p.cpp
+++ b/src/multimedia/audio/qaudiooutput_win32_p.cpp
@@ -213,7 +213,7 @@ bool QAudioOutputPrivate::open()
 #endif
     if(buffer_size == 0) {
         // Default buffer size, 200ms, default period size is 40ms
-        buffer_size = settings.sampleRate()*settings.channelCount()*(settings.sampleSize()/8)*0.2;
+        buffer_size = settings.frequency()*settings.channels()*(settings.sampleSize()/8)*0.2;
 	period_size = buffer_size/5;
     } else {
         period_size = buffer_size/5;
@@ -232,9 +232,9 @@ bool QAudioOutputPrivate::open()
     timeStamp.restart();
     elapsedTimeOffset = 0;
 
-    wfx.nSamplesPerSec = settings.sampleRate();
+    wfx.nSamplesPerSec = settings.frequency();
     wfx.wBitsPerSample = settings.sampleSize();
-    wfx.nChannels = settings.channelCount();
+    wfx.nChannels = settings.channels();
     wfx.cbSize = 0;
 
     wfx.wFormatTag = WAVE_FORMAT_PCM;
@@ -289,8 +289,8 @@ void QAudioOutputPrivate::close()
         return;
 
     deviceState = QAudio::StoppedState;
-    int delay = (buffer_size-bytesFree())*1000/(settings.sampleRate()
-                  *settings.channelCount()*(settings.sampleSize()/8));
+    int delay = (buffer_size-bytesFree())*1000/(settings.frequency()
+                  *settings.channels()*(settings.sampleSize()/8));
     waveOutReset(hWaveOut);
     Sleep(delay+10);
 
@@ -386,8 +386,8 @@ qint64 QAudioOutputPrivate::write( const char *data, qint64 len )
         LeaveCriticalSection(&waveOutCriticalSection);
 #endif
         totalTimeValue += current->dwBufferLength
-            /(settings.channelCount()*(settings.sampleSize()/8))
-            *1000000/settings.sampleRate();;
+            /(settings.channels()*(settings.sampleSize()/8))
+            *1000000/settings.frequency();;
         waveCurrentBlock++;
         waveCurrentBlock %= buffer_size/period_size;
         current = &waveBlocks[waveCurrentBlock];
diff --git a/src/network/access/qfilenetworkreply.cpp b/src/network/access/qfilenetworkreply.cpp
index 44dd9e7..8c5065c 100644
--- a/src/network/access/qfilenetworkreply.cpp
+++ b/src/network/access/qfilenetworkreply.cpp
@@ -44,35 +44,32 @@
 #include "QtCore/qdatetime.h"
 #include <QtCore/QCoreApplication>
 #include <QtCore/QFileInfo>
+#include <QDebug>
 
 QT_BEGIN_NAMESPACE
 
 QFileNetworkReplyPrivate::QFileNetworkReplyPrivate()
-    : QNetworkReplyPrivate(), realFileSize(0), finished(false)
+    : QNetworkReplyPrivate(), realFileSize(0)
 {
 }
 
-QFileNetworkReply::QFileNetworkReply(QObject *parent, const QNetworkRequest &req)
+QFileNetworkReply::~QFileNetworkReply()
+{
+}
+
+QFileNetworkReply::QFileNetworkReply(QObject *parent, const QNetworkRequest &req, const QNetworkAccessManager::Operation op)
     : QNetworkReply(*new QFileNetworkReplyPrivate(), parent)
 {
     setRequest(req);
     setUrl(req.url());
-    setOperation(QNetworkAccessManager::GetOperation);
-    QMetaObject::invokeMethod(this, "_q_startOperation", Qt::QueuedConnection);
+    setOperation(op);
     QNetworkReply::open(QIODevice::ReadOnly);
-}
 
-QFileNetworkReply::~QFileNetworkReply()
-{
-}
+    qRegisterMetaType<QNetworkReply::NetworkError>("QNetworkReply::NetworkError");
 
-// This code is mostly inspired by QNetworkAccessFileBackend
-// We also use its translation context for error messages
-void QFileNetworkReplyPrivate::_q_startOperation()
-{
-    Q_Q(QFileNetworkReply);
+    QFileNetworkReplyPrivate *d = (QFileNetworkReplyPrivate*) d_func();
 
-    QUrl url = q->url();
+    QUrl url = req.url();
     if (url.host() == QLatin1String("localhost"))
         url.setHost(QString());
 
@@ -81,81 +78,75 @@ void QFileNetworkReplyPrivate::_q_startOperation()
     if (!url.host().isEmpty()) {
         // we handle only local files
         QString msg = QCoreApplication::translate("QNetworkAccessFileBackend", "Request for opening non-local file %1").arg(url.toString());
-        q->setError(QNetworkReply::ProtocolInvalidOperationError, msg);
-        emit q->error(QNetworkReply::ProtocolInvalidOperationError);
-        doFinished();
+        setError(QNetworkReply::ProtocolInvalidOperationError, msg);
+        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
+            Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ProtocolInvalidOperationError));
+        QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
         return;
     }
 #endif
     if (url.path().isEmpty())
         url.setPath(QLatin1String("/"));
-    q->setUrl(url);
+    setUrl(url);
 
 
     QString fileName = url.toLocalFile();
     if (fileName.isEmpty()) {
         fileName = url.toString(QUrl::RemoveAuthority | QUrl::RemoveFragment | QUrl::RemoveQuery);
     }
-    realFile.setFileName(fileName);
+    d->realFile.setFileName(fileName);
 
-    QFileInfo fi(realFile);
+    QFileInfo fi(d->realFile);
     if (fi.isDir()) {
         QString msg = QCoreApplication::translate("QNetworkAccessFileBackend", "Cannot open %1: Path is a directory").arg(url.toString());
-        q->setError(QNetworkReply::ContentOperationNotPermittedError, msg);
-        emit q->error(QNetworkReply::ContentOperationNotPermittedError);
-        doFinished();
+        setError(QNetworkReply::ContentOperationNotPermittedError, msg);
+        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
+            Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ContentOperationNotPermittedError));
+        QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
         return;
     }
 
-    bool opened = realFile.open(QIODevice::ReadOnly | QIODevice::Unbuffered);
+    bool opened = d->realFile.open(QIODevice::ReadOnly | QIODevice::Unbuffered);
 
     // could we open the file?
     if (!opened) {
         QString msg = QCoreApplication::translate("QNetworkAccessFileBackend", "Error opening %1: %2")
-                      .arg(realFile.fileName(), realFile.errorString());
+                      .arg(d->realFile.fileName(), d->realFile.errorString());
 
-        if (realFile.exists()) {
-            q->setError(QNetworkReply::ContentAccessDenied, msg);
-            emit q->error(QNetworkReply::ContentAccessDenied);
+        if (d->realFile.exists()) {
+            setError(QNetworkReply::ContentAccessDenied, msg);
+            QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
+                Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ContentAccessDenied));
         } else {
-            q->setError(QNetworkReply::ContentNotFoundError, msg);
-            emit q->error(QNetworkReply::ContentNotFoundError);
+            setError(QNetworkReply::ContentNotFoundError, msg);
+            QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
+                Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ContentNotFoundError));
         }
-        doFinished();
+        QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
         return;
     }
 
-    realFileSize = fi.size();
-    q->setHeader(QNetworkRequest::LastModifiedHeader, fi.lastModified());
-    q->setHeader(QNetworkRequest::ContentLengthHeader, realFileSize);
+    d->realFileSize = fi.size();
+    setHeader(QNetworkRequest::LastModifiedHeader, fi.lastModified());
+    setHeader(QNetworkRequest::ContentLengthHeader, d->realFileSize);
 
-    emit q->metaDataChanged();
-    emit q->downloadProgress(realFileSize, realFileSize);
-    emit q->readyRead();
-    doFinished();
+    QMetaObject::invokeMethod(this, "metaDataChanged", Qt::QueuedConnection);
+    QMetaObject::invokeMethod(this, "downloadProgress", Qt::QueuedConnection,
+        Q_ARG(qint64, d->realFileSize), Q_ARG(qint64, d->realFileSize));
+    QMetaObject::invokeMethod(this, "readyRead", Qt::QueuedConnection);
+    QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
 }
 
 bool QFileNetworkReplyPrivate::isFinished() const
 {
-    return finished;
-}
-
-void QFileNetworkReplyPrivate::doFinished()
-{
-    Q_Q(QFileNetworkReply);
-    finished = true;
-    emit q->finished();
+    return true;
 }
 
-
 void QFileNetworkReply::close()
 {
     Q_D(QFileNetworkReply);
     QNetworkReply::close();
     d->realFile.close();
-
-    if (!d->finished)
-        d->doFinished();
 }
 
 void QFileNetworkReply::abort()
@@ -163,9 +154,6 @@ void QFileNetworkReply::abort()
     Q_D(QFileNetworkReply);
     QNetworkReply::close();
     d->realFile.close();
-
-    if (!d->finished)
-        d->doFinished();
 }
 
 qint64 QFileNetworkReply::bytesAvailable() const
diff --git a/src/network/access/qfilenetworkreply_p.h b/src/network/access/qfilenetworkreply_p.h
index 6f10672..125fa2e 100644
--- a/src/network/access/qfilenetworkreply_p.h
+++ b/src/network/access/qfilenetworkreply_p.h
@@ -66,7 +66,7 @@ class QFileNetworkReply: public QNetworkReply
 {
     Q_OBJECT
 public:
-    QFileNetworkReply(QObject *parent, const QNetworkRequest &req);
+    QFileNetworkReply(QObject *parent, const QNetworkRequest &req, const QNetworkAccessManager::Operation op);
     ~QFileNetworkReply();
     virtual void abort();
 
@@ -76,12 +76,9 @@ public:
     virtual bool isSequential () const;
     qint64 size() const;
 
-
     virtual qint64 readData(char *data, qint64 maxlen);
 
     Q_DECLARE_PRIVATE(QFileNetworkReply)
-    Q_PRIVATE_SLOT(d_func(), void _q_startOperation())
-
 };
 
 class QFileNetworkReplyPrivate: public QNetworkReplyPrivate
@@ -92,12 +89,7 @@ public:
     QFile realFile;
     qint64 realFileSize;
 
-    void _q_startOperation();
-
     virtual bool isFinished() const;
-    void doFinished();
-    bool finished;
-
 
     Q_DECLARE_PUBLIC(QFileNetworkReply)
 };
diff --git a/src/network/access/qhttpnetworkconnectionchannel.cpp b/src/network/access/qhttpnetworkconnectionchannel.cpp
index 39d09aa..1955dba 100644
--- a/src/network/access/qhttpnetworkconnectionchannel.cpp
+++ b/src/network/access/qhttpnetworkconnectionchannel.cpp
@@ -260,7 +260,7 @@ bool QHttpNetworkConnectionChannel::sendRequest()
         // ensure we try to receive a reply in all cases, even if _q_readyRead_ hat not been called
         // this is needed if the sends an reply before we have finished sending the request. In that
         // case receiveReply had been called before but ignored the server reply
-        QMetaObject::invokeMethod(connection, "_q_receiveReply", Qt::QueuedConnection);
+        QMetaObject::invokeMethod(this, "_q_receiveReply", Qt::QueuedConnection);
         break;
     }
     case QHttpNetworkConnectionChannel::ReadingState:
diff --git a/src/network/access/qnetworkaccessmanager.cpp b/src/network/access/qnetworkaccessmanager.cpp
index d27fbe7..e16aedc 100644
--- a/src/network/access/qnetworkaccessmanager.cpp
+++ b/src/network/access/qnetworkaccessmanager.cpp
@@ -687,10 +687,10 @@ QNetworkReply *QNetworkAccessManager::createRequest(QNetworkAccessManager::Opera
     // Also if the scheme is empty we consider it a file.
     // The QNetworkAccessFileBackend will right now only be used
     // for PUT or qrc://
-    if (op == QNetworkAccessManager::GetOperation
+    if ((op == QNetworkAccessManager::GetOperation || op == QNetworkAccessManager::HeadOperation)
          && (req.url().scheme() == QLatin1String("file")
              || req.url().scheme().isEmpty())) {
-        return new QFileNetworkReply(this, req);
+        return new QFileNetworkReply(this, req, op);
     }
 
     QNetworkRequest request = req;
diff --git a/src/network/access/qnetworkreply.cpp b/src/network/access/qnetworkreply.cpp
index 49a287f..0a8ea5d 100644
--- a/src/network/access/qnetworkreply.cpp
+++ b/src/network/access/qnetworkreply.cpp
@@ -239,7 +239,10 @@ QNetworkReplyPrivate::QNetworkReplyPrivate()
     \note Do not delete the object in the slot connected to this
     signal. Use deleteLater().
 
-    \sa QNetworkAccessManager::finished()
+    You can also use isFinished() to check if a QNetworkReply
+    has finished even before you receive the finished() signal.
+
+    \sa QNetworkAccessManager::finished(), isFinished()
 */
 
 /*!
diff --git a/src/network/ssl/qsslcertificate.cpp b/src/network/ssl/qsslcertificate.cpp
index dd50c38..8993e72 100644
--- a/src/network/ssl/qsslcertificate.cpp
+++ b/src/network/ssl/qsslcertificate.cpp
@@ -304,6 +304,7 @@ static QString _q_SubjectInfoToString(QSslCertificate::SubjectInfo info)
 */
 QString QSslCertificate::issuerInfo(SubjectInfo info) const
 {
+    // lazy init
     if (d->issuerInfo.isEmpty() && d->x509)
         d->issuerInfo =
                 _q_mapFromOnelineName(q_X509_NAME_oneline(q_X509_get_issuer_name(d->x509), 0, 0));
@@ -320,7 +321,11 @@ QString QSslCertificate::issuerInfo(SubjectInfo info) const
 */
 QString QSslCertificate::issuerInfo(const QByteArray &tag) const
 {
-    // ### Use a QByteArray for the keys in the map
+    // lazy init
+    if (d->issuerInfo.isEmpty() && d->x509)
+        d->issuerInfo =
+                _q_mapFromOnelineName(q_X509_NAME_oneline(q_X509_get_issuer_name(d->x509), 0, 0));
+
     return d->issuerInfo.value(QString::fromLatin1(tag));
 }
 
@@ -335,6 +340,7 @@ QString QSslCertificate::issuerInfo(const QByteArray &tag) const
 */
 QString QSslCertificate::subjectInfo(SubjectInfo info) const
 {
+    // lazy init
     if (d->subjectInfo.isEmpty() && d->x509)
         d->subjectInfo =
                 _q_mapFromOnelineName(q_X509_NAME_oneline(q_X509_get_subject_name(d->x509), 0, 0));
@@ -350,7 +356,11 @@ QString QSslCertificate::subjectInfo(SubjectInfo info) const
 */
 QString QSslCertificate::subjectInfo(const QByteArray &tag) const
 {
-    // ### Use a QByteArray for the keys in the map
+    // lazy init
+    if (d->subjectInfo.isEmpty() && d->x509)
+        d->subjectInfo =
+                _q_mapFromOnelineName(q_X509_NAME_oneline(q_X509_get_subject_name(d->x509), 0, 0));
+
     return d->subjectInfo.value(QString::fromLatin1(tag));
 }
 
diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp
index a262ded..3f32cf3 100644
--- a/src/opengl/qgl.cpp
+++ b/src/opengl/qgl.cpp
@@ -124,9 +124,6 @@ public:
 };
 Q_GLOBAL_STATIC(QGLDefaultOverlayFormat, defaultOverlayFormatInstance)
 
-QGLExtensions::Extensions QGLExtensions::glExtensions = 0;
-bool QGLExtensions::nvidiaFboNeedsFinish = false;
-
 Q_GLOBAL_STATIC(QGLSignalProxy, theSignalProxy)
 QGLSignalProxy *QGLSignalProxy::instance()
 {
@@ -154,11 +151,9 @@ public:
         // falling back to the GL 1 engine..
         static bool mac_x1600_check_done = false;
         if (!mac_x1600_check_done) {
-            QGLWidget *tmp = 0;
-            if (!QGLContext::currentContext()) {
-                tmp = new QGLWidget();
-                tmp->makeCurrent();
-            }
+            QGLTemporaryContext *tmp = 0;
+            if (!QGLContext::currentContext())
+                tmp = new QGLTemporaryContext();
             if (strstr((char *) glGetString(GL_RENDERER), "X1600"))
                 engineType = QPaintEngine::OpenGL;
             if (tmp)
@@ -178,7 +173,7 @@ public:
             // from an old GL 1.1 server to a GL 2.x client. In that case we can't
             // use GL 2.0.
             if ((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0)
-                && (QGLExtensions::glExtensions & QGLExtensions::FragmentShader)
+                && (QGLExtensions::glExtensions() & QGLExtensions::FragmentShader)
                 && qgetenv("QT_GL_USE_OPENGL1ENGINE").isEmpty())
                 engineType = QPaintEngine::OpenGL2;
             else
@@ -1250,7 +1245,7 @@ QGLFormat::OpenGLVersionFlags QGLFormat::openGLVersionFlags()
     static bool cachedDefault = false;
     static OpenGLVersionFlags defaultVersionFlags = OpenGL_Version_None;
     QGLContext *currentCtx = const_cast<QGLContext *>(QGLContext::currentContext());
-    QGLWidget *dummy = 0;
+    QGLTemporaryContext *tmpContext = 0;
 
     if (currentCtx && currentCtx->d_func()->version_flags_cached)
         return currentCtx->d_func()->version_flags;
@@ -1261,8 +1256,7 @@ QGLFormat::OpenGLVersionFlags QGLFormat::openGLVersionFlags()
         } else {
             if (!hasOpenGL())
                 return defaultVersionFlags;
-            dummy = new QGLWidget;
-            dummy->makeCurrent(); // glGetString() needs a current context
+            tmpContext = new QGLTemporaryContext;
             cachedDefault = true;
         }
     }
@@ -1273,9 +1267,9 @@ QGLFormat::OpenGLVersionFlags QGLFormat::openGLVersionFlags()
         currentCtx->d_func()->version_flags_cached = true;
         currentCtx->d_func()->version_flags = versionFlags;
     }
-    if (dummy) {
+    if (tmpContext) {
         defaultVersionFlags = versionFlags;
-        delete dummy;
+        delete tmpContext;
     }
 
     return versionFlags;
@@ -1493,6 +1487,8 @@ void QGLContextPrivate::init(QPaintDevice *dev, const QGLFormat &format)
     max_texture_size = -1;
     version_flags_cached = false;
     version_flags = QGLFormat::OpenGL_Version_None;
+    extension_flags_cached = false;
+    extension_flags = 0;
     current_fbo = 0;
     default_fbo = 0;
     active_engine = 0;
@@ -2147,7 +2143,7 @@ QGLTexture* QGLContextPrivate::bindTexture(const QImage &image, GLenum target, G
     int tx_h = qt_next_power_of_two(image.height());
 
     QImage img = image;
-    if (!(QGLExtensions::glExtensions & QGLExtensions::NPOTTextures)
+    if (!(QGLExtensions::glExtensions() & QGLExtensions::NPOTTextures)
         && !(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_ES_Version_2_0)
         && (target == GL_TEXTURE_2D && (tx_w != image.width() || tx_h != image.height())))
     {
@@ -2169,7 +2165,7 @@ QGLTexture* QGLContextPrivate::bindTexture(const QImage &image, GLenum target, G
     bool genMipmap = false;
 #endif
     if (glFormat.directRendering()
-        && (QGLExtensions::glExtensions & QGLExtensions::GenerateMipmap)
+        && (QGLExtensions::glExtensions() & QGLExtensions::GenerateMipmap)
         && target == GL_TEXTURE_2D
         && (options & QGLContext::MipmapBindOption))
     {
@@ -2197,9 +2193,12 @@ QGLTexture* QGLContextPrivate::bindTexture(const QImage &image, GLenum target, G
     bool premul = options & QGLContext::PremultipliedAlphaBindOption;
     GLenum externalFormat;
     GLuint pixel_type;
-    if (QGLExtensions::glExtensions & QGLExtensions::BGRATextureFormat) {
+    if (QGLExtensions::glExtensions() & QGLExtensions::BGRATextureFormat) {
         externalFormat = GL_BGRA;
-        pixel_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+        if (QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2)
+            pixel_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+        else
+            pixel_type = GL_UNSIGNED_BYTE;
     } else {
         externalFormat = GL_RGBA;
         pixel_type = GL_UNSIGNED_BYTE;
@@ -2278,12 +2277,9 @@ QGLTexture* QGLContextPrivate::bindTexture(const QImage &image, GLenum target, G
         qgl_byteSwapImage(img, pixel_type);
     }
 #ifdef QT_OPENGL_ES
-    // OpenGL/ES requires that the internal and external formats be identical.
-    // This is typically used to convert GL_RGBA into GL_BGRA.
-    // Also, we need to use GL_UNSIGNED_BYTE when the format is GL_BGRA.
+    // OpenGL/ES requires that the internal and external formats be
+    // identical.
     internalFormat = externalFormat;
-    if (pixel_type == GL_UNSIGNED_INT_8_8_8_8_REV)
-        pixel_type = GL_UNSIGNED_BYTE;
 #endif
 #ifdef QGL_BIND_TEXTURE_DEBUG
     printf(" - uploading, image.format=%d, externalFormat=0x%x, internalFormat=0x%x, pixel_type=0x%x\n",
@@ -4868,9 +4864,13 @@ QGLWidget::QGLWidget(QGLContext *context, QWidget *parent,
 
 #endif // QT3_SUPPORT
 
-void QGLExtensions::init_extensions()
+/*
+    Returns the GL extensions for the current context.
+*/
+QGLExtensions::Extensions QGLExtensions::currentContextExtensions()
 {
     QGLExtensionMatcher extensions(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)));
+    Extensions glExtensions;
 
     if (extensions.match("GL_ARB_texture_rectangle"))
         glExtensions |= TextureRectangle;
@@ -4931,6 +4931,46 @@ void QGLExtensions::init_extensions()
 
     if (extensions.match("GL_EXT_bgra"))
         glExtensions |= BGRATextureFormat;
+
+    return glExtensions;
+}
+
+/*
+    Returns the GL extensions for the current QGLContext. If there is no
+    current QGLContext, a default context will be created and the extensions
+    for that context will be returned instead.
+*/
+QGLExtensions::Extensions QGLExtensions::glExtensions()
+{
+    QGLTemporaryContext *tmpContext = 0;
+    static bool cachedDefault = false;
+    static Extensions defaultExtensions = 0;
+    QGLContext *currentCtx = const_cast<QGLContext *>(QGLContext::currentContext());
+
+    if (currentCtx && currentCtx->d_func()->extension_flags_cached)
+        return currentCtx->d_func()->extension_flags;
+
+    if (!currentCtx) {
+        if (cachedDefault) {
+            return defaultExtensions;
+        } else {
+            tmpContext = new QGLTemporaryContext;
+            cachedDefault = true;
+        }
+    }
+
+    Extensions extensionFlags = currentContextExtensions();
+    if (currentCtx) {
+        currentCtx->d_func()->extension_flags_cached = true;
+        currentCtx->d_func()->extension_flags = extensionFlags;
+    } else {
+        defaultExtensions = extensionFlags;
+    }
+
+    if (tmpContext)
+        delete tmpContext;
+
+    return extensionFlags;
 }
 
 /*
@@ -4942,7 +4982,6 @@ void QGLWidgetPrivate::initContext(QGLContext *context, const QGLWidget* shareWi
 
     glDevice.setWidget(q);
 
-    QGLExtensions::init();
     glcx = 0;
     autoSwap = true;
 
@@ -5191,7 +5230,7 @@ QSize QGLTexture::bindCompressedTexture
     }
 #if !defined(QT_OPENGL_ES)
     if (!glCompressedTexImage2D) {
-        if (!(QGLExtensions::glExtensions & QGLExtensions::TextureCompression)) {
+        if (!(QGLExtensions::glExtensions() & QGLExtensions::TextureCompression)) {
             qWarning("QGLContext::bindTexture(): The GL implementation does "
                      "not support texture compression extensions.");
             return QSize();
@@ -5230,7 +5269,7 @@ QSize QGLTexture::bindCompressedTextureDDS(const char *buf, int len)
         return QSize();
 
     // Bail out if the necessary extension is not present.
-    if (!(QGLExtensions::glExtensions & QGLExtensions::DDSTextureCompression)) {
+    if (!(QGLExtensions::glExtensions() & QGLExtensions::DDSTextureCompression)) {
         qWarning("QGLContext::bindTexture(): DDS texture compression is not supported.");
         return QSize();
     }
@@ -5340,13 +5379,13 @@ QSize QGLTexture::bindCompressedTexturePVR(const char *buf, int len)
 
     // Bail out if the necessary extension is not present.
     if (textureFormat == GL_ETC1_RGB8_OES) {
-        if (!(QGLExtensions::glExtensions &
+        if (!(QGLExtensions::glExtensions() &
                     QGLExtensions::ETC1TextureCompression)) {
             qWarning("QGLContext::bindTexture(): ETC1 texture compression is not supported.");
             return QSize();
         }
     } else {
-        if (!(QGLExtensions::glExtensions &
+        if (!(QGLExtensions::glExtensions() &
                     QGLExtensions::PVRTCTextureCompression)) {
             qWarning("QGLContext::bindTexture(): PVRTC texture compression is not supported.");
             return QSize();
diff --git a/src/opengl/qgl.h b/src/opengl/qgl.h
index 374c6d6..1a04ff9 100644
--- a/src/opengl/qgl.h
+++ b/src/opengl/qgl.h
@@ -401,6 +401,7 @@ private:
     friend class QGLContextGroup;
     friend class QGLSharedResourceGuard;
     friend class QGLPixmapBlurFilter;
+    friend class QGLExtensions;
     friend QGLFormat::OpenGLVersionFlags QGLFormat::openGLVersionFlags();
 #ifdef Q_WS_MAC
 public:
diff --git a/src/opengl/qgl_mac.mm b/src/opengl/qgl_mac.mm
index 6ed07e5..c01575b 100644
--- a/src/opengl/qgl_mac.mm
+++ b/src/opengl/qgl_mac.mm
@@ -116,6 +116,68 @@ extern void qt_mac_dispose_rgn(RgnHandle); //qregion_mac.cpp
 extern QRegion qt_mac_convert_mac_region(RgnHandle); //qregion_mac.cpp
 extern void qt_mac_to_pascal_string(QString s, Str255 str, TextEncoding encoding=0, int len=-1);  //qglobal.cpp
 
+/*
+    QGLTemporaryContext implementation
+*/
+
+class QGLTemporaryContextPrivate
+{
+public:
+#ifndef QT_MAC_USE_COCOA
+    AGLContext ctx;
+#else
+    NSOpenGLContext *ctx;
+#endif
+};
+
+QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
+    : d(new QGLTemporaryContextPrivate)
+{
+    d->ctx = 0;
+#ifndef QT_MAC_USE_COCOA
+    GLint attribs[] = {AGL_RGBA, AGL_NONE};
+    AGLPixelFormat fmt = aglChoosePixelFormat(0, 0, attribs);
+    if (!fmt) {
+        qDebug("QGLTemporaryContext: Couldn't find any RGB visuals");
+        return;
+    }
+    d->ctx = aglCreateContext(fmt, 0);
+    if (!d->ctx)
+        qDebug("QGLTemporaryContext: Unable to create context");
+    else
+        aglSetCurrentContext(d->ctx);
+    aglDestroyPixelFormat(fmt);
+#else
+    QMacCocoaAutoReleasePool pool;
+    NSOpenGLPixelFormatAttribute attribs[] = { 0 };
+    NSOpenGLPixelFormat *fmt = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
+    if (!fmt) {
+        qWarning("QGLTemporaryContext: Cannot find any visuals");
+        return;
+    }
+
+    d->ctx = [[NSOpenGLContext alloc] initWithFormat:fmt shareContext:0];
+    if (!d->ctx)
+        qWarning("QGLTemporaryContext: Cannot create context");
+    else
+        [d->ctx makeCurrentContext];
+    [fmt release];
+#endif
+}
+
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    if (d->ctx) {
+#ifndef QT_MAC_USE_COCOA
+        aglSetCurrentContext(0);
+        aglDestroyContext(d->ctx);
+#else
+        [NSOpenGLContext clearCurrentContext];
+        [d->ctx release];
+#endif
+    }
+}
+
 bool QGLFormat::hasOpenGL()
 {
     return true;
@@ -918,54 +980,6 @@ void QGLWidgetPrivate::updatePaintDevice()
     q->update();
 }
 
-
-void QGLExtensions::init()
-{
-    static bool init_done = false;
-
-    if (init_done)
-        return;
-    init_done = true;
-
-#ifndef QT_MAC_USE_COCOA
-    GLint attribs[] = { AGL_RGBA, AGL_NONE };
-    AGLPixelFormat fmt = aglChoosePixelFormat(0, 0, attribs);
-    if (!fmt) {
-        qDebug("QGLExtensions: Couldn't find any RGB visuals");
-        return;
-    }
-    AGLContext ctx = aglCreateContext(fmt, 0);
-    if (!ctx) {
-        qDebug("QGLExtensions: Unable to create context");
-    } else {
-        aglSetCurrentContext(ctx);
-        init_extensions();
-        aglSetCurrentContext(0);
-        aglDestroyContext(ctx);
-    }
-    aglDestroyPixelFormat(fmt);
-#else
-    QMacCocoaAutoReleasePool pool;
-    NSOpenGLPixelFormatAttribute attribs[] = { 0 };
-    NSOpenGLPixelFormat *fmt = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
-    if (!fmt) {
-        qWarning("QGLExtensions: Cannot find any visuals");
-        return;
-    }
-
-    NSOpenGLContext *ctx = [[NSOpenGLContext alloc] initWithFormat:fmt shareContext:0];
-    if (!ctx) {
-        qWarning("QGLExtensions: Cannot create context");
-    } else {
-        [ctx makeCurrentContext];
-        init_extensions();
-        [NSOpenGLContext clearCurrentContext];
-        [ctx release];
-    }
-    [fmt release];
-#endif
-}
-
 #endif
 
 QT_END_NAMESPACE
diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h
index 30f5591..0104f07 100644
--- a/src/opengl/qgl_p.h
+++ b/src/opengl/qgl_p.h
@@ -261,6 +261,60 @@ private:
 // "ctx" is destroyed.  Returns null if nothing is sharing with ctx.
 Q_OPENGL_EXPORT const QGLContext *qt_gl_transfer_context(const QGLContext *);
 
+// GL extension definitions
+class QGLExtensions {
+public:
+    enum Extension {
+        TextureRectangle        = 0x00000001,
+        SampleBuffers           = 0x00000002,
+        GenerateMipmap          = 0x00000004,
+        TextureCompression      = 0x00000008,
+        FragmentProgram         = 0x00000010,
+        MirroredRepeat          = 0x00000020,
+        FramebufferObject       = 0x00000040,
+        StencilTwoSide          = 0x00000080,
+        StencilWrap             = 0x00000100,
+        PackedDepthStencil      = 0x00000200,
+        NVFloatBuffer           = 0x00000400,
+        PixelBufferObject       = 0x00000800,
+        FramebufferBlit         = 0x00001000,
+        NPOTTextures            = 0x00002000,
+        BGRATextureFormat       = 0x00004000,
+        DDSTextureCompression   = 0x00008000,
+        ETC1TextureCompression  = 0x00010000,
+        PVRTCTextureCompression = 0x00020000,
+        FragmentShader          = 0x00040000
+    };
+    Q_DECLARE_FLAGS(Extensions, Extension)
+
+    static Extensions glExtensions();
+
+private:
+    static Extensions currentContextExtensions();
+};
+
+/*
+    QGLTemporaryContext - the main objective of this class is to have a way of
+    creating a GL context and making it current, without going via QGLWidget
+    and friends. At certain points during GL initialization we need a current
+    context in order decide what GL features are available, and to resolve GL
+    extensions. Having a light-weight way of creating such a context saves
+    initial application startup time, and it doesn't wind up creating recursive
+    conflicts.
+    The class currently uses a private d pointer to hide the platform specific
+    types. This could possibly been done inline with #ifdef'ery, but it causes
+    major headaches on e.g. X11 due to namespace pollution.
+*/
+class QGLTemporaryContextPrivate;
+class QGLTemporaryContext {
+public:
+    QGLTemporaryContext(bool directRendering = true, QWidget *parent = 0);
+    ~QGLTemporaryContext();
+
+private:
+    QScopedPointer<QGLTemporaryContextPrivate> d;
+};
+
 class QGLTexture;
 
 // This probably needs to grow to GL_MAX_VERTEX_ATTRIBS, but 3 is ok for now as that's
@@ -333,10 +387,12 @@ public:
     uint crWin : 1;
     uint internal_context : 1;
     uint version_flags_cached : 1;
+    uint extension_flags_cached : 1;
     QPaintDevice *paintDevice;
     QColor transpColor;
     QGLContext *q_ptr;
     QGLFormat::OpenGLVersionFlags version_flags;
+    QGLExtensions::Extensions extension_flags;
 
     QGLContextGroup *group;
     GLint max_texture_size;
@@ -375,41 +431,8 @@ Q_SIGNALS:
     void aboutToDestroyContext(const QGLContext *context);
 };
 
-// GL extension definitions
-class QGLExtensions {
-public:
-    enum Extension {
-        TextureRectangle        = 0x00000001,
-        SampleBuffers           = 0x00000002,
-        GenerateMipmap          = 0x00000004,
-        TextureCompression      = 0x00000008,
-        FragmentProgram         = 0x00000010,
-        MirroredRepeat          = 0x00000020,
-        FramebufferObject       = 0x00000040,
-        StencilTwoSide          = 0x00000080,
-        StencilWrap             = 0x00000100,
-        PackedDepthStencil      = 0x00000200,
-        NVFloatBuffer           = 0x00000400,
-        PixelBufferObject       = 0x00000800,
-        FramebufferBlit         = 0x00001000,
-        NPOTTextures            = 0x00002000,
-        BGRATextureFormat       = 0x00004000,
-        DDSTextureCompression   = 0x00008000,
-        ETC1TextureCompression  = 0x00010000,
-        PVRTCTextureCompression = 0x00020000,
-        FragmentShader          = 0x00040000
-    };
-    Q_DECLARE_FLAGS(Extensions, Extension)
-
-    static Extensions glExtensions;
-    static bool nvidiaFboNeedsFinish;
-    static void init(); // sys dependent
-    static void init_extensions(); // general: called by init()
-};
-
 Q_DECLARE_OPERATORS_FOR_FLAGS(QGLExtensions::Extensions)
 
-
 // Temporarily make a context current if not already current or
 // shared with the current contex.  The previous context is made
 // current when the object goes out of scope.
@@ -533,7 +556,7 @@ bool qt_gl_preferGL2Engine();
 
 inline GLenum qt_gl_preferredTextureFormat()
 {
-    return (QGLExtensions::glExtensions & QGLExtensions::BGRATextureFormat) && QSysInfo::ByteOrder == QSysInfo::LittleEndian
+    return (QGLExtensions::glExtensions() & QGLExtensions::BGRATextureFormat) && QSysInfo::ByteOrder == QSysInfo::LittleEndian
         ? GL_BGRA : GL_RGBA;
 }
 
@@ -542,7 +565,7 @@ inline GLenum qt_gl_preferredTextureTarget()
 #if defined(QT_OPENGL_ES_2)
     return GL_TEXTURE_2D;
 #else
-    return (QGLExtensions::glExtensions & QGLExtensions::TextureRectangle)
+    return (QGLExtensions::glExtensions() & QGLExtensions::TextureRectangle)
            && !qt_gl_preferGL2Engine()
            ? GL_TEXTURE_RECTANGLE_NV
            : GL_TEXTURE_2D;
@@ -614,7 +637,7 @@ private:
 };
 
 
-// This class can be used to match GL extensions with doing any mallocs. The
+// This class can be used to match GL extensions without doing any mallocs. The
 // class assumes that the GL extension string ends with a space character,
 // which it should do on all conformant platforms. Create the object and pass
 // in a pointer to the extension string, then call match() on each extension
diff --git a/src/opengl/qgl_qws.cpp b/src/opengl/qgl_qws.cpp
index f69ad7b..d4adc8b 100644
--- a/src/opengl/qgl_qws.cpp
+++ b/src/opengl/qgl_qws.cpp
@@ -83,6 +83,28 @@ static QGLScreen *glScreenForDevice(QPaintDevice *device)
         return 0;
 }
 
+/*
+    QGLTemporaryContext implementation
+*/
+
+class QGLTemporaryContextPrivate
+{
+public:
+    QGLWidget *widget;
+};
+
+QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
+    : d(new QGLTemporaryContextPrivate)
+{
+    d->widget = new QGLWidget;
+    d->widget->makeCurrent();
+}
+
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    delete d->widget;
+}
+
 /*****************************************************************************
   QOpenGL debug facilities
  *****************************************************************************/
@@ -311,36 +333,4 @@ void QGLWidget::setColormap(const QGLColormap &)
 {
 }
 
-void QGLExtensions::init()
-{
-    static bool init_done = false;
-
-    if (init_done)
-        return;
-    init_done = true;
-
-    // We need a context current to initialize the extensions,
-    // but getting a valid EGLNativeWindowType this early can be
-    // problematic under QWS.  So use a pbuffer instead.
-    //
-    // Unfortunately OpenGL/ES 2.0 systems don't normally
-    // support pbuffers, so we have no choice but to try
-    // our luck with a window on those systems.
-#if defined(QT_OPENGL_ES_2)
-    QGLWidget tmpWidget;
-    tmpWidget.makeCurrent();
-
-    init_extensions();
-
-    tmpWidget.doneCurrent();
-#else
-    QGLPixelBuffer pbuffer(16, 16);
-    pbuffer.makeCurrent();
-
-    init_extensions();
-
-    pbuffer.doneCurrent();
-#endif
-}
-
 QT_END_NAMESPACE
diff --git a/src/opengl/qgl_win.cpp b/src/opengl/qgl_win.cpp
index 443fbf2..ed4814f 100644
--- a/src/opengl/qgl_win.cpp
+++ b/src/opengl/qgl_win.cpp
@@ -551,7 +551,7 @@ QGLFormat pfiToQGLFormat(HDC hdc, int pfi)
     QVarLengthArray<int> iAttributes(40);
     QVarLengthArray<int> iValues(40);
     int i = 0;
-    bool has_sample_buffers = QGLExtensions::glExtensions & QGLExtensions::SampleBuffers;
+    bool has_sample_buffers = QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers;
 
     iAttributes[i++] = WGL_DOUBLE_BUFFER_ARB; // 0
     iAttributes[i++] = WGL_DEPTH_BITS_ARB; // 1
@@ -628,52 +628,14 @@ QGLFormat pfiToQGLFormat(HDC hdc, int pfi)
 
 
 /*
-   Creates a temporary GL context and makes it current
-   - cleans up when the object is destructed.
+    QGLTemporaryContext implementation
 */
 
 Q_GUI_EXPORT const QString qt_getRegisteredWndClass();
 
-class QGLTempContext
+class QGLTemporaryContextPrivate
 {
 public:
-    QGLTempContext(bool directRendering, QWidget *parent = 0)
-    {
-        QString windowClassName = qt_getRegisteredWndClass();
-        if (parent && !parent->internalWinId())
-            parent = parent->nativeParentWidget();
-
-        dmy_id = CreateWindow((const wchar_t *)windowClassName.utf16(),
-                              0, 0, 0, 0, 1, 1,
-                              parent ? parent->winId() : 0, 0, qWinAppInst(), 0);
-
-        dmy_pdc = GetDC(dmy_id);
-        PIXELFORMATDESCRIPTOR dmy_pfd;
-        memset(&dmy_pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
-        dmy_pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
-        dmy_pfd.nVersion = 1;
-        dmy_pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
-        dmy_pfd.iPixelType = PFD_TYPE_RGBA;
-        if (!directRendering)
-            dmy_pfd.dwFlags |= PFD_GENERIC_FORMAT;
-
-        int dmy_pf = ChoosePixelFormat(dmy_pdc, &dmy_pfd);
-        SetPixelFormat(dmy_pdc, dmy_pf, &dmy_pfd);
-        dmy_rc = wglCreateContext(dmy_pdc);
-        old_dc = wglGetCurrentDC();
-        old_context = wglGetCurrentContext();
-        wglMakeCurrent(dmy_pdc, dmy_rc);
-    }
-
-    ~QGLTempContext() {
-        wglMakeCurrent(dmy_pdc, 0);
-        wglDeleteContext(dmy_rc);
-        ReleaseDC(dmy_id, dmy_pdc);
-        DestroyWindow(dmy_id);
-        if (old_dc && old_context)
-            wglMakeCurrent(old_dc, old_context);
-    }
-
     HDC dmy_pdc;
     HGLRC dmy_rc;
     HDC old_dc;
@@ -681,6 +643,45 @@ public:
     WId dmy_id;
 };
 
+QGLTemporaryContext::QGLTemporaryContext(bool directRendering, QWidget *parent)
+    : d(new QGLTemporaryContextPrivate)
+{
+    QString windowClassName = qt_getRegisteredWndClass();
+    if (parent && !parent->internalWinId())
+        parent = parent->nativeParentWidget();
+
+    d->dmy_id = CreateWindow((const wchar_t *)windowClassName.utf16(),
+                             0, 0, 0, 0, 1, 1,
+                             parent ? parent->winId() : 0, 0, qWinAppInst(), 0);
+
+    d->dmy_pdc = GetDC(d->dmy_id);
+    PIXELFORMATDESCRIPTOR dmy_pfd;
+    memset(&dmy_pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
+    dmy_pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
+    dmy_pfd.nVersion = 1;
+    dmy_pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
+    dmy_pfd.iPixelType = PFD_TYPE_RGBA;
+    if (!directRendering)
+        dmy_pfd.dwFlags |= PFD_GENERIC_FORMAT;
+
+    int dmy_pf = ChoosePixelFormat(d->dmy_pdc, &dmy_pfd);
+    SetPixelFormat(d->dmy_pdc, dmy_pf, &dmy_pfd);
+    d->dmy_rc = wglCreateContext(d->dmy_pdc);
+    d->old_dc = wglGetCurrentDC();
+    d->old_context = wglGetCurrentContext();
+    wglMakeCurrent(d->dmy_pdc, d->dmy_rc);
+}
+
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    wglMakeCurrent(d->dmy_pdc, 0);
+    wglDeleteContext(d->dmy_rc);
+    ReleaseDC(d->dmy_id, d->dmy_pdc);
+    DestroyWindow(d->dmy_id);
+    if (d->old_dc && d->old_context)
+        wglMakeCurrent(d->old_dc, d->old_context);
+}
+
 bool QGLContext::chooseContext(const QGLContext* shareContext)
 {
     Q_D(QGLContext);
@@ -721,10 +722,10 @@ bool QGLContext::chooseContext(const QGLContext* shareContext)
         myDc = GetDC(d->win);
     }
 
-    // NB! the QGLTempContext object is needed for the
+    // NB! the QGLTemporaryContext object is needed for the
     // wglGetProcAddress() calls to succeed and are absolutely
     // necessary - don't remove!
-    QGLTempContext tmp_ctx(d->glFormat.directRendering(), widget);
+    QGLTemporaryContext tmp_ctx(d->glFormat.directRendering(), widget);
 
     if (!myDc) {
         qWarning("QGLContext::chooseContext(): Paint device cannot be null");
@@ -965,7 +966,7 @@ int QGLContext::choosePixelFormat(void* dummyPfd, HDC pdc)
             iAttributes[i++] = 1;
         }
         int si = 0;
-        bool trySampleBuffers = QGLExtensions::glExtensions & QGLExtensions::SampleBuffers;
+        bool trySampleBuffers = QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers;
         if (trySampleBuffers && d->glFormat.sampleBuffers()) {
             iAttributes[i++] = WGL_SAMPLE_BUFFERS_ARB;
             iAttributes[i++] = TRUE;
@@ -1471,15 +1472,4 @@ void QGLWidget::setColormap(const QGLColormap & c)
     }
 }
 
-void QGLExtensions::init()
-{
-    static bool init_done = false;
-
-    if (init_done)
-        return;
-    init_done = true;
-    QGLTempContext temp_ctx(QGLFormat::defaultFormat().directRendering());
-    init_extensions();
-}
-
 QT_END_NAMESPACE
diff --git a/src/opengl/qgl_wince.cpp b/src/opengl/qgl_wince.cpp
index 460f10d..00a125a 100644
--- a/src/opengl/qgl_wince.cpp
+++ b/src/opengl/qgl_wince.cpp
@@ -95,8 +95,27 @@ public:
 
 #include <qcolor.h>
 
+/*
+    QGLTemporaryContext implementation
+*/
 
+class QGLTemporaryContextPrivate
+{
+public:
+    QGLWidget *widget;
+};
 
+QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
+    : d(new QGLTemporaryContextPrivate)
+{
+    d->widget = new QGLWidget;
+    d->widget->makeCurrent();
+}
+
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    delete d->widget;
+}
 
 /*****************************************************************************
   QGLFormat Win32/WGL-specific code
@@ -627,21 +646,4 @@ void QGLWidget::setColormap(const QGLColormap & c)
     }
 }
 
-void QGLExtensions::init()
-{
-    static bool init_done = false;
-
-    if (init_done)
-        return;
-    init_done = true;
-
-    // We need a context current to initialize the extensions.
-    QGLWidget tmpWidget;
-    tmpWidget.makeCurrent();
-
-    init_extensions();
-
-    tmpWidget.doneCurrent();
-}
-
 QT_END_NAMESPACE
diff --git a/src/opengl/qgl_x11.cpp b/src/opengl/qgl_x11.cpp
index e883ddc..f4cc7c7 100644
--- a/src/opengl/qgl_x11.cpp
+++ b/src/opengl/qgl_x11.cpp
@@ -549,7 +549,7 @@ void *QGLContext::chooseVisual()
     bool triedDouble = false;
     bool triedSample = false;
     if (fmt.sampleBuffers())
-        fmt.setSampleBuffers(QGLExtensions::glExtensions & QGLExtensions::SampleBuffers);
+        fmt.setSampleBuffers(QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers);
     while(!fail && !(vis = tryVisual(fmt, bufDepths[i]))) {
         if (!fmt.rgba() && bufDepths[i] > 1) {
             i++;
@@ -1132,71 +1132,70 @@ void *QGLContext::getProcAddress(const QString &proc) const
     return glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(proc.toLatin1().data()));
 }
 
-//
-// This class is used to create a temporary, minimal GL context, which is used
-// to retrive GL version and extension info. It's significantly faster to
-// construct than a QGLWidget, and it doesn't have the recursive creation
-// problem that QGLWidget would have. E.g. creating a temporary QGLWidget to
-// retrieve GL info as part of the QGLWidget initialization.
-//
-class QGLTempContext
-{
+/*
+    QGLTemporaryContext implementation
+*/
+
+class QGLTemporaryContextPrivate {
 public:
-    QGLTempContext(int screen = 0) :
-            initialized(false),
-            old_drawable(0),
-            old_context(0)
-    {
-        int attribs[] = {GLX_RGBA, XNone};
-        XVisualInfo *vi = glXChooseVisual(X11->display, screen, attribs);
-        if (!vi) {
-            qWarning("QGLTempContext: No GL capable X visuals available.");
-            return;
-        }
+    bool initialized;
+    Window drawable;
+    GLXContext context;
+    GLXDrawable oldDrawable;
+    GLXContext oldContext;
+};
 
-        int useGL;
-        glXGetConfig(X11->display, vi, GLX_USE_GL, &useGL);
-        if (!useGL) {
-            XFree(vi);
-            return;
-        }
+QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
+    : d(new QGLTemporaryContextPrivate)
+{
+    d->initialized = false;
+    d->oldDrawable = 0;
+    d->oldContext = 0;
+    int screen = 0;
+
+    int attribs[] = {GLX_RGBA, XNone};
+    XVisualInfo *vi = glXChooseVisual(X11->display, screen, attribs);
+    if (!vi) {
+        qWarning("QGLTempContext: No GL capable X visuals available.");
+        return;
+    }
 
-        old_drawable = glXGetCurrentDrawable();
-        old_context = glXGetCurrentContext();
-
-        XSetWindowAttributes a;
-        a.colormap = qt_gl_choose_cmap(X11->display, vi);
-        drawable = XCreateWindow(X11->display, RootWindow(X11->display, screen),
-                                 0, 0, 1, 1, 0,
-                                 vi->depth, InputOutput, vi->visual,
-                                 CWColormap, &a);
-        context = glXCreateContext(X11->display, vi, 0, True);
-        if (context && glXMakeCurrent(X11->display, drawable, context)) {
-            initialized = true;
-        } else {
-            qWarning("QGLTempContext: Unable to create GL context.");
-            XDestroyWindow(X11->display, drawable);
-        }
+    int useGL;
+    glXGetConfig(X11->display, vi, GLX_USE_GL, &useGL);
+    if (!useGL) {
         XFree(vi);
+        return;
     }
 
-    ~QGLTempContext() {
-        if (initialized) {
-            glXMakeCurrent(X11->display, 0, 0);
-            glXDestroyContext(X11->display, context);
-            XDestroyWindow(X11->display, drawable);
-        }
-        if (old_drawable && old_context)
-            glXMakeCurrent(X11->display, old_drawable, old_context);
+    d->oldDrawable = glXGetCurrentDrawable();
+    d->oldContext = glXGetCurrentContext();
+
+    XSetWindowAttributes a;
+    a.colormap = qt_gl_choose_cmap(X11->display, vi);
+    d->drawable = XCreateWindow(X11->display, RootWindow(X11->display, screen),
+                                0, 0, 1, 1, 0,
+                                vi->depth, InputOutput, vi->visual,
+                                CWColormap, &a);
+    d->context = glXCreateContext(X11->display, vi, 0, True);
+    if (d->context && glXMakeCurrent(X11->display, d->drawable, d->context)) {
+        d->initialized = true;
+    } else {
+        qWarning("QGLTempContext: Unable to create GL context.");
+        XDestroyWindow(X11->display, d->drawable);
     }
+    XFree(vi);
+}
 
-private:
-    bool initialized;
-    Window drawable;
-    GLXContext context;
-    GLXDrawable old_drawable;
-    GLXContext old_context;
-};
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    if (d->initialized) {
+        glXMakeCurrent(X11->display, 0, 0);
+        glXDestroyContext(X11->display, d->context);
+        XDestroyWindow(X11->display, d->drawable);
+    }
+    if (d->oldDrawable && d->oldContext)
+        glXMakeCurrent(X11->display, d->oldDrawable, d->oldContext);
+}
 
 /*****************************************************************************
   QGLOverlayWidget (Internal overlay class for X11)
@@ -1632,27 +1631,6 @@ void QGLWidget::setColormap(const QGLColormap & c)
     delete [] cmw;
 }
 
-void QGLExtensions::init()
-{
-    static bool init_done = false;
-
-    if (init_done)
-        return;
-    init_done = true;
-
-    QGLTempContext context;
-    init_extensions();
-
-    // nvidia 9x.xx unix drivers contain a bug which requires us to call glFinish before releasing an fbo
-    // to avoid painting artifacts
-    const QByteArray versionString(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
-    const int pos = versionString.indexOf("NVIDIA");
-    if (pos >= 0) {
-        const float nvidiaDriverVersion = versionString.mid(pos + strlen("NVIDIA")).toFloat();
-        nvidiaFboNeedsFinish = nvidiaDriverVersion >= 90.0 && nvidiaDriverVersion < 100.0;
-    }
-}
-
 // Solaris defines glXBindTexImageEXT as part of the GL library
 #if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
 typedef void (*qt_glXBindTexImageEXT)(Display*, GLXDrawable, int, const int*);
@@ -1668,7 +1646,7 @@ static bool qt_resolveTextureFromPixmap(QPaintDevice *paintDevice)
         resolvedTextureFromPixmap = true;
 
         // Check to see if we have NPOT texture support
-        if ( !(QGLExtensions::glExtensions & QGLExtensions::NPOTTextures) &&
+        if ( !(QGLExtensions::glExtensions() & QGLExtensions::NPOTTextures) &&
              !(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0))
         {
             return false; // Can't use TFP without NPOT
diff --git a/src/opengl/qgl_x11egl.cpp b/src/opengl/qgl_x11egl.cpp
index 85daf95..572834b 100644
--- a/src/opengl/qgl_x11egl.cpp
+++ b/src/opengl/qgl_x11egl.cpp
@@ -55,112 +55,115 @@ QT_BEGIN_NAMESPACE
 
 bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig config,
                              const QX11Info &x11Info, bool useArgbVisual);
-//
-// QGLTempContext is a class for creating a temporary GL context
-// (which is needed during QGLWidget initialization to retrieve GL
-// extension info).  Faster to construct than a full QGLWidget.
-//
-class QGLTempContext
+
+/*
+    QGLTemporaryContext implementation
+*/
+
+class QGLTemporaryContextPrivate
 {
 public:
-    QGLTempContext(int screen = 0) :
-        initialized(false),
-        window(0),
-        context(0),
-        surface(0)
-    {
-        display = eglGetDisplay(EGLNativeDisplayType(X11->display));
+    bool initialized;
+    Window window;
+    EGLContext context;
+    EGLSurface surface;
+    EGLDisplay display;
+};
 
-        if (!eglInitialize(display, NULL, NULL)) {
-            qWarning("QGLTempContext: Unable to initialize EGL display.");
-            return;
-        }
+QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
+    : d(new QGLTemporaryContextPrivate)
+{
+    d->initialized = false;
+    d->window = 0;
+    d->context = 0;
+    d->surface = 0;
+    int screen = 0;
+
+    d->display = eglGetDisplay(EGLNativeDisplayType(X11->display));
 
-        EGLConfig config;
-        int numConfigs = 0;
-        EGLint attribs[] = {
-            EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+    if (!eglInitialize(d->display, NULL, NULL)) {
+        qWarning("QGLTemporaryContext: Unable to initialize EGL display.");
+        return;
+    }
+
+    EGLConfig config;
+    int numConfigs = 0;
+    EGLint attribs[] = {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
 #ifdef QT_OPENGL_ES_2
-            EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
 #endif
-            EGL_NONE
-        };
+        EGL_NONE
+    };
 
-        eglChooseConfig(display, attribs, &config, 1, &numConfigs);
-        if (!numConfigs) {
-            qWarning("QGLTempContext: No EGL configurations available.");
-            return;
-        }
+    eglChooseConfig(d->display, attribs, &config, 1, &numConfigs);
+    if (!numConfigs) {
+        qWarning("QGLTemporaryContext: No EGL configurations available.");
+        return;
+    }
 
-        XVisualInfo visualInfo;
-        XVisualInfo *vi;
-        int numVisuals;
-        EGLint id = 0;
-
-        eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &id);
-        if (id == 0) {
-            // EGL_NATIVE_VISUAL_ID is optional and might not be supported
-            // on some implementations - we'll have to do it the hard way
-            QX11Info xinfo;
-            qt_egl_setup_x11_visual(visualInfo, display, config, xinfo, false);
-        } else {
-            visualInfo.visualid = id;
-        }
-        vi = XGetVisualInfo(X11->display, VisualIDMask, &visualInfo, &numVisuals);
-        if (!vi || numVisuals < 1) {
-            qWarning("QGLTempContext: Unable to get X11 visual info id.");
-            return;
-        }
+    XVisualInfo visualInfo;
+    XVisualInfo *vi;
+    int numVisuals;
+    EGLint id = 0;
+
+    eglGetConfigAttrib(d->display, config, EGL_NATIVE_VISUAL_ID, &id);
+    if (id == 0) {
+        // EGL_NATIVE_VISUAL_ID is optional and might not be supported
+        // on some implementations - we'll have to do it the hard way
+        QX11Info xinfo;
+        qt_egl_setup_x11_visual(visualInfo, d->display, config, xinfo, false);
+    } else {
+        visualInfo.visualid = id;
+    }
+    vi = XGetVisualInfo(X11->display, VisualIDMask, &visualInfo, &numVisuals);
+    if (!vi || numVisuals < 1) {
+        qWarning("QGLTemporaryContext: Unable to get X11 visual info id.");
+        return;
+    }
 
-        window = XCreateWindow(X11->display, RootWindow(X11->display, screen),
-                               0, 0, 1, 1, 0,
-                               vi->depth, InputOutput, vi->visual,
-                               0, 0);
+    d->window = XCreateWindow(X11->display, RootWindow(X11->display, screen),
+                              0, 0, 1, 1, 0,
+                              vi->depth, InputOutput, vi->visual,
+                              0, 0);
 
-        surface = eglCreateWindowSurface(display, config, (EGLNativeWindowType) window, NULL);
+    d->surface = eglCreateWindowSurface(d->display, config, (EGLNativeWindowType) d->window, NULL);
 
-        if (surface == EGL_NO_SURFACE) {
-            qWarning("QGLTempContext: Error creating EGL surface.");
-            XFree(vi);
-            XDestroyWindow(X11->display, window);
-            return;
-        }
+    if (d->surface == EGL_NO_SURFACE) {
+        qWarning("QGLTemporaryContext: Error creating EGL surface.");
+        XFree(vi);
+        XDestroyWindow(X11->display, d->window);
+        return;
+    }
 
-        EGLint contextAttribs[] = {
+    EGLint contextAttribs[] = {
 #ifdef QT_OPENGL_ES_2
-            EGL_CONTEXT_CLIENT_VERSION, 2,
+        EGL_CONTEXT_CLIENT_VERSION, 2,
 #endif
-            EGL_NONE
-        };
-        context = eglCreateContext(display, config, 0, contextAttribs);
-        if (context != EGL_NO_CONTEXT
-            && eglMakeCurrent(display, surface, surface, context))
-        {
-            initialized = true;
-        } else {
-            qWarning("QGLTempContext: Error creating EGL context.");
-            eglDestroySurface(display, surface);
-            XDestroyWindow(X11->display, window);
-        }
-        XFree(vi);
+        EGL_NONE
+    };
+    d->context = eglCreateContext(d->display, config, 0, contextAttribs);
+    if (d->context != EGL_NO_CONTEXT
+        && eglMakeCurrent(d->display, d->surface, d->surface, d->context))
+    {
+        d->initialized = true;
+    } else {
+        qWarning("QGLTemporaryContext: Error creating EGL context.");
+        eglDestroySurface(d->display, d->surface);
+        XDestroyWindow(X11->display, d->window);
     }
+    XFree(vi);
+}
 
-    ~QGLTempContext() {
-        if (initialized) {
-            eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-            eglDestroyContext(display, context);
-            eglDestroySurface(display, surface);
-            XDestroyWindow(X11->display, window);
-        }
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    if (d->initialized) {
+        eglMakeCurrent(d->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+        eglDestroyContext(d->display, d->context);
+        eglDestroySurface(d->display, d->surface);
+        XDestroyWindow(X11->display, d->window);
     }
-
-private:
-    bool initialized;
-    Window window;
-    EGLContext context;
-    EGLSurface surface;
-    EGLDisplay display;
-};
+}
 
 bool QGLFormat::hasOpenGLOverlays()
 {
@@ -547,19 +550,6 @@ void QGLWidget::setColormap(const QGLColormap &)
 {
 }
 
-void QGLExtensions::init()
-{
-    static bool init_done = false;
-
-    if (init_done)
-        return;
-    init_done = true;
-
-    // We need a context current to initialize the extensions.
-    QGLTempContext context;
-    init_extensions();
-}
-
 // Re-creates the EGL surface if the window ID has changed or if force is true
 void QGLWidgetPrivate::recreateEglSurface(bool force)
 {
diff --git a/src/opengl/qglframebufferobject.cpp b/src/opengl/qglframebufferobject.cpp
index ed21923..ce80796 100644
--- a/src/opengl/qglframebufferobject.cpp
+++ b/src/opengl/qglframebufferobject.cpp
@@ -396,7 +396,7 @@ void QGLFramebufferObjectPrivate::init(QGLFramebufferObject *q, const QSize &sz,
     QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());
     fbo_guard.setContext(ctx);
 
-    bool ext_detected = (QGLExtensions::glExtensions & QGLExtensions::FramebufferObject);
+    bool ext_detected = (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject);
     if (!ext_detected || (ext_detected && !qt_resolve_framebufferobject_extensions(ctx)))
         return;
 
@@ -466,7 +466,7 @@ void QGLFramebufferObjectPrivate::init(QGLFramebufferObject *q, const QSize &sz,
     }
 
     if (attachment == QGLFramebufferObject::CombinedDepthStencil
-        && (QGLExtensions::glExtensions & QGLExtensions::PackedDepthStencil)) {
+        && (QGLExtensions::glExtensions() & QGLExtensions::PackedDepthStencil)) {
         // depth and stencil buffer needs another extension
         glGenRenderbuffers(1, &depth_stencil_buffer);
         Q_ASSERT(!glIsRenderbuffer(depth_stencil_buffer));
@@ -1028,8 +1028,7 @@ QPaintEngine *QGLFramebufferObject::paintEngine() const
 */
 bool QGLFramebufferObject::hasOpenGLFramebufferObjects()
 {
-    QGLExtensions::init();
-    return (QGLExtensions::glExtensions & QGLExtensions::FramebufferObject);
+    return (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject);
 }
 
 /*!
@@ -1188,8 +1187,7 @@ bool QGLFramebufferObject::isBound() const
 */
 bool QGLFramebufferObject::hasOpenGLFramebufferBlit()
 {
-    QGLExtensions::init();
-    return (QGLExtensions::glExtensions & QGLExtensions::FramebufferBlit);
+    return (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit);
 }
 
 /*!
@@ -1229,7 +1227,7 @@ void QGLFramebufferObject::blitFramebuffer(QGLFramebufferObject *target, const Q
                                            GLbitfield buffers,
                                            GLenum filter)
 {
-    if (!(QGLExtensions::glExtensions & QGLExtensions::FramebufferBlit))
+    if (!(QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit))
         return;
 
     const QGLContext *ctx = QGLContext::currentContext();
diff --git a/src/opengl/qglpixelbuffer_mac.mm b/src/opengl/qglpixelbuffer_mac.mm
index 49c1845..6731dd8 100644
--- a/src/opengl/qglpixelbuffer_mac.mm
+++ b/src/opengl/qglpixelbuffer_mac.mm
@@ -92,7 +92,7 @@ bool QGLPixelBufferPrivate::init(const QSize &size, const QGLFormat &f, QGLWidge
 
     GLenum target = GL_TEXTURE_2D;
 
-    if ((QGLExtensions::glExtensions & QGLExtensions::TextureRectangle)
+    if ((QGLExtensions::glExtensions() & QGLExtensions::TextureRectangle)
         && (size.width() != nearest_gl_texture_size(size.width())
             || size.height() != nearest_gl_texture_size(size.height())))
     {
@@ -223,7 +223,7 @@ bool QGLPixelBufferPrivate::init(const QSize &size, const QGLFormat &f, QGLWidge
 
     GLenum target = GL_TEXTURE_2D;
 
-    if ((QGLExtensions::glExtensions & QGLExtensions::TextureRectangle)
+    if ((QGLExtensions::glExtensions() & QGLExtensions::TextureRectangle)
         && (size.width() != nearest_gl_texture_size(size.width())
             || size.height() != nearest_gl_texture_size(size.height())))
     {
diff --git a/src/opengl/qglpixelbuffer_p.h b/src/opengl/qglpixelbuffer_p.h
index f40b7c5..c85dc5a 100644
--- a/src/opengl/qglpixelbuffer_p.h
+++ b/src/opengl/qglpixelbuffer_p.h
@@ -154,7 +154,6 @@ class QGLPixelBufferPrivate {
 public:
     QGLPixelBufferPrivate(QGLPixelBuffer *q) : q_ptr(q), invalid(true), qctx(0), pbuf(0), ctx(0)
     {
-        QGLExtensions::init();
 #ifdef Q_WS_WIN
         dc = 0;
 #elif defined(Q_WS_MACX)
diff --git a/src/opengl/qglpixelbuffer_win.cpp b/src/opengl/qglpixelbuffer_win.cpp
index a986ccf..8d0d105 100644
--- a/src/opengl/qglpixelbuffer_win.cpp
+++ b/src/opengl/qglpixelbuffer_win.cpp
@@ -221,7 +221,7 @@ static void qt_format_to_attrib_list(bool has_render_texture, const QGLFormat &f
     }
     if ((f.redBufferSize() > 8 || f.greenBufferSize() > 8
          || f.blueBufferSize() > 8 || f.alphaBufferSize() > 8)
-        && (QGLExtensions::glExtensions & QGLExtensions::NVFloatBuffer))
+        && (QGLExtensions::glExtensions() & QGLExtensions::NVFloatBuffer))
     {
         attribs[i++] = WGL_FLOAT_COMPONENTS_NV;
         attribs[i++] = TRUE;
@@ -368,11 +368,9 @@ void QGLPixelBuffer::releaseFromDynamicTexture()
 bool QGLPixelBuffer::hasOpenGLPbuffers()
 {
     bool ret = false;
-    QGLWidget *dmy = 0;
-    if (!QGLContext::currentContext()) {
-        dmy = new QGLWidget;
-        dmy->makeCurrent();
-    }
+    QGLTemporaryContext *tmpContext = 0;
+    if (!QGLContext::currentContext())
+        tmpContext = new QGLTemporaryContext;
     PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB =
         (PFNWGLGETEXTENSIONSSTRINGARBPROC) wglGetProcAddress("wglGetExtensionsStringARB");
     if (wglGetExtensionsStringARB) {
@@ -382,8 +380,8 @@ bool QGLPixelBuffer::hasOpenGLPbuffers()
             ret = true;
         }
     }
-    if (dmy)
-        delete dmy;
+    if (tmpContext)
+        delete tmpContext;
     return ret;
 }
 
diff --git a/src/opengl/qpaintengine_opengl.cpp b/src/opengl/qpaintengine_opengl.cpp
index c823187..57918d0 100644
--- a/src/opengl/qpaintengine_opengl.cpp
+++ b/src/opengl/qpaintengine_opengl.cpp
@@ -108,6 +108,10 @@ static bool DEBUG_TEMP_FLAG;
 #define DEBUG_ONCE_STR(str) DEBUG_ONCE qDebug() << (str);
 #endif
 
+#ifdef Q_WS_X11
+static bool qt_nvidiaFboNeedsFinish = false;
+#endif
+
 static inline void qt_glColor4ubv(unsigned char *col)
 {
     glColor4f(col[0]/255.0f, col[1]/255.0f, col[2]/255.0f, col[3]/255.0f);
@@ -423,7 +427,7 @@ inline void QGLOffscreen::release()
 
 #ifdef Q_WS_X11
     // workaround for bug in nvidia driver versions 9x.xx
-    if (QGLExtensions::nvidiaFboNeedsFinish)
+    if (qt_nvidiaFboNeedsFinish)
         glFinish();
 #endif
 
@@ -477,7 +481,7 @@ inline QGLContext *QGLOffscreen::context() const
 
 bool QGLOffscreen::isSupported()
 {
-    return (QGLExtensions::glExtensions & QGLExtensions::FramebufferObject); // for fbo
+    return (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject); // for fbo
 }
 
 struct QDrawQueueItem
@@ -1266,7 +1270,7 @@ bool QOpenGLPaintEngine::begin(QPaintDevice *pdev)
         for (int j = 0; j < 4; ++j)
             d->mv_matrix[i][j] = (i == j ? qreal(1) : qreal(0));
 
-    bool has_frag_program = (QGLExtensions::glExtensions & QGLExtensions::FragmentProgram)
+    bool has_frag_program = (QGLExtensions::glExtensions() & QGLExtensions::FragmentProgram)
                             && (pdev->devType() != QInternal::Pixmap);
 
     QGLContext *ctx = const_cast<QGLContext *>(d->device->context());
@@ -1279,11 +1283,27 @@ bool QOpenGLPaintEngine::begin(QPaintDevice *pdev)
         has_frag_program = qt_resolve_frag_program_extensions(ctx) && qt_resolve_version_1_3_functions(ctx);
 
     d->use_stencil_method = d->device->format().stencil()
-                            && (QGLExtensions::glExtensions & QGLExtensions::StencilWrap);
+                            && (QGLExtensions::glExtensions() & QGLExtensions::StencilWrap);
     if (d->device->format().directRendering()
-        && (d->use_stencil_method && QGLExtensions::glExtensions & QGLExtensions::StencilTwoSide))
+        && (d->use_stencil_method && QGLExtensions::glExtensions() & QGLExtensions::StencilTwoSide))
         d->has_stencil_face_ext = qt_resolve_stencil_face_extension(ctx);
 
+#ifdef Q_WS_X11
+    static bool nvidia_workaround_needs_init = true;
+    if (nvidia_workaround_needs_init) {
+        // nvidia 9x.xx unix drivers contain a bug which requires us to
+        // call glFinish before releasing an fbo to avoid painting
+        // artifacts
+        const QByteArray versionString(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
+        const int pos = versionString.indexOf("NVIDIA");
+        if (pos >= 0) {
+            const float nvidiaDriverVersion = versionString.mid(pos + strlen("NVIDIA")).toFloat();
+            qt_nvidiaFboNeedsFinish = nvidiaDriverVersion >= 90.0 && nvidiaDriverVersion < 100.0;
+        }
+        nvidia_workaround_needs_init = false;
+    }
+#endif
+
 #ifndef QT_OPENGL_ES
     if (!ctx->d_ptr->internal_context) {
         glGetDoublev(GL_PROJECTION_MATRIX, &d->projection_matrix[0][0]);
@@ -1333,10 +1353,10 @@ bool QOpenGLPaintEngine::begin(QPaintDevice *pdev)
         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
         glDisableClientState(GL_VERTEX_ARRAY);
 
-        if (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers)
+        if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
             glDisable(GL_MULTISAMPLE);
         glDisable(GL_TEXTURE_2D);
-        if (QGLExtensions::glExtensions & QGLExtensions::TextureRectangle)
+        if (QGLExtensions::glExtensions() & QGLExtensions::TextureRectangle)
             glDisable(GL_TEXTURE_RECTANGLE_NV);
         glDisable(GL_STENCIL_TEST);
         glDisable(GL_CULL_FACE);
@@ -1534,7 +1554,7 @@ void QOpenGLPaintEnginePrivate::updateGradient(const QBrush &brush, const QRectF
 #ifdef QT_OPENGL_ES
     Q_UNUSED(brush);
 #else
-    bool has_mirrored_repeat = QGLExtensions::glExtensions & QGLExtensions::MirroredRepeat;
+    bool has_mirrored_repeat = QGLExtensions::glExtensions() & QGLExtensions::MirroredRepeat;
     Qt::BrushStyle style = brush.style();
 
     QTransform m = brush.transform();
@@ -2098,7 +2118,7 @@ static inline bool needsEmulation(Qt::BrushStyle style)
 {
     return !(style == Qt::SolidPattern
              || (style == Qt::LinearGradientPattern
-                 && (QGLExtensions::glExtensions & QGLExtensions::MirroredRepeat)));
+                 && (QGLExtensions::glExtensions() & QGLExtensions::MirroredRepeat)));
 }
 
 void QOpenGLPaintEnginePrivate::updateUseEmulation()
@@ -2420,12 +2440,12 @@ void QOpenGLPaintEngine::updateRenderHints(QPainter::RenderHints hints)
             d->high_quality_antialiasing = true;
         } else {
             d->high_quality_antialiasing = false;
-            if (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers)
+            if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
                 glEnable(GL_MULTISAMPLE);
         }
     } else {
         d->high_quality_antialiasing = false;
-        if (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers)
+        if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
             glDisable(GL_MULTISAMPLE);
     }
 
@@ -2435,14 +2455,14 @@ void QOpenGLPaintEngine::updateRenderHints(QPainter::RenderHints hints)
         if (!d->offscreen.isValid()) {
             DEBUG_ONCE_STR("Unable to initialize offscreen, disabling high quality antialiasing");
             d->high_quality_antialiasing = false;
-            if (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers)
+            if (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers)
                 glEnable(GL_MULTISAMPLE);
         }
     }
 
     d->has_antialiasing = d->high_quality_antialiasing
                           || ((hints & QPainter::Antialiasing)
-                              && (QGLExtensions::glExtensions & QGLExtensions::SampleBuffers));
+                              && (QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers));
 }
 
 
diff --git a/src/opengl/qwindowsurface_gl.cpp b/src/opengl/qwindowsurface_gl.cpp
index 8ee4361..7a565e6 100644
--- a/src/opengl/qwindowsurface_gl.cpp
+++ b/src/opengl/qwindowsurface_gl.cpp
@@ -295,7 +295,6 @@ QGLWindowSurface::QGLWindowSurface(QWidget *window)
     : QWindowSurface(window), d_ptr(new QGLWindowSurfacePrivate)
 {
     Q_ASSERT(window->isTopLevel());
-    QGLExtensions::init();
     d_ptr->pb = 0;
     d_ptr->fbo = 0;
     d_ptr->ctx = 0;
@@ -520,7 +519,7 @@ void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &
 
     glDisable(GL_SCISSOR_TEST);
 
-    if (d_ptr->fbo && (QGLExtensions::glExtensions & QGLExtensions::FramebufferBlit)) {
+    if (d_ptr->fbo && (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit)) {
         const int h = d_ptr->fbo->height();
 
         const int sx0 = br.left();
@@ -698,7 +697,7 @@ void QGLWindowSurface::updateGeometry() {
     }
 
     if (d_ptr->destructive_swap_buffers
-        && (QGLExtensions::glExtensions & QGLExtensions::FramebufferObject)
+        && (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject)
         && (d_ptr->fbo || !d_ptr->tried_fbo)
         && qt_gl_preferGL2Engine())
     {
@@ -712,7 +711,7 @@ void QGLWindowSurface::updateGeometry() {
         format.setInternalTextureFormat(GLenum(GL_RGBA));
         format.setTextureTarget(target);
 
-        if (QGLExtensions::glExtensions & QGLExtensions::FramebufferBlit)
+        if (QGLExtensions::glExtensions() & QGLExtensions::FramebufferBlit)
             format.setSamples(8);
 
         d_ptr->fbo = new QGLFramebufferObject(rect.size(), format);
diff --git a/src/script/bridge/qscriptqobject.cpp b/src/script/bridge/qscriptqobject.cpp
index fb0dddb..3f4f6bb 100644
--- a/src/script/bridge/qscriptqobject.cpp
+++ b/src/script/bridge/qscriptqobject.cpp
@@ -978,7 +978,8 @@ JSC::JSValue QtFunction::execute(JSC::ExecState *exec, JSC::JSValue thisValue,
     QScriptObjectDelegate *delegate = scriptObject->delegate();
     Q_ASSERT(delegate && (delegate->type() == QScriptObjectDelegate::QtObject));
     QObject *qobj = static_cast<QScript::QObjectDelegate*>(delegate)->value();
-    Q_ASSERT_X(qobj != 0, "QtFunction::call", "handle the case when QObject has been deleted");
+    if (!qobj)
+        return JSC::throwError(exec, JSC::GeneralError, QString::fromLatin1("cannot call function of deleted QObject"));
     QScriptEnginePrivate *engine = scriptEngineFromExec(exec);
 
     const QMetaObject *meta = qobj->metaObject();