Merge commit 'qt/master-stable'

Conflicts:
	config.tests/unix/openssl/openssl.pri
	demos/embedded/embedded.pro
	examples/itemviews/chart/chart.pro
	examples/network/network.pro
	examples/painting/painterpaths/painterpaths.pro
	examples/threads/mandelbrot/mandelbrot.pro
	qmake/project.cpp
	src/3rdparty/libtiff/libtiff/tif_config.h
	src/corelib/arch/arch.pri
	src/corelib/global/qglobal.cpp
	src/corelib/kernel/kernel.pri
	src/corelib/kernel/qcore_unix_p.h
	src/corelib/kernel/qobject.cpp
	src/corelib/thread/qthread_unix.cpp
	src/corelib/tools/qsharedpointer_impl.h
	src/corelib/tools/tools.pri
	src/gui/kernel/qaction.h
	src/gui/kernel/qapplication.cpp
	src/gui/painting/qregion.h
	src/gui/widgets/qlineedit.cpp
	src/gui/widgets/qlineedit_p.h
	src/network/socket/qnativesocketengine_unix.cpp
	tests/auto/qdir/tst_qdir.cpp
	tests/auto/qdiriterator/tst_qdiriterator.cpp
	tests/auto/qhttp/qhttp.pro
	tests/auto/qline/qline.pro
	tests/auto/qnetworkreply/tst_qnetworkreply.cpp
	tests/auto/qresourceengine/qresourceengine.pro
	tests/auto/qsharedpointer/qsharedpointer.pro
	tests/auto/qstring/qstring.pro
	tests/auto/qtcpsocket/qtcpsocket.pro
	tests/auto/qtcpsocket/tst_qtcpsocket.cpp

109 files changed, 5807 insertions, 3316 deletions

diff --git a/src/gui/accessible/accessible.pri b/src/gui/accessible/accessible.pri
index 76b6687..ad2fb4c 100644
--- a/src/gui/accessible/accessible.pri
+++ b/src/gui/accessible/accessible.pri
@@ -14,7 +14,8 @@ contains(QT_CONFIG, accessibility) {
 
       mac:!embedded {
         HEADERS += accessible/qaccessible_mac_p.h
-        OBJECTIVE_SOURCES += accessible/qaccessible_mac.mm
+        OBJECTIVE_SOURCES += accessible/qaccessible_mac.mm \
+                             accessible/qaccessible_mac_cocoa.mm
       } else:win32 { 
         SOURCES += accessible/qaccessible_win.cpp
       } else {
diff --git a/src/gui/accessible/qaccessible_mac_cocoa.mm b/src/gui/accessible/qaccessible_mac_cocoa.mm
index e69de29..1cb2ffa 100644
--- a/src/gui/accessible/qaccessible_mac_cocoa.mm
+++ b/src/gui/accessible/qaccessible_mac_cocoa.mm
@@ -0,0 +1,234 @@
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qaccessible.h"
+#include "qaccessible_mac_p.h"
+#include "qdebug.h"
+#include "qtabwidget.h"
+
+#include <private/qt_mac_p.h>
+#include <private/qcocoaview_mac_p.h>
+#include <private/qwidget_p.h>
+
+
+#ifndef QT_NO_ACCESSIBILITY
+
+#ifdef QT_MAC_USE_COCOA
+
+QT_BEGIN_NAMESPACE
+
+//#define MAC_ACCESSIBILTY_DEVELOPER_MODE
+
+#ifdef MAC_ACCESSIBILTY_DEVELOPER_MODE
+#define MAC_ACCESSIBILTY_DEBUG qDebug
+#else
+#define MAC_ACCESSIBILTY_DEBUG if (0) qDebug
+#endif
+
+typedef QMap<QAccessible::Role, NSString *> QMacAccessibiltyRoleMap;
+Q_GLOBAL_STATIC(QMacAccessibiltyRoleMap, qMacAccessibiltyRoleMap);
+
+static QAInterface interfaceForView(QT_MANGLE_NAMESPACE(QCocoaView) *view)
+{
+    return QAInterface(QAccessible::queryAccessibleInterface([view qt_qwidget]));
+}
+
+/*
+    Set up mappings from Qt accessibilty roles to Mac accessibilty roles.
+*/
+static void populateRoleMap()
+{
+    QMacAccessibiltyRoleMap &roleMap = *qMacAccessibiltyRoleMap();
+    roleMap[QAccessible::MenuItem] = NSAccessibilityMenuItemRole;
+    roleMap[QAccessible::MenuBar] = NSAccessibilityMenuBarRole;
+    roleMap[QAccessible::ScrollBar] = NSAccessibilityScrollBarRole;
+    roleMap[QAccessible::Grip] = NSAccessibilityGrowAreaRole;
+    roleMap[QAccessible::Window] = NSAccessibilityWindowRole;
+    roleMap[QAccessible::Dialog] = NSAccessibilityWindowRole;
+    roleMap[QAccessible::AlertMessage] = NSAccessibilityWindowRole;
+    roleMap[QAccessible::ToolTip] = NSAccessibilityWindowRole;
+    roleMap[QAccessible::HelpBalloon] = NSAccessibilityWindowRole;
+    roleMap[QAccessible::PopupMenu] = NSAccessibilityMenuRole;
+    roleMap[QAccessible::Application] = NSAccessibilityApplicationRole;
+    roleMap[QAccessible::Pane] = NSAccessibilityGroupRole;
+    roleMap[QAccessible::Grouping] = NSAccessibilityGroupRole;
+    roleMap[QAccessible::Separator] = NSAccessibilitySplitterRole;
+    roleMap[QAccessible::ToolBar] = NSAccessibilityToolbarRole;
+    roleMap[QAccessible::PageTab] = NSAccessibilityRadioButtonRole;
+    roleMap[QAccessible::ButtonMenu] = NSAccessibilityMenuButtonRole;
+    roleMap[QAccessible::ButtonDropDown] = NSAccessibilityPopUpButtonRole;
+    roleMap[QAccessible::SpinBox] = NSAccessibilityIncrementorRole;
+    roleMap[QAccessible::Slider] = NSAccessibilitySliderRole;
+    roleMap[QAccessible::ProgressBar] = NSAccessibilityProgressIndicatorRole;
+    roleMap[QAccessible::ComboBox] = NSAccessibilityPopUpButtonRole;
+    roleMap[QAccessible::RadioButton] = NSAccessibilityRadioButtonRole;
+    roleMap[QAccessible::CheckBox] = NSAccessibilityCheckBoxRole;
+    roleMap[QAccessible::StaticText] = NSAccessibilityStaticTextRole;
+    roleMap[QAccessible::Table] = NSAccessibilityTableRole;
+    roleMap[QAccessible::StatusBar] = NSAccessibilityStaticTextRole;
+    roleMap[QAccessible::Column] = NSAccessibilityColumnRole;
+    roleMap[QAccessible::ColumnHeader] = NSAccessibilityColumnRole;
+    roleMap[QAccessible::Row] = NSAccessibilityRowRole;
+    roleMap[QAccessible::RowHeader] = NSAccessibilityRowRole;
+    roleMap[QAccessible::Cell] = NSAccessibilityTextFieldRole;
+    roleMap[QAccessible::PushButton] = NSAccessibilityButtonRole;
+    roleMap[QAccessible::EditableText] = NSAccessibilityTextFieldRole;
+    roleMap[QAccessible::Link] = NSAccessibilityTextFieldRole;
+    roleMap[QAccessible::Indicator] = NSAccessibilityValueIndicatorRole;
+    roleMap[QAccessible::Splitter] = NSAccessibilitySplitGroupRole;
+    roleMap[QAccessible::List] = NSAccessibilityListRole;
+    roleMap[QAccessible::ListItem] = NSAccessibilityStaticTextRole;
+    roleMap[QAccessible::Cell] = NSAccessibilityStaticTextRole;
+}
+
+/*
+    Returns a Mac accessibility role for the given interface, or
+    NSAccessibilityUnknownRole if no role mapping is found.
+*/
+static NSString *macRoleForInterface(QAInterface interface)
+{
+    const QAccessible::Role qtRole = interface.role();
+    QMacAccessibiltyRoleMap &roleMap = *qMacAccessibiltyRoleMap();
+
+    if (roleMap.isEmpty())
+        populateRoleMap();
+
+    MAC_ACCESSIBILTY_DEBUG() << "role for" << interface.object() << "interface role" << hex << qtRole;
+
+    if (roleMap.contains(qtRole)) {
+        MAC_ACCESSIBILTY_DEBUG() << "return" <<  roleMap[qtRole];
+        return roleMap[qtRole];
+    }
+
+    MAC_ACCESSIBILTY_DEBUG() << "return NSAccessibilityUnknownRole";
+    return NSAccessibilityUnknownRole;
+}
+
+/*
+    Is the interface a QTabBar embedded in a QTabWidget?
+    (as opposed to a stand-alone tab bar)
+*/
+static bool isEmbeddedTabBar(const QAInterface &interface)
+{
+    QObject *object = interface.object();
+    if (interface.role() == QAccessible::PageTabList && object)
+        return (qobject_cast<QTabWidget *>(object->parent()));
+
+    return false;
+}
+
+static bool isInterfaceIgnored(QAInterface interface)
+{
+    // Mac accessibility does not have an attribute that corresponds to the 
+    // Invisible/Offscreen state. Use the ignore facility to disable them.
+    const QAccessible::State state = interface.state();
+    if (state & QAccessible::Invisible ||
+        state & QAccessible::Offscreen )
+        return false;
+
+    // Hide QTabBars that has a QTabWidget parent (the QTabWidget handles the accessibility)
+    if (isEmbeddedTabBar(interface))
+        return false;
+
+    if (QObject * const object = interface.object()) {
+        const QString className = QLatin1String(object->metaObject()->className());
+
+        // Prevent VoiceOver from focusing on tool tips by ignoring those
+        // interfaces. Shifting VoiceOver focus to the tool tip is confusing
+        // and the contents of the tool tip is avalible through the description 
+        // attribute anyway.
+        if (className == QLatin1String("QTipLabel"))
+            return false;
+    }
+
+    // Hide interfaces with an unknown role. When developing it's often useful to disable
+    // this check to see all interfaces in the hierarchy.
+#ifndef MAC_ACCESSIBILTY_DEVELOPER_MODE
+    return [macRoleForInterface(interface) isEqualToString: NSAccessibilityUnknownRole];
+#else
+    return NO;
+#endif
+}
+
+QT_END_NAMESPACE
+
+@implementation QT_MANGLE_NAMESPACE(QCocoaView) (Accessibility)
+
+- (BOOL)accessibilityIsIgnored
+{
+    QAInterface interface = interfaceForView(self);
+    return isInterfaceIgnored(interface);
+}
+
+- (NSArray *)accessibilityAttributeNames
+{
+    QAInterface interface = interfaceForView(self);
+
+    static NSArray *attributes = nil;
+    if (attributes == nil) {
+        attributes = [super accessibilityAttributeNames];
+
+    }
+    return attributes;
+}
+
+- (id)accessibilityAttributeValue:(NSString *)attribute
+{
+    MAC_ACCESSIBILTY_DEBUG() << "accessibilityAttributeValue" << self <<  QCFString::toQString(reinterpret_cast<CFStringRef>(attribute));
+
+    QAInterface interface = interfaceForView(self);
+
+    // Switch on the attribute name and call the appropriate handler function.
+    // Pass the call on to the NSView class for attributes we don't handle.
+    if ([attribute isEqualToString:@"AXRole"]) {
+        return macRoleForInterface(interface);
+    } else {
+        return [super accessibilityAttributeValue:attribute];    
+    }
+}
+
+@end
+
+#endif // QT_MAC_USE_COCOA
+
+#endif // QT_NO_ACCESSIBILITY
+
diff --git a/src/gui/dialogs/qcolordialog.cpp b/src/gui/dialogs/qcolordialog.cpp
index 42d3a9a..aee592c 100644
--- a/src/gui/dialogs/qcolordialog.cpp
+++ b/src/gui/dialogs/qcolordialog.cpp
@@ -1583,8 +1583,7 @@ void QColorDialog::setCurrentColor(const QColor &color)
 
 #ifdef Q_WS_MAC
     d->setCurrentQColor(color);
-    if (d->delegate)
-        QColorDialogPrivate::setColor(d->delegate, color);
+    d->setCocoaPanelColor(color);
 #endif
 }
 
@@ -1725,19 +1724,16 @@ void QColorDialog::setVisible(bool visible)
 
 #if defined(Q_WS_MAC)
     if (visible) {
-        if (!d->delegate && QColorDialogPrivate::sharedColorPanelAvailable &&
-                !(testAttribute(Qt::WA_DontShowOnScreen) || (d->opts & DontUseNativeDialog))){
-            d->delegate = QColorDialogPrivate::openCocoaColorPanel(
-                    currentColor(), parentWidget(), windowTitle(), options(), d);
+        if (d->delegate || (QColorDialogPrivate::sharedColorPanelAvailable &&
+                !(testAttribute(Qt::WA_DontShowOnScreen) || (d->opts & DontUseNativeDialog)))){
+            d->openCocoaColorPanel(currentColor(), parentWidget(), windowTitle(), options());
             QColorDialogPrivate::sharedColorPanelAvailable = false;
             setAttribute(Qt::WA_DontShowOnScreen);
         }
         setWindowFlags(windowModality() == Qt::WindowModal ? Qt::Sheet : DefaultWindowFlags);
     } else {
         if (d->delegate) {
-            QColorDialogPrivate::closeCocoaColorPanel(d->delegate);
-            d->delegate = 0;
-            QColorDialogPrivate::sharedColorPanelAvailable = true;
+            d->closeCocoaColorPanel();
             setAttribute(Qt::WA_DontShowOnScreen, false);
         }
     }
@@ -1840,6 +1836,14 @@ QRgb QColorDialog::getRgba(QRgb initial, bool *ok, QWidget *parent)
 
 QColorDialog::~QColorDialog()
 {
+    Q_D(QColorDialog);
+#if defined(Q_WS_MAC)
+    if (d->delegate) {
+        d->releaseCocoaColorPanelDelegate();
+        QColorDialogPrivate::sharedColorPanelAvailable = true;
+    }
+#endif
+
 #ifndef QT_NO_SETTINGS
     if (!customSet) {
         QSettings settings(QSettings::UserScope, QLatin1String("Trolltech"));
diff --git a/src/gui/dialogs/qcolordialog_mac.mm b/src/gui/dialogs/qcolordialog_mac.mm
index 1936de5..6cdb7ee 100644
--- a/src/gui/dialogs/qcolordialog_mac.mm
+++ b/src/gui/dialogs/qcolordialog_mac.mm
@@ -76,6 +76,8 @@ QT_USE_NAMESPACE
     CGFloat mMinWidth;  // currently unused
     CGFloat mExtraHeight;   // currently unused
     BOOL mHackedPanel;
+    NSInteger mResultCode;
+    BOOL mDialogIsExecuting;
 }
 - (id)initWithColorPanel:(NSColorPanel *)panel
        stolenContentView:(NSView *)stolenContentView
@@ -90,7 +92,8 @@ QT_USE_NAMESPACE
 - (NSColorPanel *)colorPanel;
 - (QColor)qtColor;
 - (void)finishOffWithCode:(NSInteger)result;
-- (void)cleanUpAfterMyself;
+- (void)showColorPanel;
+- (void)exec;
 @end
 
 @implementation QCocoaColorPanelDelegate
@@ -110,6 +113,8 @@ QT_USE_NAMESPACE
     mMinWidth = 0.0;
     mExtraHeight = 0.0;
     mHackedPanel = (okButton != 0);
+    mResultCode = NSCancelButton;
+    mDialogIsExecuting = false;
 
     if (mHackedPanel) {
         [self relayout];
@@ -121,19 +126,31 @@ QT_USE_NAMESPACE
         [cancelButton setTarget:self];
     }
 
-    if (mPriv)
-        [[NSNotificationCenter defaultCenter] addObserver:self
-                                              selector:@selector(colorChanged:)
-                                              name:NSColorPanelColorDidChangeNotification
-                                              object:mColorPanel];
+    [[NSNotificationCenter defaultCenter] addObserver:self
+        selector:@selector(colorChanged:)
+        name:NSColorPanelColorDidChangeNotification
+        object:mColorPanel];
+
     mQtColor = new QColor();
     return self;
 }
 
 - (void)dealloc
 {
-    if (mPriv)
-        [[NSNotificationCenter defaultCenter] removeObserver:self];
+    QMacCocoaAutoReleasePool pool;
+    if (mHackedPanel) {
+        NSView *ourContentView = [mColorPanel contentView];
+
+        // return stolen stuff to its rightful owner
+        [mStolenContentView removeFromSuperview];
+        [mColorPanel setContentView:mStolenContentView];
+
+        [mOkButton release];
+        [mCancelButton release];
+        [ourContentView release];
+    }
+    [mColorPanel setDelegate:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
     delete mQtColor;
     [super dealloc];
 }
@@ -160,8 +177,7 @@ QT_USE_NAMESPACE
 - (void)colorChanged:(NSNotification *)notification;
 {
     Q_UNUSED(notification);
-    if (mPriv)
-        [self updateQtColor];
+    [self updateQtColor];
 }
 
 - (void)relayout
@@ -258,8 +274,7 @@ QT_USE_NAMESPACE
         }
     }
 
-    if (mPriv)
-        mPriv->setCurrentQColor(*mQtColor);
+    mPriv->setCurrentQColor(*mQtColor);
 }
 
 - (NSColorPanel *)colorPanel
@@ -274,36 +289,42 @@ QT_USE_NAMESPACE
 
 - (void)finishOffWithCode:(NSInteger)code
 {
-    if (mPriv) {
-        // Finish the QColorDialog as well. But since a call to accept or reject will
-        // close down the QEventLoop found in QDialog, we need to make sure that the
-        // current thread has exited the native dialogs modal session/run loop first.
-        // We ensure this by posting the call:
+    mResultCode = code;
+    if (mDialogIsExecuting) {
+        // We stop the current modal event loop. The control
+        // will then return inside -(void)exec below.
+        // It's important that the modal event loop is stopped before
+        // we accept/reject QColorDialog, since QColorDialog has its
+        // own event loop that needs to be stopped last. 
         [NSApp stopModalWithCode:code];
-        if (code == NSOKButton)
-            QMetaObject::invokeMethod(mPriv->colorDialog(), "accept", Qt::QueuedConnection);
-        else
-            QMetaObject::invokeMethod(mPriv->colorDialog(), "reject", Qt::QueuedConnection);
     } else {
-        [NSApp stopModalWithCode:code];
+        // Since we are not in a modal event loop, we can safely close
+        // down QColorDialog
+        if (mResultCode == NSCancelButton)
+            mPriv->colorDialog()->reject();
+        else
+            mPriv->colorDialog()->accept();
     }
 }
 
-- (void)cleanUpAfterMyself
+- (void)showColorPanel
 {
-    if (mHackedPanel) {
-        NSView *ourContentView = [mColorPanel contentView];
-
-        // return stolen stuff to its rightful owner
-        [mStolenContentView removeFromSuperview];
-        [mColorPanel setContentView:mStolenContentView];
+    mDialogIsExecuting = false;
+    [mColorPanel makeKeyAndOrderFront:mColorPanel];
+}
 
-        [mOkButton release];
-        [mCancelButton release];
-        [ourContentView release];
-    }
-    [mColorPanel setDelegate:nil];
+- (void)exec
+{
+    QBoolBlocker nativeDialogOnTop(QApplicationPrivate::native_modal_dialog_active);
+    QMacCocoaAutoReleasePool pool;
+    mDialogIsExecuting = true;
+    [NSApp runModalForWindow:mColorPanel];
+    if (mResultCode == NSCancelButton)
+        mPriv->colorDialog()->reject();
+    else
+        mPriv->colorDialog()->accept();
 }
+
 @end
 
 QT_BEGIN_NAMESPACE
@@ -312,91 +333,90 @@ extern void macStartInterceptNSPanelCtor();
 extern void macStopInterceptNSPanelCtor();
 extern NSButton *macCreateButton(const char *text, NSView *superview);
 
-void *QColorDialogPrivate::openCocoaColorPanel(const QColor &initial,
-        QWidget *parent, const QString &title, QColorDialog::ColorDialogOptions options,
-        QColorDialogPrivate *priv)
+void QColorDialogPrivate::openCocoaColorPanel(const QColor &initial,
+        QWidget *parent, const QString &title, QColorDialog::ColorDialogOptions options)
 {
     Q_UNUSED(parent);   // we would use the parent if only NSColorPanel could be a sheet
     QMacCocoaAutoReleasePool pool;
 
-    /*
-        The standard Cocoa color panel has no OK or Cancel button and
-        is created as a utility window, whereas we want something like
-        the Carbon color panel. We need to take the following steps:
+    if (!delegate) {
+        /*
+           The standard Cocoa color panel has no OK or Cancel button and
+           is created as a utility window, whereas we want something like
+           the Carbon color panel. We need to take the following steps:
+
+           1. Intercept the color panel constructor to turn off the
+           NSUtilityWindowMask flag. This is done by temporarily
+           replacing initWithContentRect:styleMask:backing:defer:
+           in NSPanel by our own method.
 
-         1. Intercept the color panel constructor to turn off the
-            NSUtilityWindowMask flag. This is done by temporarily
-            replacing initWithContentRect:styleMask:backing:defer:
-            in NSPanel by our own method.
+           2. Modify the color panel so that its content view is part
+           of a new content view that contains it as well as two
+           buttons (OK and Cancel).
 
-         2. Modify the color panel so that its content view is part
-            of a new content view that contains it as well as two
-            buttons (OK and Cancel).
+           3. Lay out the original content view and the buttons when
+           the color panel is shown and whenever it is resized.
 
-         3. Lay out the original content view and the buttons when
-            the color panel is shown and whenever it is resized.
+           4. Clean up after ourselves.
+         */
 
-         4. Clean up after ourselves.
-    */
+        bool hackColorPanel = !(options & QColorDialog::NoButtons);
 
-    bool hackColorPanel = !(options & QColorDialog::NoButtons);
+        if (hackColorPanel)
+            macStartInterceptNSPanelCtor();
+        NSColorPanel *colorPanel = [NSColorPanel sharedColorPanel];
+        if (hackColorPanel)
+            macStopInterceptNSPanelCtor();
 
-    if (hackColorPanel)
-        macStartInterceptNSPanelCtor();
-    NSColorPanel *colorPanel = [NSColorPanel sharedColorPanel];
-    if (hackColorPanel)
-        macStopInterceptNSPanelCtor();
+        [colorPanel setHidesOnDeactivate:false];
 
-    [colorPanel setHidesOnDeactivate:false];
+        // set up the Cocoa color panel
+        [colorPanel setShowsAlpha:options & QColorDialog::ShowAlphaChannel];
+        [colorPanel setTitle:(NSString*)(CFStringRef)QCFString(title)];
 
-    // set up the Cocoa color panel
-    [colorPanel setShowsAlpha:options & QColorDialog::ShowAlphaChannel];
-    [colorPanel setTitle:(NSString*)(CFStringRef)QCFString(title)];
+        NSView *stolenContentView = 0;
+        NSButton *okButton = 0;
+        NSButton *cancelButton = 0;
 
-    NSView *stolenContentView = 0;
-    NSButton *okButton = 0;
-    NSButton *cancelButton = 0;
+        if (hackColorPanel) {
+            // steal the color panel's contents view
+            stolenContentView = [colorPanel contentView];
+            [stolenContentView retain];
+            [colorPanel setContentView:0];
 
-    if (hackColorPanel) {
-        // steal the color panel's contents view
-        stolenContentView = [colorPanel contentView];
-        [stolenContentView retain];
-        [colorPanel setContentView:0];
+            // create a new content view and add the stolen one as a subview
+            NSRect frameRect = { { 0.0, 0.0 }, { 0.0, 0.0 } };
+            NSView *ourContentView = [[NSView alloc] initWithFrame:frameRect];
+            [ourContentView addSubview:stolenContentView];
 
-        // create a new content view and add the stolen one as a subview
-        NSRect frameRect = { { 0.0, 0.0 }, { 0.0, 0.0 } };
-        NSView *ourContentView = [[NSView alloc] initWithFrame:frameRect];
-        [ourContentView addSubview:stolenContentView];
+            // create OK and Cancel buttons and add these as subviews
+            okButton = macCreateButton("&OK", ourContentView);
+            cancelButton = macCreateButton("Cancel", ourContentView);
 
-        // create OK and Cancel buttons and add these as subviews
-        okButton = macCreateButton("&OK", ourContentView);
-        cancelButton = macCreateButton("Cancel", ourContentView);
+            [colorPanel setContentView:ourContentView];
+            [colorPanel setDefaultButtonCell:[okButton cell]];
+        }
 
-        [colorPanel setContentView:ourContentView];
-        [colorPanel setDefaultButtonCell:[okButton cell]];
+        delegate = [[QCocoaColorPanelDelegate alloc] initWithColorPanel:colorPanel
+            stolenContentView:stolenContentView
+            okButton:okButton
+            cancelButton:cancelButton
+            priv:this];
+        [colorPanel setDelegate:static_cast<QCocoaColorPanelDelegate *>(delegate)];
     }
 
-    // create a delegate and set it
-    QCocoaColorPanelDelegate *delegate =
-            [[QCocoaColorPanelDelegate alloc] initWithColorPanel:colorPanel
-                                               stolenContentView:stolenContentView
-                                                        okButton:okButton
-                                                    cancelButton:cancelButton
-                                                            priv:priv];
-    [colorPanel setDelegate:delegate];
-    setColor(delegate, initial);
-    [colorPanel makeKeyAndOrderFront:colorPanel];
-
-    return delegate;
+    setCocoaPanelColor(initial);
+    [static_cast<QCocoaColorPanelDelegate *>(delegate) showColorPanel];
 }
 
-void QColorDialogPrivate::closeCocoaColorPanel(void *delegate)
+void QColorDialogPrivate::closeCocoaColorPanel()
 {
-    QMacCocoaAutoReleasePool pool;
-    QCocoaColorPanelDelegate *theDelegate = static_cast<QCocoaColorPanelDelegate *>(delegate);
-    [[theDelegate colorPanel] close];
-    [theDelegate cleanUpAfterMyself];
-    [theDelegate autorelease];
+    [[static_cast<QCocoaColorPanelDelegate *>(delegate) colorPanel] close];
+}
+
+void QColorDialogPrivate::releaseCocoaColorPanelDelegate()
+{
+    [static_cast<QCocoaColorPanelDelegate *>(delegate) release];
 }
 
 void QColorDialogPrivate::mac_nativeDialogModalHelp()
@@ -416,13 +436,10 @@ void QColorDialogPrivate::mac_nativeDialogModalHelp()
 
 void QColorDialogPrivate::_q_macRunNativeAppModalPanel()
 {
-    QBoolBlocker nativeDialogOnTop(QApplicationPrivate::native_modal_dialog_active);
-    QMacCocoaAutoReleasePool pool;
-    QCocoaColorPanelDelegate *delegateCasted = static_cast<QCocoaColorPanelDelegate *>(delegate);
-    [NSApp runModalForWindow:[delegateCasted colorPanel]];
+    [static_cast<QCocoaColorPanelDelegate *>(delegate) exec];
 }
 
-void QColorDialogPrivate::setColor(void *delegate, const QColor &color)
+void QColorDialogPrivate::setCocoaPanelColor(const QColor &color)
 {
     QMacCocoaAutoReleasePool pool;
     QCocoaColorPanelDelegate *theDelegate = static_cast<QCocoaColorPanelDelegate *>(delegate);
diff --git a/src/gui/dialogs/qcolordialog_p.h b/src/gui/dialogs/qcolordialog_p.h
index ea66d4a..00d40b6 100644
--- a/src/gui/dialogs/qcolordialog_p.h
+++ b/src/gui/dialogs/qcolordialog_p.h
@@ -116,14 +116,11 @@ public:
     QByteArray memberToDisconnectOnClose;
 
 #ifdef Q_WS_MAC
-    static void *openCocoaColorPanel(const QColor &initial,
-            QWidget *parent, const QString &title,
-            QColorDialog::ColorDialogOptions options,
-            QColorDialogPrivate *priv = 0);
-    static void closeCocoaColorPanel(void *delegate);
-    static QColor execCocoaColorPanel(const QColor &initial, QWidget *parent,
-            const QString &title, QColorDialog::ColorDialogOptions options);
-    static void setColor(void *delegate, const QColor &color);
+    void openCocoaColorPanel(const QColor &initial,
+            QWidget *parent, const QString &title, QColorDialog::ColorDialogOptions options);
+    void closeCocoaColorPanel();
+    void releaseCocoaColorPanelDelegate();
+    void setCocoaPanelColor(const QColor &color);
 
     inline void done(int result) { q_func()->done(result); }
     inline QColorDialog *colorDialog() { return q_func(); }
diff --git a/src/gui/dialogs/qfileinfogatherer.cpp b/src/gui/dialogs/qfileinfogatherer.cpp
index 4d9a008..6e1b6af 100644
--- a/src/gui/dialogs/qfileinfogatherer.cpp
+++ b/src/gui/dialogs/qfileinfogatherer.cpp
@@ -44,8 +44,11 @@
 #include <qfsfileengine.h>
 #include <qdiriterator.h>
 #ifndef Q_OS_WIN
-#include <unistd.h>
-#include <sys/types.h>
+#  include <unistd.h>
+#  include <sys/types.h>
+#endif
+#if defined(Q_OS_VXWORKS)
+#  include "qplatformdefs.h"
 #endif
 
 QT_BEGIN_NAMESPACE
diff --git a/src/gui/dialogs/qfilesystemmodel.cpp b/src/gui/dialogs/qfilesystemmodel.cpp
index 283bda6..7492039 100644
--- a/src/gui/dialogs/qfilesystemmodel.cpp
+++ b/src/gui/dialogs/qfilesystemmodel.cpp
@@ -884,6 +884,7 @@ QVariant QFileSystemModel::headerData(int section, Qt::Orientation orientation,
             pixmap.setAlphaChannel(pixmap.createAlphaMask());
             return pixmap;
         }
+        break;
     case Qt::TextAlignmentRole:
         return Qt::AlignLeft;
     }
diff --git a/src/gui/egl/qegl.cpp b/src/gui/egl/qegl.cpp
index 89d9d1b..ebdac9a 100644
--- a/src/gui/egl/qegl.cpp
+++ b/src/gui/egl/qegl.cpp
@@ -400,4 +400,15 @@ void QEglContext::dumpAllConfigs()
     delete [] configs;
 }
 
+QString QEglContext::extensions()
+{
+    const char* exts = eglQueryString(dpy, EGL_EXTENSIONS);
+    return QString(QLatin1String(exts));
+}
+
+bool QEglContext::hasExtension(const char* extensionName)
+{
+    return extensions().contains(QLatin1String(extensionName));
+}
+
 QT_END_NAMESPACE
diff --git a/src/gui/egl/qegl_p.h b/src/gui/egl/qegl_p.h
index b457552..d2be229 100644
--- a/src/gui/egl/qegl_p.h
+++ b/src/gui/egl/qegl_p.h
@@ -122,6 +122,9 @@ public:
 
     void dumpAllConfigs();
 
+    QString extensions();
+    bool hasExtension(const char* extensionName);
+
 private:
     QEgl::API apiType;
     EGLDisplay dpy;
diff --git a/src/gui/egl/qegl_x11.cpp b/src/gui/egl/qegl_x11.cpp
index be89efe..daaa4ba 100644
--- a/src/gui/egl/qegl_x11.cpp
+++ b/src/gui/egl/qegl_x11.cpp
@@ -125,7 +125,17 @@ void QEglProperties::setVisualFormat(const QX11Info *xinfo)
     setValue(EGL_RED_SIZE, countBits(visual->red_mask));
     setValue(EGL_GREEN_SIZE, countBits(visual->green_mask));
     setValue(EGL_BLUE_SIZE, countBits(visual->blue_mask));
-    setValue(EGL_ALPHA_SIZE, 0);    // XXX
+
+    EGLint alphaBits = 0;
+#if !defined(QT_NO_XRENDER)
+    XRenderPictFormat *format;
+    format = XRenderFindVisualFormat(xinfo->display(), visual);
+    if (format && (format->type == PictTypeDirect) && format->direct.alphaMask) {
+        alphaBits = countBits(format->direct.alphaMask);
+        qDebug("QEglProperties::setVisualFormat() - visual's alphaMask is %d", alphaBits);
+    }
+#endif
+    setValue(EGL_ALPHA_SIZE, alphaBits);
 }
 
 extern const QX11Info *qt_x11Info(const QPaintDevice *pd);
diff --git a/src/gui/egl/qeglproperties.cpp b/src/gui/egl/qeglproperties.cpp
index e0ae8a6..358ebcc 100644
--- a/src/gui/egl/qeglproperties.cpp
+++ b/src/gui/egl/qeglproperties.cpp
@@ -46,12 +46,26 @@ QT_BEGIN_NAMESPACE
 #include <QtCore/qdebug.h>
 #include <QtCore/qstringlist.h>
 
+#include "qegl_p.h"
+
+
 // Initialize a property block.
 QEglProperties::QEglProperties()
 {
     props.append(EGL_NONE);
 }
 
+QEglProperties::QEglProperties(EGLConfig cfg)
+{
+    props.append(EGL_NONE);
+    for (int name = 0x3020; name <= 0x304F; ++name) {
+        EGLint value;
+        if (name != EGL_NONE && eglGetConfigAttrib(QEglContext::defaultDisplay(0), cfg, name, &value))
+            setValue(name, value);
+    }
+    eglGetError();  // Clear the error state.
+}
+
 // Fetch the current value associated with a property.
 int QEglProperties::value(int name) const
 {
@@ -215,12 +229,21 @@ bool QEglProperties::reduceConfiguration()
         removeValue(EGL_SAMPLES);
         return true;
     }
-    if (removeValue(EGL_ALPHA_SIZE))
+    if (removeValue(EGL_ALPHA_SIZE)) {
+#if defined(EGL_BIND_TO_TEXTURE_RGBA) && defined(EGL_BIND_TO_TEXTURE_RGB)
+        if (removeValue(EGL_BIND_TO_TEXTURE_RGBA))
+            setValue(EGL_BIND_TO_TEXTURE_RGB, TRUE);
+#endif
         return true;
+    }
     if (removeValue(EGL_STENCIL_SIZE))
         return true;
     if (removeValue(EGL_DEPTH_SIZE))
         return true;
+#if defined(EGL_BIND_TO_TEXTURE_RGB)
+    if (removeValue(EGL_BIND_TO_TEXTURE_RGB))
+        return true;
+#endif
     return false;
 }
 
diff --git a/src/gui/egl/qeglproperties_p.h b/src/gui/egl/qeglproperties_p.h
index 81af4cd..bcdc657 100644
--- a/src/gui/egl/qeglproperties_p.h
+++ b/src/gui/egl/qeglproperties_p.h
@@ -107,6 +107,7 @@ class Q_GUI_EXPORT QEglProperties
 {
 public:
     QEglProperties();
+    QEglProperties(EGLConfig);
     QEglProperties(const QEglProperties& other) : props(other.props) {}
     ~QEglProperties() {}
 
diff --git a/src/gui/embedded/embedded.pri b/src/gui/embedded/embedded.pri
index 53a2512..e8eb959 100644
--- a/src/gui/embedded/embedded.pri
+++ b/src/gui/embedded/embedded.pri
@@ -114,11 +114,18 @@ embedded {
 		SOURCES += embedded/qscreenlinuxfb_qws.cpp
 	}
 
+        contains( gfx-drivers, qnx ) {
+                HEADERS += embedded/qscreenqnx_qws.h
+                SOURCES += embedded/qscreenqnx_qws.cpp
+                LIBS += -lgf
+        }
+
 	contains( gfx-drivers, qvfb ) {
 		HEADERS += embedded/qscreenvfb_qws.h
 		SOURCES += embedded/qscreenvfb_qws.cpp
 	}
 
+
 	contains( gfx-drivers, vnc ) {
 		VNCDIR = $$QT_SOURCE_TREE/src/plugins/gfxdrivers/vnc
 		INCLUDEPATH += $$VNCDIR
@@ -158,6 +165,11 @@ embedded {
 		SOURCES +=embedded/qkbdum_qws.cpp
 	}
 
+        contains( kbd-drivers, qnx ) {
+                HEADERS += embedded/qkbdqnx_qws.h
+                SOURCES += embedded/qkbdqnx_qws.cpp
+        }
+
 #
 # Mouse drivers
 #
@@ -185,5 +197,10 @@ embedded {
 	contains( mouse-drivers, linuxinput ) {
 		HEADERS +=embedded/qmouselinuxinput_qws.h
 		SOURCES +=embedded/qmouselinuxinput_qws.cpp
-	}
+        }
+
+        contains( mouse-drivers, qnx ) {
+                HEADERS += embedded/qmouseqnx_qws.h
+                SOURCES += embedded/qmouseqnx_qws.cpp
+        }
 }
diff --git a/src/gui/embedded/qkbddriverfactory_qws.cpp b/src/gui/embedded/qkbddriverfactory_qws.cpp
index b77eb72..fb10030 100644
--- a/src/gui/embedded/qkbddriverfactory_qws.cpp
+++ b/src/gui/embedded/qkbddriverfactory_qws.cpp
@@ -48,6 +48,7 @@
 #include "qkbdlinuxinput_qws.h"
 #include "qkbdum_qws.h"
 #include "qkbdvfb_qws.h"
+#include "qkbdqnx_qws.h"
 #include <stdlib.h>
 #include "private/qfactoryloader_p.h"
 #include "qkbddriverplugin_qws.h"
@@ -101,6 +102,10 @@ Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
 QWSKeyboardHandler *QKbdDriverFactory::create(const QString& key, const QString& device)
 {
     QString driver = key.toLower();
+#if defined(Q_OS_QNX) && !defined(QT_NO_QWS_KBD_QNX)
+    if (driver == QLatin1String("qnx") || driver.isEmpty())
+        return new QWSQnxKeyboardHandler(device);
+#endif
 #ifndef QT_NO_QWS_KEYBOARD
 # ifndef QT_NO_QWS_KBD_TTY
     if (driver == QLatin1String("tty") || driver.isEmpty())
@@ -143,6 +148,9 @@ QStringList QKbdDriverFactory::keys()
 {
     QStringList list;
 
+#if defined(Q_OS_QNX) && !defined(QT_NO_QWS_KBD_QNX)
+    list << QLatin1String("QNX");
+#endif
 #ifndef QT_NO_QWS_KBD_TTY
     list << QLatin1String("TTY");
 #endif
diff --git a/src/gui/embedded/qkbdqnx_qws.cpp b/src/gui/embedded/qkbdqnx_qws.cpp
new file mode 100644
index 0000000..06163c7
--- /dev/null
+++ b/src/gui/embedded/qkbdqnx_qws.cpp
@@ -0,0 +1,231 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qkbdqnx_qws.h"
+#include "QtCore/qsocketnotifier.h"
+#include "QtCore/qdebug.h"
+
+#include <sys/dcmd_input.h>
+#include <photon/keycodes.h>
+
+#include "qplatformdefs.h"
+#include <errno.h>
+
+/*!
+    \class QWSQnxKeyboardHandler
+    \preliminary
+    \ingroup qws
+    \since 4.6
+    \internal
+
+    \brief The QWSQnxKeyboardHandler class implements a keyboard driver
+    for the QNX \c{devi-hid} input manager.
+
+    To be able to compile this mouse handler, \l{Qt for Embedded Linux}
+    must be configured with the \c -qt-kbd-qnx option, see the
+    \l{Qt for Embedded Linux Character Input} documentation for details.
+
+    In order to use this keyboard handler, the \c{devi-hid} input manager
+    must be set up and run with the resource manager interface (option \c{-r}).
+    Also, Photon must not be running.
+
+    Example invocation from command line: \c{/usr/photon/bin/devi-hid -Pr kbd mouse}
+    Note that after running \c{devi-hid}, you will not be able to use the local
+    shell anymore. It is suggested to run the command in a shell scrip, that launches
+    a Qt application after invocation of \c{devi-hid}.
+
+    To make \l{Qt for Embedded Linux} explicitly choose the qnx keyboard
+    handler, set the QWS_KEYBOARD environment variable to \c{qnx}. By default,
+    the first keyboard device (\c{/dev/devi/keyboard0}) is used. To override, pass a device
+    name as the first and only parameter, for example
+    \c{QWS_KEYBOARD=qnx:/dev/devi/keyboard1; export QWS_KEYBOARD}.
+
+    \sa {Qt for Embedded Linux Character Input}, {Qt for Embedded Linux}
+*/
+
+/*!
+    Constructs a keyboard handler for the specified \a device, defaulting to
+    \c{/dev/devi/keyboard0}.
+
+    Note that you should never instanciate this class, instead let QKbdDriverFactory
+    handle the keyboard handlers.
+
+    \sa QKbdDriverFactory
+ */
+QWSQnxKeyboardHandler::QWSQnxKeyboardHandler(const QString &device)
+{
+    // open the keyboard device
+    keyboardFD = QT_OPEN(device.isEmpty() ? "/dev/devi/keyboard0" : device.toLatin1().constData(),
+                         QT_OPEN_RDONLY);
+    if (keyboardFD == -1) {
+        qErrnoWarning(errno, "QWSQnxKeyboardHandler: Unable to open device");
+        return;
+    }
+
+    // create a socket notifier so we'll wake up whenever keyboard input is detected.
+    QSocketNotifier *notifier = new QSocketNotifier(keyboardFD, QSocketNotifier::Read, this);
+    connect(notifier, SIGNAL(activated(int)), SLOT(socketActivated()));
+
+    qDebug() << "QWSQnxKeyboardHandler: connected.";
+
+}
+
+/*!
+    Destroys this keyboard handler and closes the connection to the keyboard device.
+ */
+QWSQnxKeyboardHandler::~QWSQnxKeyboardHandler()
+{
+    QT_CLOSE(keyboardFD);
+}
+
+/*! \internal
+    Translates the QNX keyboard events to Qt keyboard events
+ */
+void QWSQnxKeyboardHandler::socketActivated()
+{
+    _keyboard_packet packet;
+
+    // read one keyboard event
+    int bytesRead = QT_READ(keyboardFD, &packet, sizeof(_keyboard_packet));
+    if (bytesRead == -1) {
+        qErrnoWarning(errno, "QWSQnxKeyboardHandler::socketActivated(): Unable to read data.");
+        return;
+    }
+
+    // the bytes read must be the size of a keyboard packet
+    Q_ASSERT(bytesRead == sizeof(_keyboard_packet));
+
+#if 0
+    qDebug() << "keyboard got scancode"
+             << hex << packet.data.modifiers
+             << packet.data.flags
+             << packet.data.key_cap
+             << packet.data.key_sym
+             << packet.data.key_scan;
+#endif
+
+    // QNX is nice enough to translate the raw keyboard data into a QNX data structure
+    // Now we just have to translate it into a format Qt understands.
+
+    // figure out whether it's a press
+    bool isPress = packet.data.key_cap & KEY_DOWN;
+    // figure out wheter the key is still pressed and the key event is repeated
+    bool isRepeat = packet.data.key_cap & KEY_REPEAT;
+
+    Qt::Key key = Qt::Key_unknown;
+    int unicode = 0xffff;
+
+    // TODO - this switch is not complete!
+    switch (packet.data.key_scan) {
+    case KEYCODE_SPACE: key = Qt::Key_Space; unicode = 0x20; break;
+    case KEYCODE_F1: key = Qt::Key_F1; break;
+    case KEYCODE_F2: key = Qt::Key_F2; break;
+    case KEYCODE_F3: key = Qt::Key_F3; break;
+    case KEYCODE_F4: key = Qt::Key_F4; break;
+    case KEYCODE_F5: key = Qt::Key_F5; break;
+    case KEYCODE_F6: key = Qt::Key_F6; break;
+    case KEYCODE_F7: key = Qt::Key_F7; break;
+    case KEYCODE_F8: key = Qt::Key_F8; break;
+    case KEYCODE_F9: key = Qt::Key_F9; break;
+    case KEYCODE_F10: key = Qt::Key_F10; break;
+    case KEYCODE_F11: key = Qt::Key_F11; break;
+    case KEYCODE_F12: key = Qt::Key_F12; break;
+    case KEYCODE_BACKSPACE: key = Qt::Key_Backspace; break;
+    case KEYCODE_TAB: key = Qt::Key_Tab; break;
+    case KEYCODE_RETURN: key = Qt::Key_Return; break;
+    case KEYCODE_KP_ENTER: key = Qt::Key_Enter; break;
+    case KEYCODE_UP:
+    case KEYCODE_KP_UP:
+        key = Qt::Key_Up; break;
+    case KEYCODE_DOWN:
+    case KEYCODE_KP_DOWN:
+        key = Qt::Key_Down; break;
+    case KEYCODE_LEFT:
+    case KEYCODE_KP_LEFT:
+        key = Qt::Key_Left; break;
+    case KEYCODE_RIGHT:
+    case KEYCODE_KP_RIGHT:
+        key = Qt::Key_Right; break;
+    case KEYCODE_HOME:
+    case KEYCODE_KP_HOME:
+        key = Qt::Key_Home; break;
+    case KEYCODE_END:
+    case KEYCODE_KP_END:
+        key = Qt::Key_End; break;
+    case KEYCODE_PG_UP:
+    case KEYCODE_KP_PG_UP:
+        key = Qt::Key_PageUp; break;
+    case KEYCODE_PG_DOWN:
+    case KEYCODE_KP_PG_DOWN:
+        key = Qt::Key_PageDown; break;
+    case KEYCODE_INSERT:
+    case KEYCODE_KP_INSERT:
+        key = Qt::Key_Insert; break;
+    case KEYCODE_DELETE:
+    case KEYCODE_KP_DELETE:
+        key = Qt::Key_Delete; break;
+    case KEYCODE_ESCAPE:
+        key = Qt::Key_Escape; break;
+    default: // none of the above, try the key_scan directly
+        unicode = packet.data.key_scan;
+        break;
+    }
+
+    // figure out the modifiers that are currently pressed
+    Qt::KeyboardModifiers modifiers = Qt::NoModifier;
+    if (packet.data.flags & KEYMOD_SHIFT)
+        modifiers |= Qt::ShiftModifier;
+    if (packet.data.flags & KEYMOD_CTRL)
+        modifiers |= Qt::ControlModifier;
+    if (packet.data.flags & KEYMOD_ALT)
+        modifiers |= Qt::AltModifier;
+
+    // if the unicode value is not ascii, we ignore it.
+    // TODO - do a complete mapping between all QNX scan codes and Qt codes
+    if (unicode != 0xffff && !isascii(unicode))
+        return; // unprintable character
+
+    // call processKeyEvent. This is where all the magic happens to insert a
+    // key event into Qt's event loop.
+    // Note that for repeated key events, isPress must be true
+    // (on QNX, isPress is not set when the key event is repeated).
+    processKeyEvent(unicode, key, modifiers, isPress || isRepeat, isRepeat);
+}
diff --git a/src/gui/embedded/qkbdqnx_qws.h b/src/gui/embedded/qkbdqnx_qws.h
new file mode 100644
index 0000000..c046c8d
--- /dev/null
+++ b/src/gui/embedded/qkbdqnx_qws.h
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QKBDQNX_QWS_H
+#define QKBDQNX_QWS_H
+
+#include <QtGui/qapplication.h>
+#include <QtGui/qkbd_qws.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#if !defined(QT_NO_QWS_KEYBOARD) && !defined(QT_NO_QWS_KBD_QNX)
+
+class Q_GUI_EXPORT QWSQnxKeyboardHandler : public QObject, public QWSKeyboardHandler
+{
+    Q_OBJECT
+public:
+    QWSQnxKeyboardHandler(const QString &device);
+    ~QWSQnxKeyboardHandler();
+
+private Q_SLOTS:
+    void socketActivated();
+
+private:
+    int keyboardFD;
+};
+
+#endif // QT_NO_QWS_KEYBOARD
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QKBDQNX_QWS_H
diff --git a/src/gui/embedded/qlock.cpp b/src/gui/embedded/qlock.cpp
index 305832c..9592a4d 100644
--- a/src/gui/embedded/qlock.cpp
+++ b/src/gui/embedded/qlock.cpp
@@ -41,9 +41,46 @@
 
 #include "qlock_p.h"
 
-#ifndef QT_NO_QWS_MULTIPROCESS
+QT_BEGIN_NAMESPACE
+
+#ifdef QT_NO_QWS_MULTIPROCESS
+
+/* no multiprocess - use a dummy */
+
+QLock::QLock(const QString & /*filename*/, char /*id*/, bool /*create*/)
+    : type(Read), data(0)
+{
+}
+
+QLock::~QLock()
+{
+}
+
+bool QLock::isValid() const
+{
+    return true;
+}
+
+void QLock::lock(Type t)
+{
+    data = (QLockData *)-1;
+    type = t;
+}
+
+void QLock::unlock()
+{
+    data = 0;
+}
+
+bool QLock::locked() const
+{
+    return data;
+}
+
+#else // QT_NO_QWS_MULTIPROCESS
 
 #include "qwssignalhandler_p.h"
+
 #include <unistd.h>
 #include <sys/types.h>
 #if defined(Q_OS_DARWIN)
@@ -71,16 +108,10 @@ union semun {
 #include <qdebug.h>
 #include <signal.h>
 
-#endif // QT_NO_QWS_MULTIPROCESS
-
 #include <private/qcore_unix_p.h> // overrides QT_OPEN
 
 #define MAX_LOCKS   200            // maximum simultaneous read locks
 
-QT_BEGIN_NAMESPACE
-
-
-#ifndef QT_NO_QWS_MULTIPROCESS
 class QLockData
 {
 public:
@@ -91,7 +122,6 @@ public:
     int count;
     bool owned;
 };
-#endif // QT_NO_QWS_MULTIPROCESS
 
 /*!
     \class QLock
@@ -126,11 +156,6 @@ public:
 
 QLock::QLock(const QString &filename, char id, bool create)
 {
-#ifdef QT_NO_QWS_MULTIPROCESS
-    Q_UNUSED(filename);
-    Q_UNUSED(id);
-    Q_UNUSED(create);
-#else
     data = new QLockData;
     data->count = 0;
 #ifdef Q_NO_SEMAPHORE
@@ -163,7 +188,6 @@ QLock::QLock(const QString &filename, char id, bool create)
                  qPrintable(filename), id);
         qDebug() << "Error" << eno << strerror(eno);
     }
-#endif
 }
 
 /*!
@@ -174,7 +198,6 @@ QLock::QLock(const QString &filename, char id, bool create)
 
 QLock::~QLock()
 {
-#ifndef QT_NO_QWS_MULTIPROCESS
     if (locked())
         unlock();
 #ifdef Q_NO_SEMAPHORE
@@ -188,7 +211,6 @@ QLock::~QLock()
         QWSSignalHandler::instance()->removeSemaphore(data->id);
 #endif
     delete data;
-#endif
 }
 
 /*!
@@ -200,11 +222,7 @@ QLock::~QLock()
 
 bool QLock::isValid() const
 {
-#ifndef QT_NO_QWS_MULTIPROCESS
     return (data->id != -1);
-#else
-    return true;
-#endif
 }
 
 /*!
@@ -221,9 +239,6 @@ bool QLock::isValid() const
 
 void QLock::lock(Type t)
 {
-#ifdef QT_NO_QWS_MULTIPROCESS
-    Q_UNUSED(t);
-#else
     if (!data->count) {
 #ifdef Q_NO_SEMAPHORE
         int op = LOCK_SH;
@@ -256,7 +271,6 @@ void QLock::lock(Type t)
 #endif
     }
     data->count++;
-#endif
 }
 
 /*!
@@ -269,7 +283,6 @@ void QLock::lock(Type t)
 
 void QLock::unlock()
 {
-#ifndef QT_NO_QWS_MULTIPROCESS
     if(data->count) {
         data->count--;
         if(!data->count) {
@@ -298,7 +311,6 @@ void QLock::unlock()
     } else {
         qDebug("Unlock without corresponding lock");
     }
-#endif
 }
 
 /*!
@@ -310,11 +322,9 @@ void QLock::unlock()
 
 bool QLock::locked() const
 {
-#ifndef QT_NO_QWS_MULTIPROCESS
     return (data->count > 0);
-#else
-    return false;
-#endif
 }
 
+#endif // QT_NO_QWS_MULTIPROCESS
+
 QT_END_NAMESPACE
diff --git a/src/gui/embedded/qmousedriverfactory_qws.cpp b/src/gui/embedded/qmousedriverfactory_qws.cpp
index 46898ae..6d71750 100644
--- a/src/gui/embedded/qmousedriverfactory_qws.cpp
+++ b/src/gui/embedded/qmousedriverfactory_qws.cpp
@@ -47,6 +47,7 @@
 #include "qmouselinuxinput_qws.h"
 #include "qmousevfb_qws.h"
 #include "qmousetslib_qws.h"
+#include "qmouseqnx_qws.h"
 #include <stdlib.h>
 #include "private/qfactoryloader_p.h"
 #include "qmousedriverplugin_qws.h"
@@ -102,6 +103,10 @@ Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
 QWSMouseHandler *QMouseDriverFactory::create(const QString& key, const QString &device)
 {
     QString driver = key.toLower();
+#if defined(Q_OS_QNX) && !defined(QT_NO_QWS_MOUSE_QNX)
+    if (driver == QLatin1String("qnx") || driver.isEmpty())
+        return new QQnxMouseHandler(key, device);
+#endif
 #ifndef QT_NO_QWS_MOUSE_LINUXTP
     if (driver == QLatin1String("linuxtp") || driver.isEmpty())
         return new QWSLinuxTPMouseHandler(key, device);
@@ -149,6 +154,9 @@ QStringList QMouseDriverFactory::keys()
 {
     QStringList list;
 
+#if defined(Q_OS_QNX) && !defined(QT_NO_QWS_MOUSE_QNX)
+    list << QLatin1String("QNX");
+#endif
 #ifndef QT_NO_QWS_MOUSE_LINUXTP
     list << QLatin1String("LinuxTP");
 #endif
diff --git a/src/gui/embedded/qmousepc_qws.cpp b/src/gui/embedded/qmousepc_qws.cpp
index 317bb8a..2d62772 100644
--- a/src/gui/embedded/qmousepc_qws.cpp
+++ b/src/gui/embedded/qmousepc_qws.cpp
@@ -332,7 +332,7 @@ protected:
         tty.c_oflag     = 0;
         tty.c_lflag     = 0;
         tty.c_cflag     = f | CREAD | CLOCAL | HUPCL;
-#if !defined(Q_OS_DARWIN) && !defined(Q_OS_SOLARIS) && !defined(Q_OS_INTEGRITY)
+#ifdef Q_OS_LINUX
         tty.c_line      = 0;
 #endif
         tty.c_cc[VTIME] = 0;
diff --git a/src/gui/embedded/qmouseqnx_qws.cpp b/src/gui/embedded/qmouseqnx_qws.cpp
new file mode 100644
index 0000000..98f8f06
--- /dev/null
+++ b/src/gui/embedded/qmouseqnx_qws.cpp
@@ -0,0 +1,190 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+#include "qmouseqnx_qws.h"
+
+#include "qsocketnotifier.h"
+#include "qdebug.h"
+
+#include <sys/dcmd_input.h>
+
+#include <errno.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QQnxMouseHandler
+    \preliminary
+    \ingroup qws
+    \internal
+    \since 4.6
+
+    \brief The QQnxMouseHandler class implements a mouse driver
+    for the QNX \c{devi-hid} input manager.
+
+    To be able to compile this mouse handler, \l{Qt for Embedded Linux}
+    must be configured with the \c -qt-mouse-qnx option, see the
+    \l{Qt for Embedded Linux Pointer Handling}{Pointer Handling} documentation for details.
+
+    In order to use this mouse handler, the \c{devi-hid} input manager
+    must be set up and run with the resource manager interface (option \c{-r}).
+    Also, Photon must not be running.
+
+    Example invocation from command line: \c{/usr/photon/bin/devi-hid -Pr kbd mouse}
+    Note that after running \c{devi-hid}, you will not be able to use the local
+    shell anymore. It is suggested to run the command in a shell scrip, that launches
+    a Qt application after invocation of \c{devi-hid}.
+
+    To make \l{Qt for Embedded Linux} explicitly choose the qnx mouse
+    handler, set the QWS_MOUSE_PROTO environment variable to \c{qnx}. By default,
+    the first mouse device (\c{/dev/devi/mouse0}) is used. To override, pass a device
+    name as the first and only parameter, for example
+    \c{QWS_MOUSE_PROTO=qnx:/dev/devi/mouse1; export QWS_MOUSE_PROTO}.
+
+    \sa {Qt for Embedded Linux Pointer Handling}{Pointer Handling}, {Qt for Embedded Linux}
+*/
+
+/*!
+    Constructs a mouse handler for the specified \a device, defaulting to \c{/dev/devi/mouse0}.
+    The \a driver parameter must be \c{"qnx"}.
+
+    Note that you should never instanciate this class, instead let QMouseDriverFactory
+    handle the mouse handlers.
+
+    \sa QMouseDriverFactory
+ */
+QQnxMouseHandler::QQnxMouseHandler(const QString & /*driver*/, const QString &device)
+{
+    // open the mouse device with O_NONBLOCK so reading won't block when there's no data
+    mouseFD = QT_OPEN(device.isEmpty() ? "/dev/devi/mouse0" : device.toLatin1().constData(),
+                          QT_OPEN_RDONLY | O_NONBLOCK);
+    if (mouseFD == -1) {
+        qErrnoWarning(errno, "QQnxMouseHandler: Unable to open mouse device");
+        return;
+    }
+
+    // register a socket notifier on the file descriptor so we'll wake up whenever
+    // there's a mouse move waiting for us.
+    mouseNotifier = new QSocketNotifier(mouseFD, QSocketNotifier::Read, this);
+    connect(mouseNotifier, SIGNAL(activated(int)), SLOT(socketActivated()));
+
+    qDebug() << "QQnxMouseHandler: connected.";
+}
+
+/*!
+    Destroys this mouse handler and closes the connection to the mouse device.
+ */
+QQnxMouseHandler::~QQnxMouseHandler()
+{
+    QT_CLOSE(mouseFD);
+}
+
+/*! \reimp */
+void QQnxMouseHandler::resume()
+{
+    if (mouseNotifier)
+        mouseNotifier->setEnabled(true);
+}
+
+/*! \reimp */
+void QQnxMouseHandler::suspend()
+{
+    if (mouseNotifier)
+        mouseNotifier->setEnabled(false);
+}
+
+/*! \internal
+
+  This function is called whenever there is activity on the mouse device.
+  By default, it reads up to 10 mouse move packets and calls mouseChanged()
+  for each of them.
+*/
+void QQnxMouseHandler::socketActivated()
+{
+    // _mouse_packet is a QNX structure. devi-hid is nice enough to translate
+    // the raw byte data from mouse devices into generic format for us.
+    _mouse_packet packet;
+
+    int iteration = 0;
+
+    // read mouse events in batches of 10. Since we're getting quite a lot
+    // of mouse events, it's better to do them in batches than to return to the
+    // event loop every time.
+    do {
+        int bytesRead = QT_READ(mouseFD, &packet, sizeof(packet));
+        if (bytesRead == -1) {
+            // EAGAIN means that there are no more mouse events to read
+            if (errno != EAGAIN)
+                qErrnoWarning(errno, "QQnxMouseHandler: Unable to read from socket");
+            return;
+        }
+
+        // bytes read should always be equal to the size of a packet.
+        Q_ASSERT(bytesRead == sizeof(packet));
+
+        // translate the coordinates from the QNX data structure to Qt coordinates
+        // note the swapped y axis
+        QPoint pos = mousePos;
+        pos += QPoint(packet.dx, -packet.dy);
+
+        // QNX only tells us relative mouse movements, not absolute ones, so limit the
+        // cursor position manually to the screen
+        limitToScreen(pos);
+
+        // translate the QNX mouse button bitmask to Qt buttons
+        int buttons = Qt::NoButton;
+
+        if (packet.hdr.buttons & _POINTER_BUTTON_LEFT)
+            buttons |= Qt::LeftButton;
+        if (packet.hdr.buttons & _POINTER_BUTTON_MIDDLE)
+            buttons |= Qt::MidButton;
+        if (packet.hdr.buttons & _POINTER_BUTTON_RIGHT)
+            buttons |= Qt::RightButton;
+
+        // call mouseChanged() - this does all the magic to actually move the on-screen
+        // mouse cursor.
+        mouseChanged(pos, buttons, 0);
+    } while (++iteration < 11);
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/gui/embedded/qmouseqnx_qws.h b/src/gui/embedded/qmouseqnx_qws.h
new file mode 100644
index 0000000..a61562e
--- /dev/null
+++ b/src/gui/embedded/qmouseqnx_qws.h
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMOUSE_QNX_H
+#define QMOUSE_QNX_H
+
+#include <QtCore/qobject.h>
+#include <QtGui/qmouse_qws.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QSocketNotifier;
+
+class Q_GUI_EXPORT QQnxMouseHandler : public QObject, public QWSMouseHandler
+{
+    Q_OBJECT
+public:
+    explicit QQnxMouseHandler(const QString &driver = QString(),
+                              const QString &device = QString());
+    ~QQnxMouseHandler();
+
+    void resume();
+    void suspend();
+
+private Q_SLOTS:
+    void socketActivated();
+
+private:
+    QSocketNotifier *mouseNotifier;
+    int mouseFD;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QMOUSE_QWS_H
diff --git a/src/gui/embedded/qscreendriverfactory_qws.cpp b/src/gui/embedded/qscreendriverfactory_qws.cpp
index 2290627..b531798 100644
--- a/src/gui/embedded/qscreendriverfactory_qws.cpp
+++ b/src/gui/embedded/qscreendriverfactory_qws.cpp
@@ -47,6 +47,7 @@
 #include "qscreentransformed_qws.h"
 #include "qscreenvfb_qws.h"
 #include "qscreenmulti_qws_p.h"
+#include "qscreenqnx_qws.h"
 #include <stdlib.h>
 #include "private/qfactoryloader_p.h"
 #include "qscreendriverplugin_qws.h"
@@ -105,6 +106,10 @@ Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
 QScreen *QScreenDriverFactory::create(const QString& key, int displayId)
 {
     QString driver = key.toLower();
+#if defined(Q_OS_QNX) && !defined(QT_NO_QWS_QNX)
+    if (driver == QLatin1String("qnx") || driver.isEmpty())
+        return new QQnxScreen(displayId);
+#endif
 #ifndef QT_NO_QWS_QVFB
     if (driver == QLatin1String("qvfb") || driver.isEmpty())
         return new QVFbScreen(displayId);
@@ -146,6 +151,9 @@ QStringList QScreenDriverFactory::keys()
 {
     QStringList list;
 
+#if defined(Q_OS_QNX) && !defined(QT_NO_QWS_QNX)
+    list << QLatin1String("QNX");
+#endif
 #ifndef QT_NO_QWS_QVFB
     list << QLatin1String("QVFb");
 #endif
diff --git a/src/gui/embedded/qscreenqnx_qws.cpp b/src/gui/embedded/qscreenqnx_qws.cpp
new file mode 100644
index 0000000..7101bc7
--- /dev/null
+++ b/src/gui/embedded/qscreenqnx_qws.cpp
@@ -0,0 +1,447 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qscreenqnx_qws.h"
+#include "qdebug.h"
+
+#include <gf/gf.h>
+
+// This struct holds all the pointers to QNX's internals
+struct QQnxScreenContext
+{
+    inline QQnxScreenContext()
+        : device(0), display(0), layer(0), hwSurface(0), memSurface(0), context(0)
+    {}
+
+    gf_dev_t device;
+    gf_dev_info_t deviceInfo;
+    gf_display_t display;
+    gf_display_info_t displayInfo;
+    gf_layer_t layer;
+    gf_surface_t hwSurface;
+    gf_surface_t memSurface;
+    gf_surface_info_t memSurfaceInfo;
+    gf_context_t context;
+};
+
+/*!
+    \class QQnxScreen
+    \preliminary
+    \ingroup qws
+    \since 4.6
+    \internal
+
+    \brief The QQnxScreen class implements a screen driver
+    for QNX io-display based devices.
+
+    Note - you never have to instanciate this class, the QScreenDriverFactory
+    does that for us based on the \c{QWS_DISPLAY} environment variable.
+
+    To activate this driver, set \c{QWS_DISPLAY} to \c{qnx}.
+
+    Example:
+    \c{QWS_DISPLAY=qnx; export QWS_DISPLAY}
+
+    By default, the main layer of the first display of the first device is used.
+    If you have multiple graphic cards, multiple displays or multiple layers and
+    don't want to connect to the default, you can override that with setting
+    the corresponding options \c{device}, \c{display} or \c{layer} in the \c{QWS_DISPLAY} variable:
+
+    \c{QWS_DISPLAY=qnx:device=3:display=4:layer=5}
+
+    In addition, it is suggested to set the physical width and height of the display.
+    QQnxScreen will use that information to compute the dots per inch (DPI) in order to render
+    fonts correctly. If this informaiton is omitted, QQnxScreen defaults to 72 dpi.
+
+    \c{QWS_DISPLAY=qnx:mmWidth=120:mmHeight=80}
+
+    \c{mmWidth} and \c{mmHeight} are the physical width/height of the screen in millimeters.
+
+    \sa QScreen, QScreenDriverPlugin, {Running Qt for Embedded Linux Applications}{Running Applications}
+*/
+
+/*!
+    Constructs a QQnxScreen object. The \a display_id argument
+    identifies the Qt for Embedded Linux server to connect to.
+*/
+QQnxScreen::QQnxScreen(int display_id)
+    : QScreen(display_id), d(new QQnxScreenContext)
+{
+}
+
+/*!
+    Destroys this QQnxScreen object.
+*/
+QQnxScreen::~QQnxScreen()
+{
+    delete d;
+}
+
+/*! \reimp
+*/
+bool QQnxScreen::initDevice()
+{
+    // implement this if you have multiple processes that want to access the display
+    // (not required if QT_NO_QWS_MULTIPROCESS is set)
+    return true;
+}
+
+/*! \internal
+  Attaches to the named device \a name.
+*/
+static bool attachDevice(QQnxScreenContext * const d, const char *name)
+{
+    int ret = gf_dev_attach(&d->device, name, &d->deviceInfo);
+    if (ret != GF_ERR_OK) {
+        qWarning("QQnxScreen: gf_dev_attach(%s) failed with error code %d", name, ret);
+        return false;
+    }
+    return true;
+}
+
+/*! \internal
+  Attaches to the display at index \a displayIndex.
+ */
+static bool attachDisplay(QQnxScreenContext * const d, int displayIndex)
+{
+    int ret = gf_display_attach(&d->display, d->device, displayIndex, &d->displayInfo);
+    if (ret != GF_ERR_OK) {
+        qWarning("QQnxScreen: gf_display_attach(%d) failed with error code %d",
+                displayIndex, ret);
+        return false;
+    }
+    return true;
+}
+
+/*! \internal
+  Attaches to the layer \a layerIndex.
+ */
+static bool attachLayer(QQnxScreenContext * const d, int layerIndex)
+{
+    int ret = gf_layer_attach(&d->layer, d->display, layerIndex, 0);
+    if (ret != GF_ERR_OK) {
+        qWarning("QQnxScreen: gf_layer_attach(%d) failed with error code %d", layerIndex,
+                ret);
+        return false;
+    }
+    gf_layer_enable(d->layer);
+
+    return true;
+}
+
+/*! \internal
+  Creates a new hardware surface (usually on the Gfx card memory) with the dimensions \a w * \a h.
+ */
+static bool createHwSurface(QQnxScreenContext * const d, int w, int h)
+{
+    int ret = gf_surface_create_layer(&d->hwSurface, &d->layer, 1, 0,
+                w, h, GF_FORMAT_ARGB8888, 0, 0);
+    if (ret != GF_ERR_OK) {
+        qWarning("QQnxScreen: gf_surface_create_layer(%dx%d) failed with error code %d",
+                w, h, ret);
+        return false;
+    }
+
+    gf_layer_set_surfaces(d->layer, &d->hwSurface, 1);
+
+    ret = gf_layer_update(d->layer, 0);
+    if (ret != GF_ERR_OK) {
+        qWarning("QQnxScreen: gf_layer_update() failed with error code %d\n", ret);
+        return false;
+    }
+
+    return true;
+}
+
+/*! \internal
+  Creates an in-memory, linear accessible surface of dimensions \a w * \a h.
+  This is the main surface that QWS blits to.
+ */
+static bool createMemSurface(QQnxScreenContext * const d, int w, int h)
+{
+    // Note: gf_surface_attach() could also be used, so we'll create the buffer
+    // and let the surface point to it. Here, we use surface_create instead.
+
+    int ret = gf_surface_create(&d->memSurface, d->device, w, h,
+                GF_FORMAT_ARGB8888, 0,
+                GF_SURFACE_CREATE_CPU_FAST_ACCESS | GF_SURFACE_CREATE_CPU_LINEAR_ACCESSIBLE
+                | GF_SURFACE_PHYS_CONTIG);
+    if (ret != GF_ERR_OK) {
+        qWarning("QQnxScreen: gf_surface_create(%dx%d) failed with error code %d",
+                w, h, ret);
+        return false;
+    }
+
+    gf_surface_get_info(d->memSurface, &d->memSurfaceInfo);
+
+    if (d->memSurfaceInfo.sid == unsigned(GF_SID_INVALID)) {
+        qWarning("QQnxScreen: gf_surface_get_info() failed.");
+        return false;
+    }
+
+    return true;
+}
+
+/* \internal
+   Creates a QNX gf context and sets our memory surface on it.
+ */
+static bool createContext(QQnxScreenContext * const d)
+{
+    int ret = gf_context_create(&d->context);
+    if (ret != GF_ERR_OK) {
+        qWarning("QQnxScreen: gf_context_create() failed with error code %d", ret);
+        return false;
+    }
+
+    ret = gf_context_set_surface(d->context, d->memSurface);
+    if (ret != GF_ERR_OK) {
+        qWarning("QQnxScreen: gf_context_set_surface() failed with error code %d", ret);
+        return false;
+    }
+
+    return true;
+}
+
+/*! \reimp
+  Connects to QNX's io-display based device based on the \a displaySpec parameters
+  from the \c{QWS_DISPLAY} environment variable. See the QQnxScreen class documentation
+  for possible parameters.
+
+  \sa QQnxScreen
+ */
+bool QQnxScreen::connect(const QString &displaySpec)
+{
+    const QStringList params = displaySpec.split(QLatin1Char(':'), QString::SkipEmptyParts);
+
+    bool isOk = false;
+    QRegExp deviceRegExp(QLatin1String("^device=(.+)$"));
+    if (params.indexOf(deviceRegExp) != -1) {
+        isOk = attachDevice(d, deviceRegExp.cap(1).toLocal8Bit().constData());
+    } else {
+        // no device specified - attach to device 0 (the default)
+        isOk = attachDevice(d, GF_DEVICE_INDEX(0));
+    }
+
+    if (!isOk)
+        return false;
+
+    qDebug("QQnxScreen: Attached to Device, number of displays: %d", d->deviceInfo.ndisplays);
+
+    // default to display 0
+    int displayIndex = 0;
+    QRegExp displayRegexp(QLatin1String("^display=(\\d+)$"));
+    if (params.indexOf(displayRegexp) != -1) {
+        displayIndex = displayRegexp.cap(1).toInt();
+    }
+
+    if (!attachDisplay(d, displayIndex))
+        return false;
+
+    qDebug("QQnxScreen: Attached to Display %d, resolution %dx%d, refresh %d Hz",
+            displayIndex, d->displayInfo.xres, d->displayInfo.yres,
+            d->displayInfo.refresh);
+
+
+    // default to main_layer_index from the displayInfo struct
+    int layerIndex = 0;
+    QRegExp layerRegexp(QLatin1String("^layer=(\\d+)$"));
+    if (params.indexOf(layerRegexp) != -1) {
+        layerIndex = layerRegexp.cap(1).toInt();
+    } else {
+        layerIndex = d->displayInfo.main_layer_index;
+    }
+
+    if (!attachLayer(d, layerIndex))
+        return false;
+
+    // tell QWSDisplay the width and height of the display
+    w = dw = d->displayInfo.xres;
+    h = dh = d->displayInfo.yres;
+
+    // we only support 32 bit displays for now.
+    QScreen::d = 32;
+
+    // assume 72 dpi as default, to calculate the physical dimensions if not specified
+    const int defaultDpi = 72;
+
+    // Handle display physical size spec.
+    QRegExp mmWidthRegexp(QLatin1String("^mmWidth=(\\d+)$"));
+    if (params.indexOf(mmWidthRegexp) == -1) {
+        physWidth = qRound(dw * 25.4 / defaultDpi);
+    } else {
+        physWidth = mmWidthRegexp.cap(1).toInt();
+    }
+
+    QRegExp mmHeightRegexp(QLatin1String("^mmHeight=(\\d+)$"));
+    if (params.indexOf(mmHeightRegexp) == -1) {
+        physHeight = qRound(dh * 25.4 / defaultDpi);
+    } else {
+        physHeight = mmHeightRegexp.cap(1).toInt();
+    }
+
+    // create a hardware surface with our dimensions. In the old days, it was possible
+    // to get a pointer directly to the hw surface, so we could blit directly. Now, we
+    // have to use one indirection more, because it's not guaranteed that the hw surface
+    // is mappable into our process.
+    if (!createHwSurface(d, w, h))
+        return false;
+
+    // create an in-memory linear surface that is used by QWS. QWS will blit directly in here.
+    if (!createMemSurface(d, w, h))
+        return false;
+
+    // set the address of the in-memory buffer that QWS is blitting to
+    data = d->memSurfaceInfo.vaddr;
+    // set the line stepping
+    lstep = d->memSurfaceInfo.stride;
+
+    // the overall size of the in-memory buffer is linestep * height
+    size = mapsize = lstep * h;
+
+    // create a QNX drawing context
+    if (!createContext(d))
+        return false;
+
+    // we're always using a software cursor for now. Initialize it here.
+    QScreenCursor::initSoftwareCursor();
+
+    // done, the driver should be connected to the display now.
+    return true;
+}
+
+/*! \reimp
+ */
+void QQnxScreen::disconnect()
+{
+    if (d->context)
+        gf_context_free(d->context);
+
+    if (d->memSurface)
+        gf_surface_free(d->memSurface);
+
+    if (d->hwSurface)
+        gf_surface_free(d->hwSurface);
+
+    if (d->layer)
+        gf_layer_detach(d->layer);
+
+    if (d->display)
+        gf_display_detach(d->display);
+
+    if (d->device)
+        gf_dev_detach(d->device);
+
+    d->memSurface = 0;
+    d->hwSurface = 0;
+    d->context = 0;
+    d->layer = 0;
+    d->display = 0;
+    d->device = 0;
+}
+
+/*! \reimp
+ */
+void QQnxScreen::shutdownDevice()
+{
+}
+
+
+/*! \reimp
+  QQnxScreen doesn't support setting the mode, use io-display instead.
+ */
+void QQnxScreen::setMode(int,int,int)
+{
+    qWarning("QQnxScreen: Unable to change mode, use io-display instead.");
+}
+
+/*! \reimp
+ */
+bool QQnxScreen::supportsDepth(int depth) const
+{
+    // only 32-bit for the moment
+    return depth == 32;
+}
+
+/*! \reimp
+ */
+void QQnxScreen::exposeRegion(QRegion r, int changing)
+{
+    // here is where the actual magic happens. QWS will call exposeRegion whenever
+    // a region on the screen is dirty and needs to be updated on the actual screen.
+
+    // first, call the parent implementation. The parent implementation will update
+    // the region on our in-memory surface
+    QScreen::exposeRegion(r, changing);
+
+    // now our in-memory surface should be up to date with the latest changes.
+    // the code below copies the region from the in-memory surface to the hardware.
+
+    // just get the bounding rectangle of the region. Most screen updates are rectangular
+    // anyways. Code could be optimized to blit each and every member of the region
+    // individually, but in real life, the speed-up is neglectable
+    const QRect br = r.boundingRect();
+    if (br.isEmpty())
+        return; // ignore empty regions because gf_draw_blit2 doesn't like 0x0 dimensions
+
+    // start drawing.
+    int ret = gf_draw_begin(d->context);
+    if (ret != GF_ERR_OK) {
+        qWarning("QQnxScreen: gf_draw_begin() failed with error code %d", ret);
+        return;
+    }
+
+    // blit the changed region from the memory surface to the hardware surface
+    ret = gf_draw_blit2(d->context, d->memSurface, d->hwSurface,
+            br.x(), br.y(), br.right(), br.bottom(), br.x(), br.y());
+    if (ret != GF_ERR_OK) {
+        qWarning("QQnxScreen: gf_draw_blit2() failed with error code %d", ret);
+    }
+
+    // flush all drawing commands (in our case, a single blit)
+    ret = gf_draw_flush(d->context);
+    if (ret != GF_ERR_OK) {
+        qWarning("QQnxScreen: gf_draw_flush() failed with error code %d", ret);
+    }
+
+    // tell QNX that we're done drawing.
+    gf_draw_end(d->context);
+}
+
diff --git a/src/gui/embedded/qscreenqnx_qws.h b/src/gui/embedded/qscreenqnx_qws.h
new file mode 100644
index 0000000..837c061
--- /dev/null
+++ b/src/gui/embedded/qscreenqnx_qws.h
@@ -0,0 +1,82 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSCREENQNX_QWS_H
+#define QSCREENQNX_QWS_H
+
+#include <QtGui/qscreen_qws.h>
+
+#ifndef QT_NO_QWS_QNX
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+struct QQnxScreenContext;
+
+class QQnxScreen : public QScreen
+{
+public:
+    explicit QQnxScreen(int display_id);
+    ~QQnxScreen();
+
+    bool initDevice();
+    bool connect(const QString &displaySpec);
+    void disconnect();
+    void shutdownDevice();
+    void setMode(int,int,int);
+    bool supportsDepth(int) const;
+
+    void exposeRegion(QRegion r, int changing);
+
+private:
+    QQnxScreenContext * const d;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_NO_QWS_QNX
+
+#endif
diff --git a/src/gui/embedded/qwindowsystem_qws.cpp b/src/gui/embedded/qwindowsystem_qws.cpp
index a521319..9545051 100644
--- a/src/gui/embedded/qwindowsystem_qws.cpp
+++ b/src/gui/embedded/qwindowsystem_qws.cpp
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "qplatformdefs.h"
+
 #include "qwindowsystem_qws.h"
 #include "qwsevent_qws.h"
 #include "qwscommand_qws_p.h"
@@ -71,24 +73,26 @@
 
 #include <qdebug.h>
 
-#include <unistd.h>
+#include "qkbddriverfactory_qws.h"
+#include "qmousedriverfactory_qws.h"
+
+#include <qbuffer.h>
+#include <qdir.h>
+
+#include <private/qwindowsurface_qws_p.h>
+#include <private/qfontengine_qpf_p.h>
+
+#include "qwindowsystem_p.h"
+
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <errno.h>
 
 #ifndef QT_NO_QWS_MULTIPROCESS
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ipc.h>
-#include <sys/shm.h>
-#ifndef Q_OS_DARWIN
-# include <sys/sem.h>
-#endif
 #include <sys/param.h>
 #include <sys/mount.h>
 #endif
-#include <signal.h>
-#include <fcntl.h>
 
 #if !defined(QT_NO_SOUND) && !defined(Q_OS_DARWIN)
 #ifdef QT_USE_OLD_QWS_SOUND
@@ -101,17 +105,6 @@
 #endif
 #endif
 
-#include "qkbddriverfactory_qws.h"
-#include "qmousedriverfactory_qws.h"
-
-#include <qbuffer.h>
-#include <qdir.h>
-
-#include <private/qwindowsurface_qws_p.h>
-#include <private/qfontengine_qpf_p.h>
-
-#include "qwindowsystem_p.h"
-
 //#define QWS_DEBUG_FONTCLEANUP
 
 QT_BEGIN_NAMESPACE
@@ -1406,7 +1399,7 @@ void QWSServerPrivate::initServer(int flags)
 #ifndef QT_NO_QWS_MULTIPROCESS
 
     if (!geteuid()) {
-#if !defined(Q_OS_FREEBSD) && !defined(Q_OS_SOLARIS) && !defined(Q_OS_DARWIN) && !defined(QT_LINUXBASE)
+#if defined(Q_OS_LINUX) && !defined(QT_LINUXBASE)
         if(mount(0,"/var/shm", "shm", 0, 0)) {
             /* This just confuses people with 2.2 kernels
             if (errno != EBUSY)
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index db00fbd..7e73863 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -135,38 +135,39 @@
 
     \section1 Transformation
 
-    QGraphicsItem supports affine transformations in addition to its base
-    position, pos(). To change the item's transformation, you can pass
-    a transformation matrix to setTransform()
-
-    Item transformations accumulate from parent to child, so if both a
-    parent and child item are rotated 90 degrees, the child's total
-    transformation will be 180 degrees.  Similarly, if the item's
-    parent is scaled to 2x its original size, its children will also
-    be twice as large. An item's transformation does not affect its
-    own local geometry; all geometry functions (e.g., contains(),
-    update(), and all the mapping functions) still operate in local
-    coordinates. For convenience, QGraphicsItem provides the functions
-    sceneTransform(), which returns the item's total transformation
+    QGraphicsItem supports projective transformations in addition to its base
+    position, pos(). There are several ways to change an item's transformation.
+    For simple transformations, you can call either of the convenience
+    functions setRotation() or setScale(), or you can pass any transformation
+    matrix to setTransform(). For advanced transformation control you also have
+    the option of setting several combined transformations by calling
+    setTransformations().
+
+    Item transformations accumulate from parent to child, so if both a parent
+    and child item are rotated 90 degrees, the child's total transformation
+    will be 180 degrees. Similarly, if the item's parent is scaled to 2x its
+    original size, its children will also be twice as large. An item's
+    transformation does not affect its own local geometry; all geometry
+    functions (e.g., contains(), update(), and all the mapping functions) still
+    operate in local coordinates. For convenience, QGraphicsItem provides the
+    functions sceneTransform(), which returns the item's total transformation
     matrix (including its position and all parents' positions and
-    transformations), and scenePos(), which returns its position in
-    scene coordinates. To reset an item's matrix, call
-    resetTransform().
+    transformations), and scenePos(), which returns its position in scene
+    coordinates. To reset an item's matrix, call resetTransform().
 
-    Another way to apply transformation to an item is to use the , or
-    set the different transformation properties (transformOrigin,
-    x/y/zRotation, x/yScale, horizontal/verticalShear).  Those
-    properties come in addition to the base transformation
+    Certain transformation operations produce a different outcome depending on
+    the order in which they are applied. For example, if you scale an
+    transform, and then rotate it, you may get a different result than if the
+    transform was rotated first. However, the order you set the transformation
+    properties on QGraphicsItem does not affect the resulting transformation;
+    QGraphicsItem always applies the properties in a fixed, defined order:
 
-    The order you set the transformation properties does not affect
-    the resulting transformation The resulting transformation is
-    always computed in the following order
-
-    \code
-    [Origin] [Base] [RotateX] [RotateY] [RotateZ] [Shear] [Scale] [-Origin]
-    \endcode
-
-    Where [Base] is the stransformation set by setTransform
+    \list
+    \o The item's base transform is applied (transform())
+    \o The item's transformations list is applied in order (transformations())
+    \o The item is rotated relative to its transform origin point (rotation(), transformOriginPoint())
+    \o The item is scaled relative to its transform origin point (scale(), transformOriginPoint())
+    \endlist
 
     \section1 Painting
 
@@ -2969,11 +2970,10 @@ QMatrix QGraphicsItem::matrix() const
 
     Returns this item's transformation matrix.
 
-    Either the one set by setTransform, or the resulting transformation from
-    all the transfmation properties
-
-    If no matrix or transformation property has been set, the
-    identity matrix is returned. 
+    The transformation matrix is combined with the item's rotation(), scale()
+    and transformations() into a combined transformations for the item.
+    
+    The default transformation matrix is an identity matrix.
 
     \sa setTransform(), sceneTransform()
 */
@@ -2987,13 +2987,13 @@ QTransform QGraphicsItem::transform() const
 /*!
     \since 4.6
 
-    Returns the rotation around the Z axis.
+    Returns the clockwise rotation, in degrees, around the Z axis. The default
+    value is 0 (i.e., the item is not rotated).
 
-    The default is 0
+    The rotation is combined with the item's scale(), transform() and
+    transformations() to map the item's coordinate system to the parent item.
 
-    \warning The value doesn't take in account any rotation set with the setTransform() method.
-
-    \sa setRotation(), {Transformations}
+    \sa setRotation(), transformOriginPoint(), {Transformations}
 */
 qreal QGraphicsItem::rotation() const
 {
@@ -3005,9 +3005,19 @@ qreal QGraphicsItem::rotation() const
 /*!
     \since 4.6
 
-    Sets the rotation around the Z axis to \a angle degrees.
+    Sets the clockwise rotation \a angle, in degrees, around the Z axis. The
+    default value is 0 (i.e., the item is not rotated). Assigning a negative
+    value will rotate the item counter-clockwise. Normally the rotation angle
+    is in the range (-360, 360), but it's also possible to assign values
+    outside of this range (e.g., a rotation of 370 degrees is the same as a
+    rotation of 10 degrees).
+
+    The item is rotated around its transform origin point, which by default
+    is (0, 0). You can select a different transformation origin by calling
+    setTransformOriginPoint().
 
-    \warning The value doesn't take in account any rotation set with the setTransform() method.
+    The rotation is combined with the item's scale(), transform() and
+    transformations() to map the item's coordinate system to the parent item.
 
     \sa rotation(), setTransformOriginPoint(), {Transformations}
 */
@@ -3027,13 +3037,13 @@ void QGraphicsItem::setRotation(qreal angle)
 /*!
     \since 4.6
 
-    Returns the scale factor of the item.
+    Returns the scale factor of the item. The default scale factor is 1.0
+    (i.e., the item is not scaled).
 
-    The default is 1
+    The scale is combined with the item's rotation(), transform() and
+    transformations() to map the item's coordinate system to the parent item.
 
-    \warning The value doesn't take in account any scaling set with the setTransform() method.
-
-    \sa setScale(), {Transformations}
+    \sa setScale(), rotation(), {Transformations}
 */
 qreal QGraphicsItem::scale() const
 {
@@ -3045,9 +3055,17 @@ qreal QGraphicsItem::scale() const
 /*!
     \since 4.6
 
-    Sets the scale factor of the item to \a factor.
+    Sets the scale \a factor of the item. The default scale factor is 1.0
+    (i.e., the item is not scaled). A scale factor of 0.0 will collapse the
+    item to a single point. If you provide a negative scale factor, the
+    item will be flipped and mirrored (i.e., rotated 180 degrees).
+
+    The item is scaled around its transform origin point, which by default
+    is (0, 0). You can select a different transformation origin by calling
+    setTransformOriginPoint().
 
-    \warning The value doesn't take in account any scaling set with the setTransform() method.
+    The scale is combined with the item's rotation(), transform() and
+    transformations() to map the item's coordinate system to the parent item.
 
     \sa scale(), setTransformOriginPoint(), {Transformations}
 */
@@ -3068,9 +3086,17 @@ void QGraphicsItem::setScale(qreal factor)
 /*!
     \since 4.6
 
-    returns list of graphics transformations on the item.
+    Returns a list of graphics transforms that currently apply to this item.
 
-    \sa scale(), setTransformOriginPoint(), {Transformations}
+    QGraphicsTransform is for applying and controlling a chain of individual
+    transformation operations on an item. It's particularily useful in
+    animations, where each transform operation needs to be interpolated
+    independently, or differently.
+
+    The transformations are combined with the item's rotation(), scale() and
+    transform() to map the item's coordinate system to the parent item.
+
+    \sa scale(), rotation(), transformOriginPoint(), {Transformations}
 */
 QList<QGraphicsTransform *> QGraphicsItem::transformations() const
 {
@@ -3082,7 +3108,20 @@ QList<QGraphicsTransform *> QGraphicsItem::transformations() const
 /*!
     \since 4.6
 
-    Sets a list of graphics transformations on the item to \a transformations.
+    Sets a list of graphics \a transformations (QGraphicsTransform) that
+    currently apply to this item.
+
+    If all you want is to rotate or scale an item, you should call setRotation()
+    or setScale() instead. If you want to set an arbitrary transformation on
+    an item, you can call setTransform().
+
+    QGraphicsTransform is for applying and controlling a chain of individual
+    transformation operations on an item. It's particularily useful in
+    animations, where each transform operation needs to be interpolated
+    independently, or differently.
+
+    The transformations are combined with the item's rotation(), scale() and
+    transform() to map the item's coordinate system to the parent item.
 
     \sa scale(), setTransformOriginPoint(), {Transformations}
 */
@@ -3098,7 +3137,9 @@ void QGraphicsItem::setTransformations(const QList<QGraphicsTransform *> &transf
     d_ptr->dirtySceneTransform = 1;
 }
 
-
+/*!
+    \internal
+*/
 void QGraphicsItemPrivate::appendGraphicsTransform(QGraphicsTransform *t)
 {
     if (!transformData)
@@ -3432,7 +3473,9 @@ void QGraphicsItem::setMatrix(const QMatrix &matrix, bool combine)
     to map an item coordiate to a scene coordinate, or mapFromScene() to map
     from scene coordinates to item coordinates.
 
-    \warning using this function doesnt affect the value of the transformation properties
+    The transformation matrix is combined with the item's rotation(), scale()
+    and transformations() into a combined transformation that maps the item's
+    coordinate system to its parent.
 
     \sa transform(), setRotation(), setScale(), setTransformOriginPoint(), {The Graphics View Coordinate System}, {Transformations}
 */
@@ -3491,7 +3534,14 @@ void QGraphicsItem::resetTransform()
 
 /*!
     \obsolete
-    Use setZRotation() instead
+
+    Use
+
+    \code
+    setRotation(rotation() + angle);
+    \endcode
+
+    instead.
 
     Rotates the current item transformation \a angle degrees clockwise around
     its origin. To translate around an arbitrary point (x, y), you need to
@@ -3501,8 +3551,6 @@ void QGraphicsItem::resetTransform()
 
     \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsitem.cpp 6
 
-    \warning using this functionhas no effect on the zRotation value
-
     \sa setTransform(), transform(), scale(), shear(), translate()
 */
 void QGraphicsItem::rotate(qreal angle)
@@ -3512,7 +3560,14 @@ void QGraphicsItem::rotate(qreal angle)
 
 /*!
     \obsolete
-    Use setScale() instead
+
+    Use
+
+    \code
+    setTransform(QTransform::fromScale(sx, sy), true);
+    \endcode
+
+    instead.
 
     Scales the current item transformation by (\a sx, \a sy) around its
     origin. To scale from an arbitrary point (x, y), you need to combine
@@ -3522,8 +3577,6 @@ void QGraphicsItem::rotate(qreal angle)
 
     \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsitem.cpp 7
 
-    \warning using this function has no effect on the xScale or yScale value
-
     \sa setTransform(), transform()
 */
 void QGraphicsItem::scale(qreal sx, qreal sy)
@@ -3533,11 +3586,16 @@ void QGraphicsItem::scale(qreal sx, qreal sy)
 
 /*!
     \obsolete
-    Use setShear instead.
 
-    Shears the current item transformation by (\a sh, \a sv).
+    Use 
+
+    \code
+    setTransform(QTransform().shear(sh, sv), true);
+    \endcode
+
+    instead.
 
-    \warning using this function has no effect on the horizontalShear or verticalShear value
+    Shears the current item transformation by (\a sh, \a sv).
 
     \sa setTransform(), transform()
 */
@@ -3548,7 +3606,13 @@ void QGraphicsItem::shear(qreal sh, qreal sv)
 
 /*!
     \obsolete
-    Use setPos() or setTransformOriginPoint() instead.
+
+    Use setPos() or setTransformOriginPoint() instead. For identical
+    behavior, use
+    
+    \code
+    setTransform(QTransform::fromTranslate(dx, dy), true);
+    \endcode
 
     Translates the current item transformation by (\a dx, \a dy).
 
@@ -6462,7 +6526,7 @@ void QGraphicsItem::prepareGeometryChange()
         // if someone is connected to the changed signal or the scene has no views.
         // Note that this has to be done *after* markDirty to ensure that
         // _q_processDirtyItems is called before _q_emitUpdated.
-        if ((scenePrivate->connectedSignals & scenePrivate->changedSignalMask)
+	if ((scenePrivate->connectedSignals[0] & scenePrivate->changedSignalMask)
             || scenePrivate->views.isEmpty()) {
             if (d_ptr->hasTranslateOnlySceneTransform()) {
                 d_ptr->scene->update(boundingRect().translated(d_ptr->sceneTransform.dx(),
@@ -6747,6 +6811,16 @@ QGraphicsObject::QGraphicsObject(QGraphicsItemPrivate &dd, QGraphicsItem *parent
 */
 
 /*!
+  \fn const QObjectList &QGraphicsObject::children() const
+  \internal
+
+  This function returns the same value as QObject::children(). It's
+  provided to differentiate between the obsolete member
+  QGraphicsItem::children() and QObject::children(). QGraphicsItem now
+  provides childItems() instead.
+*/
+
+/*!
   \property QGraphicsObject::transformOriginPoint
   \brief the transformation origin
 
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index aa2cf40..ba01b52 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -468,7 +468,8 @@ public:
     QGraphicsItem *q_ptr;
 };
 
-struct QGraphicsItemPrivate::TransformData {
+struct QGraphicsItemPrivate::TransformData
+{
     QTransform transform;
     qreal scale;
     qreal rotation;
@@ -481,7 +482,7 @@ struct QGraphicsItemPrivate::TransformData {
         scale(1.0), rotation(0.0),
         xOrigin(0.0), yOrigin(0.0),
         onlyTransform(true)
-    {}
+    { }
 
     QTransform computedFullTransform(QTransform *postmultiplyTransform = 0) const
     {
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index e6727af..9b9c9c2 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -344,7 +344,7 @@ void QGraphicsScenePrivate::_q_emitUpdated()
     // the optimization that items send updates directly to the views, but it
     // needs to happen in order to keep compatibility with the behavior from
     // Qt 4.4 and backward.
-    if (connectedSignals & changedSignalMask) {
+    if (connectedSignals[0] & changedSignalMask) {
         for (int i = 0; i < views.size(); ++i) {
             QGraphicsView *view = views.at(i);
             if (!view->d_func()->connectedToScene) {
@@ -2899,7 +2899,7 @@ void QGraphicsScene::update(const QRectF &rect)
 
     // Check if anyone's connected; if not, we can send updates directly to
     // the views. Otherwise or if there are no views, use old behavior.
-    bool directUpdates = !(d->connectedSignals & d->changedSignalMask) && !d->views.isEmpty();
+    bool directUpdates = !(d->connectedSignals[0] & d->changedSignalMask) && !d->views.isEmpty();
     if (rect.isNull()) {
         d->updateAll = true;
         d->updatedRects.clear();
@@ -4477,7 +4477,7 @@ void QGraphicsScenePrivate::markDirty(QGraphicsItem *item, const QRectF &rect, b
     if (removingItemFromScene) {
         // Note that this function can be called from the item's destructor, so
         // do NOT call any virtual functions on it within this block.
-        if ((connectedSignals & changedSignalMask) || views.isEmpty()) {
+        if ((connectedSignals[0] & changedSignalMask) || views.isEmpty()) {
             // This block of code is kept for compatibility. Since 4.5, by default
             // QGraphicsView does not connect the signal and we use the below
             // method of delivering updates.
@@ -4623,7 +4623,7 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool
 
     // Process item.
     if (item->d_ptr->dirty || item->d_ptr->paintedViewBoundingRectsNeedRepaint) {
-        const bool useCompatUpdate = views.isEmpty() || (connectedSignals & changedSignalMask);
+        const bool useCompatUpdate = views.isEmpty() || (connectedSignals[0] & changedSignalMask);
         const QRectF itemBoundingRect = adjustedItemBoundingRect(item);
 
         if (useCompatUpdate && !itemIsUntransformable && qFuzzyIsNull(item->boundingRegionGranularity())) {
diff --git a/src/gui/graphicsview/qgraphicsscenebsptreeindex.cpp b/src/gui/graphicsview/qgraphicsscenebsptreeindex.cpp
index 40043e7..e5f03b3 100644
--- a/src/gui/graphicsview/qgraphicsscenebsptreeindex.cpp
+++ b/src/gui/graphicsview/qgraphicsscenebsptreeindex.cpp
@@ -525,7 +525,7 @@ QGraphicsSceneBspTreeIndex::~QGraphicsSceneBspTreeIndex()
 }
 
 /*!
-    \reimp
+    \internal
     Clear the all the BSP index.
 */
 void QGraphicsSceneBspTreeIndex::clear()
@@ -566,7 +566,7 @@ void QGraphicsSceneBspTreeIndex::removeItem(QGraphicsItem *item)
 }
 
 /*!
-    \reimp
+    \internal
     Update the BSP when the \a item 's bounding rect has changed.
 */
 void QGraphicsSceneBspTreeIndex::prepareBoundingRectChange(const QGraphicsItem *item)
@@ -682,7 +682,7 @@ void QGraphicsSceneBspTreeIndex::setBspTreeDepth(int depth)
 }
 
 /*!
-    \reimp
+    \internal
 
     This method react to the  \a rect change of the scene and
     reset the BSP tree index.
@@ -695,11 +695,10 @@ void QGraphicsSceneBspTreeIndex::updateSceneRect(const QRectF &rect)
 }
 
 /*!
-    \reimp
+    \internal
 
     This method react to the \a change of the \a item and use the \a value to
     update the BSP tree if necessary.
-
 */
 void QGraphicsSceneBspTreeIndex::itemChange(const QGraphicsItem *item, QGraphicsItem::GraphicsItemChange change, const QVariant &value)
 {
diff --git a/src/gui/graphicsview/qgraphicstransform.cpp b/src/gui/graphicsview/qgraphicstransform.cpp
index a71d5cc..69b6002 100644
--- a/src/gui/graphicsview/qgraphicstransform.cpp
+++ b/src/gui/graphicsview/qgraphicstransform.cpp
@@ -39,6 +39,43 @@
 **
 ****************************************************************************/
 
+/*!
+    \class QGraphicsTransform
+    \brief The QGraphicsTransform class is an abstract base class for building
+    advanced transformations on QGraphicsItems.
+    \since 4.6
+
+    As an alternative to QGraphicsItem::transform, QGraphicsTransform lets you
+    create and control advanced transformations that can be configured
+    independently using specialized properties.
+
+    QGraphicsItem allows you to assign any number of QGraphicsTransform
+    instances to one QGraphicsItem. Each QGraphicsTransform is applied in
+    order, one at a time, to the QGraphicsItem it's assigned to.
+
+    QGraphicsTransform is particularily useful for animations. Whereas
+    QGraphicsItem::setTransform() lets you assign any transform directly to an
+    item, there is no direct way to interpolate between two different
+    transformations (e.g., when transitioning between two states, each for
+    which the item has a different arbitrary transform assigned). Using
+    QGraphicsTransform you can interpolate the property values of each
+    independent transformation. The resulting operation is then combined into a
+    single transform which is applied to QGraphicsItem.
+
+    If you want to create your own configurable transformation, you can create
+    a subclass of QGraphicsTransform (or any or the existing subclasses), and
+    reimplement the pure virtual applyTo() function, which takes a pointer to a
+    QTransform. Each operation you would like to apply should be exposed as
+    properties (e.g., customTransform->setVerticalShear(2.5)). Inside you
+    reimplementation of applyTo(), you can modify the provided transform
+    respectively.
+
+    QGraphicsTransform can be used together with QGraphicsItem::setTransform(),
+    QGraphicsItem::setRotation(), and QGraphicsItem::setScale().
+
+    \sa QGraphicsItem::transform(), QGraphicsScale, QGraphicsRotation, QGraphicsRotation3D
+*/
+
 #include "qgraphicstransform.h"
 #include "qgraphicsitem_p.h"
 #include "qgraphicstransform_p.h"
@@ -51,7 +88,6 @@
 
 QT_BEGIN_NAMESPACE
 
-
 void QGraphicsTransformPrivate::setItem(QGraphicsItem *i)
 {
     if (item == i)
@@ -77,15 +113,38 @@ void QGraphicsTransformPrivate::updateItem(QGraphicsItem *item)
     item->d_ptr->dirtySceneTransform = 1;
 }
 
-void QGraphicsTransform::update()
+/*!
+    Constructs a new QGraphicsTransform with the given \a parent.
+*/
+QGraphicsTransform::QGraphicsTransform(QObject *parent)
+    : QObject(*new QGraphicsTransformPrivate, parent)
+{
+}
+
+/*!
+    Destroys the graphics transform.
+*/
+QGraphicsTransform::~QGraphicsTransform()
 {
     Q_D(QGraphicsTransform);
-    if (d->item)
-        d->updateItem(d->item);
+    d->setItem(0);
+}
+
+/*!
+    \internal
+*/
+QGraphicsTransform::QGraphicsTransform(QGraphicsTransformPrivate &p, QObject *parent)
+    : QObject(p, parent)
+{
 }
 
 /*!
-  returns this object as a QTransform.
+    Applies this transformation to an identity transform, and returns the
+    resulting transform.
+
+    This is equivalent to passing an identity transform to applyTo().
+
+    \sa applyTo()
 */
 QTransform QGraphicsTransform::transform() const
 {
@@ -95,76 +154,65 @@ QTransform QGraphicsTransform::transform() const
 }
 
 /*!
-  \class QGraphicsTransform
-  \brief The QGraphicsTransform class is an abstract base class for tranformations on QGraphicsItems.
-  \since 4.6
-
-  The classes that inherit QGraphicsTransform express different types of transformations
-  that can be applied to graphics items.
+    \fn void QGraphicsTransform::applyTo(QTransform *transform) const
 
-  A list of these transformations can be applied to any graphics item. These
-  transformations are then easily modifyable and usable from e.g. within animations.
+    This pure virtual method has to be reimplemented in derived classes.
 
-  QGraphicsTransform is an abstract base class that is implemented by QGraphicsScale,
-  QGraphicsRotation and QGraphicsRotation3D. Subclasses have to implement the applyTo method.
+    It applies this transformation to \a transform.
 
-  \sa QGraphicsItem::transform(), QGraphicsScale, QGraphicsRotation, QGraphicsRotation3D
+    \sa QGraphicsItem::transform()
 */
 
 /*!
-  Constructs a new QGraphicsTransform with \a parent.
-*/
-QGraphicsTransform::QGraphicsTransform(QObject *parent) :
-    QObject(*new QGraphicsTransformPrivate, parent)
-{
-}
+    Notifies that this transform operation has changed its parameters in such a
+    way that applyTo() will return a different result than before.
 
-/*!
-  Destructs the graphics transform.
+    When implementing you own custom graphics transform, you must call this
+    function every time you change a parameter, to let QGraphicsItem know that
+    its transformation needs to be updated.
+
+    \sa applyTo()
 */
-QGraphicsTransform::~QGraphicsTransform()
+void QGraphicsTransform::update()
 {
     Q_D(QGraphicsTransform);
-    d->setItem(0);
+    if (d->item)
+        d->updateItem(d->item);
 }
 
 /*!
-  \internal
-*/
-QGraphicsTransform::QGraphicsTransform(QGraphicsTransformPrivate &p, QObject *parent)
-    : QObject(p, parent)
-{
-}
-
-/*! \fn void QGraphicsTransform::applyTo(QTransform *transform) const
+  \class QGraphicsScale
+  \brief The QGraphicsScale class provides a scale transformation.
+  \since 4.6
 
-  This pure virtual method has to be reimplemented in derived classes.
+  QGraphicsScene provides certain parameters to help control how the scale
+  should be applied.
 
-  It applies this transformation to \a transform.
-*/
+  The origin is the point that the item is scaled from (i.e., it stays fixed
+  relative to the parent as the rest of the item grows). By default the
+  origin is QPointF(0, 0).
 
+  The two parameters xScale and yScale describe the scale factors to apply in
+  horizontal and vertical direction. They can take on any value, including 0
+  (to collapse the item to a point) or negativate value. A negative xScale
+  value will mirror the item horizontally. A negative yScale value will flip
+  the item vertically.
 
-/*!
-  \class QGraphicsScale
-  \brief The QGraphicsScale class provides a way to scale a graphics item in 2 dimensions.
-  \since 4.6
-
-  QGraphicsScale contains an \a origin around which the scaling happens, and two
-  scale factors, xScale and yScale, the x and one for the y axis.
+  \sa QGraphicsTransform, QGraphicsItem::setScale(), QTransform::scale()
 */
 
 class QGraphicsScalePrivate : public QGraphicsTransformPrivate
 {
 public:
     QGraphicsScalePrivate()
-            : xScale(1), yScale(1) {}
+        : xScale(1), yScale(1) {}
     QPointF origin;
     qreal xScale;
     qreal yScale;
 };
 
 /*!
-  Constructs a new graphics scale object with \a parent.
+    Constructs an empty QGraphicsScale object with the given \a parent.
 */
 QGraphicsScale::QGraphicsScale(QObject *parent)
     : QGraphicsTransform(*new QGraphicsScalePrivate, parent)
@@ -172,24 +220,26 @@ QGraphicsScale::QGraphicsScale(QObject *parent)
 }
 
 /*!
-  Destroys the object
+    Destroys the graphics scale.
 */
 QGraphicsScale::~QGraphicsScale()
 {
 }
 
 /*!
-  \property QGraphicsScale::origin
-  The origin of the scale. All scaling will be done relative to this point.
+    \property QGraphicsScale::origin
+    \brief The QGraphicsScene class provides the origin of the scale.
+
+    All scaling will be done relative to this point (i.e., this point
+    will stay fixed, relative to the parent, when the item is scaled).
 
-  The \a origin is in other words the fixed point for the transformation.
+    \sa xScale, yScale
 */
 QPointF QGraphicsScale::origin() const
 {
     Q_D(const QGraphicsScale);
     return d->origin;
 }
-
 void QGraphicsScale::setOrigin(const QPointF &point)
 {
     Q_D(QGraphicsScale);
@@ -199,26 +249,21 @@ void QGraphicsScale::setOrigin(const QPointF &point)
 }
 
 /*!
-  \fn QGraphicsScale::originChanged()
-
-  This signal is emitted whenever the origin of the object
-  changes.
-*/
-
-/*!
-  \property QGraphicsScale::xScale
+    \property QGraphicsScale::xScale
+    \brief the horizontal scale factor.
 
-  The scale factor in x direction. The x direction is
-  in the graphics items logical coordinates.
+    The scale factor can be any real number; the default value is 1.0. If you
+    set the factor to 0.0, the item will be collapsed to a single point. If you
+    provide a negative value, the item will be mirrored horizontally around its
+    origin.
 
-  \sa yScale
+    \sa yScale, origin
 */
 qreal QGraphicsScale::xScale() const
 {
     Q_D(const QGraphicsScale);
     return d->xScale;
 }
-
 void QGraphicsScale::setXScale(qreal scale)
 {
     Q_D(QGraphicsScale);
@@ -230,19 +275,21 @@ void QGraphicsScale::setXScale(qreal scale)
 }
 
 /*!
-  \property QGraphicsScale::yScale
+    \property QGraphicsScale::yScale
+    \brief the vertical scale factor.
 
-  The scale factor in y direction. The y direction is
-  in the graphics items logical coordinates.
+    The scale factor can be any real number; the default value is 1.0. If you
+    set the factor to 0.0, the item will be collapsed to a single point. If you
+    provide a negative value, the item will be flipped vertically around its
+    origin.
 
-  \sa xScale
+    \sa xScale, origin
 */
 qreal QGraphicsScale::yScale() const
 {
     Q_D(const QGraphicsScale);
     return d->yScale;
 }
-
 void QGraphicsScale::setYScale(qreal scale)
 {
     Q_D(QGraphicsScale);
@@ -254,14 +301,7 @@ void QGraphicsScale::setYScale(qreal scale)
 }
 
 /*!
-  \fn QGraphicsScale::scaleChanged()
-
-  This signal is emitted whenever the xScale or yScale of the object
-  changes.
-*/
-
-/*!
-  \reimp
+    \reimp
 */
 void QGraphicsScale::applyTo(QTransform *transform) const
 {
@@ -272,12 +312,41 @@ void QGraphicsScale::applyTo(QTransform *transform) const
 }
 
 /*!
-  \class QGraphicsRotation
-  \brief The QGraphicsRotation class provides a way to rotate a graphics item in 2 dimensions.
-  \since 4.6
+    \fn QGraphicsScale::originChanged()
+
+    QGraphicsScale emits this signal when its origin changes.
+
+    \sa QGraphicsScale::origin
+*/
+
+/*!
+    \fn QGraphicsScale::scaleChanged()
+
+    This signal is emitted whenever the xScale or yScale of the object
+    changes.
 
-  QGraphicsRotation contains an \a origin around which the rotation happens, and one
-  angle in degrees describing the amount of the rotation.
+    \sa QGraphicsScale::xScale, QGraphicsScale::yScale
+*/
+
+/*!
+    \class QGraphicsRotation
+    \brief The QGraphicsRotation class provides a rotation transformation.
+    \since 4.6
+
+    QGraphicsRotation provides certain parameters to help control how the
+    rotation should be applied.
+
+    The origin is the point that the item is rotated around (i.e., it stays
+    fixed relative to the parent as the rest of the item is rotated). By
+    default the origin is QPointF(0, 0).
+
+    The angle property provides the number of degrees to rotate the item
+    clockwise around the origin. This value also be negative, indicating a
+    counter-clockwise rotation. For animation purposes it may also be useful to
+    provide rotation angles exceeding (-360, 360) degrees, for instance to
+    animate how an item rotates several times.
+
+    \sa QGraphicsTransform, QGraphicsItem::setRotation(), QTransform::rotate()
 */
 
 class QGraphicsRotationPrivate : public QGraphicsTransformPrivate
@@ -291,7 +360,7 @@ public:
 };
 
 /*!
-  Constructs a new graphics rotation with \a parent.
+    Constructs a new QGraphicsRotation with the given \a parent.
 */
 QGraphicsRotation::QGraphicsRotation(QObject *parent)
     : QGraphicsTransform(*new QGraphicsRotationPrivate, parent)
@@ -299,7 +368,7 @@ QGraphicsRotation::QGraphicsRotation(QObject *parent)
 }
 
 /*!
-  \internal
+    \internal
 */
 QGraphicsRotation::QGraphicsRotation(QGraphicsRotationPrivate &p, QObject *parent)
     : QGraphicsTransform(p, parent)
@@ -307,24 +376,26 @@ QGraphicsRotation::QGraphicsRotation(QGraphicsRotationPrivate &p, QObject *paren
 }
 
 /*!
-  Destructs the object
+    Destroys the graphics rotation.
 */
 QGraphicsRotation::~QGraphicsRotation()
 {
 }
 
 /*!
-  \property QGraphicsRotation::origin
-  The origin around which this object will rotate the graphics item.
+    \property QGraphicsRotation::origin
+    \brief the origin of the rotation.
 
-  The \a origin is in other words the fixed point for the transformation.
+    All rotations will be done relative to this point (i.e., this point
+    will stay fixed, relative to the parent, when the item is rotated).
+
+    \sa angle
 */
 QPointF QGraphicsRotation::origin() const
 {
     Q_D(const QGraphicsRotation);
     return d->origin;
 }
-
 void QGraphicsRotation::setOrigin(const QPointF &point)
 {
     Q_D(QGraphicsRotation);
@@ -334,22 +405,22 @@ void QGraphicsRotation::setOrigin(const QPointF &point)
 }
 
 /*!
-  \fn QGraphicsRotation::originChanged()
+    \property QGraphicsRotation::angle
+    \brief the angle for clockwise rotation, in degrees.
 
-  This signal is emitted whenever the origin of the object
-  changes.
-*/
+    The angle can be any real number; the default value is 0.0. A value of 180
+    will rotate 180 degrees, clockwise. If you provide a negative number, the
+    item will be rotated counter-clockwise. Normally the rotation angle will be
+    in the range (-360, 360), but you can also provide numbers outside of this
+    range (e.g., a angle of 370 degrees gives the same result as 10 degrees).
 
-/*!
-  \property QGraphicsRotation::angle
-  The angle, in degrees, of the rotation.
+    \sa origin
 */
 qreal QGraphicsRotation::angle() const
 {
     Q_D(const QGraphicsRotation);
     return d->angle;
 }
-
 void QGraphicsRotation::setAngle(qreal angle)
 {
     Q_D(QGraphicsRotation);
@@ -361,33 +432,50 @@ void QGraphicsRotation::setAngle(qreal angle)
 }
 
 /*!
-  \fn void QGraphicsRotation::angleChanged()
-
-  This signal is emitted whenever the angle of the object
-  changes.
-*/
-
-/*!
-  \reimp
+    \reimp
 */
 void QGraphicsRotation::applyTo(QTransform *t) const
 {
     Q_D(const QGraphicsRotation);
-    if(d->angle) {
+    if (d->angle) {
         t->translate(d->origin.x(), d->origin.y());
         t->rotate(d->angle);
         t->translate(-d->origin.x(), -d->origin.y());
     }
 }
 
+/*!
+    \fn QGraphicsRotation::originChanged()
+
+    This signal is emitted whenever the origin has changed.
+
+    \sa QGraphicsRotation::origin
+*/
 
 /*!
-  \class QGraphicsRotation3D
-  \brief The QGraphicsRotation3D class provides a way to rotate a graphics item in 3 dimensions.
-  \since 4.6
+  \fn void QGraphicsRotation::angleChanged()
 
-  In addition to the origin and angle of a simple QGraphicsRotation, QGraphicsRotation3D contains
-  also an axis that describes around which axis in space the rotation is supposed to happen.
+  This signal is emitted whenever the angle has changed.
+
+  \sa QGraphicsRotation::angle
+*/
+
+/*!
+    \class QGraphicsRotation3D
+    \brief The QGraphicsRotation3D class provides rotation in 3 dimensions.
+    \since 4.6
+
+    QGraphicsRotation3D extends QGraphicsRotation with the ability to rotate
+    around a given axis.
+
+    You can provide the desired axis by assigning a QVector3D to the axis
+    property. The angle property, which is provided by QGraphicsRotation, now
+    describes the number of degrees to rotate around this axis.
+
+    By default the axis is (0, 0, 1), giving QGraphicsRotation3D the same
+    default behavior as QGraphicsRotation (i.e., rotation around the Z axis).
+
+    \sa QGraphicsTransform, QGraphicsItem::setRotation(), QTransform::rotate()
 */
 
 class QGraphicsRotation3DPrivate : public QGraphicsRotationPrivate
@@ -399,7 +487,7 @@ public:
 };
 
 /*!
-  Constructs a new 3D rotation with \a parent.
+    Constructs a new QGraphicsRotation3D with the given \a parent.
 */
 QGraphicsRotation3D::QGraphicsRotation3D(QObject *parent)
     : QGraphicsRotation(*new QGraphicsRotation3DPrivate, parent)
@@ -407,7 +495,7 @@ QGraphicsRotation3D::QGraphicsRotation3D(QObject *parent)
 }
 
 /*!
-  Destroys the object
+    Destroys the 3D graphics rotation.
 */
 QGraphicsRotation3D::~QGraphicsRotation3D()
 {
@@ -415,15 +503,22 @@ QGraphicsRotation3D::~QGraphicsRotation3D()
 
 /*!
     \property QGraphicsRotation3D::axis
+    \brief a rotation axis, specified by a vector in 3D space.
+
+    This can be any axis in 3D space. By default the axis is (0, 0, 1),
+    which is aligned with the Z axis and provides the same behavior
+    for the rotation angle as QGraphicsRotation. If you provide another
+    axis, QGraphicsRotation3D will provide a transformation that rotates
+    around this axis. For example, if you would like to rotate an item
+    around its X axis, you could pass (1, 0, 0) as the axis.
 
-    A rotation axis is specified by a vector in 3D space.
+    \sa QTransform, QGraphicsRotation::angle
 */
 QVector3D QGraphicsRotation3D::axis()
 {
     Q_D(QGraphicsRotation3D);
     return d->axis;
 }
-
 void QGraphicsRotation3D::setAxis(const QVector3D &axis)
 {
     Q_D(QGraphicsRotation3D);
@@ -431,17 +526,10 @@ void QGraphicsRotation3D::setAxis(const QVector3D &axis)
     update();
 }
 
-/*!
-  \fn void QGraphicsRotation3D::axisChanged()
-
-  This signal is emitted whenever the axis of the object
-  changes.
-*/
-
-const qreal inv_dist_to_plane = 1. / 1024.;
+static const qreal inv_dist_to_plane = 1. / 1024.;
 
 /*!
-  \reimp
+    \reimp
 */
 void QGraphicsRotation3D::applyTo(QTransform *t) const
 {
@@ -474,6 +562,12 @@ void QGraphicsRotation3D::applyTo(QTransform *t) const
     t->translate(-d->origin.x(), -d->origin.y());
 }
 
+/*!
+    \fn void QGraphicsRotation3D::axisChanged()
+
+    This signal is emitted whenever the axis of the object changes.
+*/
+
 #include "moc_qgraphicstransform.cpp"
 
 QT_END_NAMESPACE
diff --git a/src/gui/graphicsview/qgraphicstransform.h b/src/gui/graphicsview/qgraphicstransform.h
index adf9438..d7c07d0 100644
--- a/src/gui/graphicsview/qgraphicstransform.h
+++ b/src/gui/graphicsview/qgraphicstransform.h
@@ -1,7 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 **
@@ -34,7 +34,7 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** contact the sales department at http://www.qtsoftware.com/contact.
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
@@ -65,11 +65,12 @@ public:
     QTransform transform() const;
     virtual void applyTo(QTransform *transform) const = 0;
 
-protected slots:
+protected Q_SLOTS:
     void update();
 
 protected:
     QGraphicsTransform(QGraphicsTransformPrivate &p, QObject *parent);
+
 private:
     friend class QGraphicsItem;
     friend class QGraphicsItemPrivate;
diff --git a/src/gui/image/image.pri b/src/gui/image/image.pri
index c15e8b6..5e9bf8e 100644
--- a/src/gui/image/image.pri
+++ b/src/gui/image/image.pri
@@ -25,7 +25,9 @@ HEADERS += \
 	image/qpixmapcache_p.h \
         image/qpixmapdata_p.h \
         image/qpixmapdatafactory_p.h \
-        image/qpixmapfilter_p.h
+        image/qpixmapfilter_p.h \
+        image/qimagepixmapcleanuphooks_p.h \
+
 
 SOURCES += \
         image/qbitmap.cpp \
@@ -47,6 +49,8 @@ SOURCES += \
         image/qmovie.cpp \
         image/qpixmap_raster.cpp \
         image/qnativeimage.cpp \
+        image/qimagepixmapcleanuphooks.cpp \
+
 
 win32 {
     SOURCES += image/qpixmap_win.cpp
diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index 9a1380e..476fe52 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -49,6 +49,7 @@
 #include "qimagewriter.h"
 #include "qstringlist.h"
 #include "qvariant.h"
+#include "qimagepixmapcleanuphooks_p.h"
 #include <ctype.h>
 #include <stdlib.h>
 #include <limits.h>
@@ -106,14 +107,6 @@ static inline bool checkPixelSize(const QImage::Format format)
     }
 
 
-// ### Qt 5: remove
-typedef void (*_qt_image_cleanup_hook)(int);
-Q_GUI_EXPORT _qt_image_cleanup_hook qt_image_cleanup_hook = 0;
-
-// ### Qt 5: rename
-typedef void (*_qt_image_cleanup_hook_64)(qint64);
-Q_GUI_EXPORT _qt_image_cleanup_hook_64 qt_image_cleanup_hook_64 = 0;
-
 static QImage rotated90(const QImage &src);
 static QImage rotated180(const QImage &src);
 static QImage rotated270(const QImage &src);
@@ -263,8 +256,8 @@ QImageData * QImageData::create(const QSize &size, QImage::Format format, int nu
 
 QImageData::~QImageData()
 {
-    if (is_cached && qt_image_cleanup_hook_64)
-        qt_image_cleanup_hook_64((((qint64) ser_no) << 32) | ((qint64) detach_no));
+    if (is_cached)
+        QImagePixmapCleanupHooks::executeImageHooks((((qint64) ser_no) << 32) | ((qint64) detach_no));
     delete paintEngine;
     if (data && own_data)
         free(data);
@@ -1348,8 +1341,8 @@ QImage::operator QVariant() const
 void QImage::detach()
 {
     if (d) {
-        if (d->is_cached && qt_image_cleanup_hook_64 && d->ref == 1)
-            qt_image_cleanup_hook_64(cacheKey());
+        if (d->is_cached && d->ref == 1)
+            QImagePixmapCleanupHooks::executeImageHooks(cacheKey());
 
         if (d->ref != 1 || d->ro_data)
             *this = copy();
diff --git a/src/gui/image/qimagepixmapcleanuphooks.cpp b/src/gui/image/qimagepixmapcleanuphooks.cpp
new file mode 100644
index 0000000..7d1c5fb
--- /dev/null
+++ b/src/gui/image/qimagepixmapcleanuphooks.cpp
@@ -0,0 +1,110 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qimagepixmapcleanuphooks_p.h"
+#include "qpixmapdata_p.h"
+
+
+// Legacy, single instance hooks: ### Qt 5: remove
+typedef void (*_qt_pixmap_cleanup_hook)(int);
+typedef void (*_qt_pixmap_cleanup_hook_64)(qint64);
+typedef void (*_qt_image_cleanup_hook)(int);
+Q_GUI_EXPORT _qt_pixmap_cleanup_hook qt_pixmap_cleanup_hook = 0;
+Q_GUI_EXPORT _qt_pixmap_cleanup_hook_64 qt_pixmap_cleanup_hook_64 = 0;
+Q_GUI_EXPORT _qt_image_cleanup_hook qt_image_cleanup_hook = 0;
+Q_GUI_EXPORT _qt_image_cleanup_hook_64 qt_image_cleanup_hook_64 = 0;
+
+
+QImagePixmapCleanupHooks* qt_image_and_pixmap_cleanup_hooks = 0;
+
+
+QImagePixmapCleanupHooks::QImagePixmapCleanupHooks()
+{
+    qt_image_and_pixmap_cleanup_hooks = this;
+}
+
+QImagePixmapCleanupHooks *QImagePixmapCleanupHooks::instance()
+{
+    if (!qt_image_and_pixmap_cleanup_hooks)
+        qt_image_and_pixmap_cleanup_hooks = new QImagePixmapCleanupHooks;
+    return qt_image_and_pixmap_cleanup_hooks;
+}
+
+void QImagePixmapCleanupHooks::addPixmapHook(_qt_pixmap_cleanup_hook_pm hook)
+{
+    pixmapHooks.append(hook);
+}
+
+void QImagePixmapCleanupHooks::addImageHook(_qt_image_cleanup_hook_64 hook)
+{
+    imageHooks.append(hook);
+}
+
+void QImagePixmapCleanupHooks::removePixmapHook(_qt_pixmap_cleanup_hook_pm hook)
+{
+    pixmapHooks.removeAll(hook);
+}
+
+void QImagePixmapCleanupHooks::removeImageHook(_qt_image_cleanup_hook_64 hook)
+{
+    imageHooks.removeAll(hook);
+}
+
+
+void QImagePixmapCleanupHooks::executePixmapHooks(QPixmap* pm)
+{
+    for (int i = 0; i < qt_image_and_pixmap_cleanup_hooks->pixmapHooks.count(); ++i)
+        qt_image_and_pixmap_cleanup_hooks->pixmapHooks[i](pm);
+
+    if (qt_pixmap_cleanup_hook_64)
+        qt_pixmap_cleanup_hook_64(pm->cacheKey());
+}
+
+
+void QImagePixmapCleanupHooks::executeImageHooks(qint64 key)
+{
+    for (int i = 0; i < qt_image_and_pixmap_cleanup_hooks->imageHooks.count(); ++i)
+        qt_image_and_pixmap_cleanup_hooks->imageHooks[i](key);
+
+    if (qt_image_cleanup_hook_64)
+        qt_image_cleanup_hook_64(key);
+}
+
diff --git a/src/gui/painting/qregion_wince.cpp b/src/gui/image/qimagepixmapcleanuphooks_p.h
index 9c33123..e765e69 100644
--- a/src/gui/painting/qregion_wince.cpp
+++ b/src/gui/image/qimagepixmapcleanuphooks_p.h
@@ -39,81 +39,51 @@
 **
 ****************************************************************************/
 
-#include "qatomic.h"
-#include "qbitmap.h"
-#include "qbuffer.h"
-#include "qimage.h"
-#include "qpolygon.h"
-#include "qregion.h"
-#include "qt_windows.h"
-#include "qpainterpath.h"
-#include "qguifunctions_wince.h"
+#ifndef QIMAGEPIXMAP_CLEANUPHOOKS_P_H
+#define QIMAGEPIXMAP_CLEANUPHOOKS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qpixmap.h>
 
 QT_BEGIN_NAMESPACE
 
-QRegion::QRegionData QRegion::shared_empty = { Q_BASIC_ATOMIC_INITIALIZER(1), 0, 0 };
+typedef void (*_qt_image_cleanup_hook_64)(qint64);
+typedef void (*_qt_pixmap_cleanup_hook_pm)(QPixmap*);
 
-HRGN qt_tryCreateRegion(QRegion::RegionType type, int left, int top, int right, int bottom)
-{
-    const int tries = 10;
-    for (int i = 0; i < tries; ++i) {
-        HRGN region;
-        switch (type) {
-        case QRegion::Rectangle:
-            region = CreateRectRgn(left, top, right, bottom);
-            break;
-        case QRegion::Ellipse:
-#ifndef Q_OS_WINCE
-            region = CreateEllipticRgn(left, top, right, bottom);
-#endif
-            break;
-        }
-        if (region) {
-            if (GetRegionData(region, 0, 0))
-                return region;
-            else
-                DeleteObject(region);
-        }
-    }
-    return 0;
-}
+class QImagePixmapCleanupHooks;
+extern QImagePixmapCleanupHooks* qt_image_and_pixmap_cleanup_hooks;
 
-void qt_win_dispose_rgn(HRGN r)
+class Q_GUI_EXPORT QImagePixmapCleanupHooks
 {
-    if (r)
-        DeleteObject(r);
-}
+public:
+    QImagePixmapCleanupHooks();
 
-static void qt_add_rect(HRGN &winRegion, QRect r)
-{
-    HRGN rgn = CreateRectRgn(r.left(), r.top(), r.x() + r.width(), r.y() + r.height());
-    if (rgn) {
-        HRGN dest = CreateRectRgn(0,0,0,0);
-        int result = CombineRgn(dest, winRegion, rgn, RGN_OR);
-        if (result) {
-            DeleteObject(winRegion);
-            winRegion = dest;
-        }
-    }
-}
+    static QImagePixmapCleanupHooks *instance();
 
-void QRegion::ensureHandle() const
-{
-    if (d->rgn)
-        DeleteObject(d->rgn);
-    d->rgn = CreateRectRgn(0,0,0,0);
-    if (d->qt_rgn) {
-        if (d->qt_rgn->numRects == 1) {
-            QRect r = d->qt_rgn->extents;
-            qt_add_rect(d->rgn, r);
-            return;
-        }
-        for (int i = 0;i < d->qt_rgn->numRects;i++) {
-            QRect r = d->qt_rgn->rects.at(i);
-            qt_add_rect(d->rgn, r);
-        }
-    }
-}
+    void addPixmapHook(_qt_pixmap_cleanup_hook_pm);
+    void addImageHook(_qt_image_cleanup_hook_64);
+
+    void removePixmapHook(_qt_pixmap_cleanup_hook_pm);
+    void removeImageHook(_qt_image_cleanup_hook_64);
 
+    static void executePixmapHooks(QPixmap*);
+    static void executeImageHooks(qint64 key);
+
+private:
+    QList<_qt_image_cleanup_hook_64> imageHooks;
+    QList<_qt_pixmap_cleanup_hook_pm> pixmapHooks;
+};
 
 QT_END_NAMESPACE
+
+#endif // QIMAGEPIXMAP_CLEANUPHOOKS_P_H
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index b7d5efd..44181d1 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -43,6 +43,7 @@
 
 #include "qpixmap.h"
 #include "qpixmapdata_p.h"
+#include "qimagepixmapcleanuphooks_p.h"
 
 #include "qbitmap.h"
 #include "qcolormap.h"
@@ -85,14 +86,6 @@
 QT_BEGIN_NAMESPACE
 
 // ### Qt 5: remove
-typedef void (*_qt_pixmap_cleanup_hook)(int);
-Q_GUI_EXPORT _qt_pixmap_cleanup_hook qt_pixmap_cleanup_hook = 0;
-
-// ### Qt 5: rename
-typedef void (*_qt_pixmap_cleanup_hook_64)(qint64);
-Q_GUI_EXPORT _qt_pixmap_cleanup_hook_64 qt_pixmap_cleanup_hook_64 = 0;
-
-// ### Qt 5: remove
 Q_GUI_EXPORT qint64 qt_pixmap_id(const QPixmap &pixmap)
 {
     return pixmap.cacheKey();
@@ -660,7 +653,7 @@ void QPixmap::resize_helper(const QSize &s)
     QX11PixmapData *x11Data = data->classId() == QPixmapData::X11Class ? static_cast<QX11PixmapData*>(data) : 0;
     if (x11Data) {
         pm.x11SetScreen(x11Data->xinfo.screen());
-        uninit = x11Data->uninit;
+        uninit = x11Data->flags & QX11PixmapData::Uninitialized;
     }
 #elif defined(Q_WS_MAC)
     QMacPixmapData *macData = data->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data) : 0;
@@ -1361,8 +1354,8 @@ bool QPixmap::isDetached() const
 void QPixmap::deref()
 {
     if (data && !data->ref.deref()) { // Destroy image if last ref
-        if (data->is_cached && qt_pixmap_cleanup_hook_64)
-            qt_pixmap_cleanup_hook_64(cacheKey());
+        if (data->is_cached)
+            QImagePixmapCleanupHooks::executePixmapHooks(this);
         delete data;
         data = 0;
     }
@@ -1904,9 +1897,6 @@ int QPixmap::defaultDepth()
     
 }
 
-typedef void (*_qt_pixmap_cleanup_hook_64)(qint64);
-extern _qt_pixmap_cleanup_hook_64 qt_pixmap_cleanup_hook_64;
-
 /*!
     Detaches the pixmap from shared pixmap data.
 
@@ -1932,8 +1922,8 @@ void QPixmap::detach()
         rasterData->image.detach();
     }
 
-    if (data->is_cached && qt_pixmap_cleanup_hook_64 && data->ref == 1)
-        qt_pixmap_cleanup_hook_64(cacheKey());
+    if (data->is_cached && data->ref == 1)
+        QImagePixmapCleanupHooks::executePixmapHooks(this);
 
 #if defined(Q_WS_MAC)
     QMacPixmapData *macData = id == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data) : 0;
@@ -1953,7 +1943,7 @@ void QPixmap::detach()
 #if defined(Q_WS_X11)
     if (data->classId() == QPixmapData::X11Class) {
         QX11PixmapData *d = static_cast<QX11PixmapData*>(data);
-        d->uninit = false;
+        d->flags &= ~QX11PixmapData::Uninitialized;
 
         // reset the cache data
         if (d->hd2) {
diff --git a/src/gui/image/qpixmap_mac.cpp b/src/gui/image/qpixmap_mac.cpp
index 45392f1..5568898 100644
--- a/src/gui/image/qpixmap_mac.cpp
+++ b/src/gui/image/qpixmap_mac.cpp
@@ -1178,6 +1178,7 @@ QPixmap QPixmap::fromMacCGImageRef(CGImageRef image)
     const size_t w = CGImageGetWidth(image),
                  h = CGImageGetHeight(image);
     QPixmap ret(w, h);
+    ret.fill(Qt::transparent);
     CGRect rect = CGRectMake(0, 0, w, h);
     CGContextRef ctx = qt_mac_cg_context(&ret);
     qt_mac_drawCGImage(ctx, &rect, image);
diff --git a/src/gui/image/qpixmap_x11.cpp b/src/gui/image/qpixmap_x11.cpp
index 86cf515..be3d070 100644
--- a/src/gui/image/qpixmap_x11.cpp
+++ b/src/gui/image/qpixmap_x11.cpp
@@ -313,7 +313,7 @@ int Q_GUI_EXPORT qt_x11_preferred_pixmap_depth = 0;
 
 QX11PixmapData::QX11PixmapData(PixelType type)
     : QPixmapData(type, X11Class), hd(0),
-      uninit(true), read_only(false), x11_mask(0), picture(0), mask_picture(0), hd2(0),
+      flags(Uninitialized), x11_mask(0), picture(0), mask_picture(0), hd2(0), gl_surface(0),
       share_mode(QPixmap::ImplicitlyShared), pengine(0)
 {
 }
@@ -1217,7 +1217,7 @@ void QX11PixmapData::release()
             XFreePixmap(xinfo.display(), hd2);
             hd2 = 0;
         }
-        if (!read_only)
+        if (!(flags & Readonly))
             XFreePixmap(xinfo.display(), hd);
         hd = 0;
     }
@@ -1876,7 +1876,7 @@ QPixmap QX11PixmapData::transformed(const QTransform &transform,
     } else {                                        // color pixmap
         QPixmap pm;
         QX11PixmapData *x11Data = static_cast<QX11PixmapData*>(pm.data);
-        x11Data->uninit = false;
+        x11Data->flags &= ~QX11PixmapData::Uninitialized;
         x11Data->xinfo = xinfo;
         x11Data->d = d;
         x11Data->w = w;
@@ -2018,7 +2018,7 @@ QPixmap QPixmap::grabWindow(WId window, int x, int y, int w, int h)
 
     QPixmap pm(data);
 
-    data->uninit = false;
+    data->flags &= ~QX11PixmapData::Uninitialized;
     pm.x11SetScreen(scr);
 
     GC gc = XCreateGC(dpy, pm.handle(), 0, 0);
@@ -2060,7 +2060,7 @@ QPaintEngine* QX11PixmapData::paintEngine() const
 {
     QX11PixmapData *that = const_cast<QX11PixmapData*>(this);
 
-    if (read_only && share_mode == QPixmap::ImplicitlyShared) {
+    if ((flags & Readonly) && share_mode == QPixmap::ImplicitlyShared) {
         // if someone wants to draw onto us, copy the shared contents
         // and turn it into a fully fledged QPixmap
         ::Pixmap hd_copy = XCreatePixmap(X11->display, RootWindow(X11->display, xinfo.screen()),
@@ -2082,7 +2082,7 @@ QPaintEngine* QX11PixmapData::paintEngine() const
             XFreeGC(X11->display, gc);
         }
         that->hd = hd_copy;
-        that->read_only = false;
+        that->flags &= ~QX11PixmapData::Readonly;
     }
 
     if (!that->pengine)
@@ -2133,7 +2133,7 @@ void QX11PixmapData::copy(const QPixmapData *data, const QRect &rect)
 
     setSerialNumber(++qt_pixmap_serial);
 
-    uninit = false;
+    flags &= ~Uninitialized;
     xinfo = x11Data->xinfo;
     d = x11Data->d;
     w = rect.width();
@@ -2201,7 +2201,7 @@ void QX11PixmapData::convertToARGB32(bool preserveContents)
         return;
 
     // Q_ASSERT(count == 1);
-    if (read_only && share_mode == QPixmap::ExplicitlyShared)
+    if ((flags & Readonly) && share_mode == QPixmap::ExplicitlyShared)
         return;
 
     Pixmap pm = XCreatePixmap(X11->display, RootWindow(X11->display, xinfo.screen()),
@@ -2211,10 +2211,10 @@ void QX11PixmapData::convertToARGB32(bool preserveContents)
     if (picture) {
         if (preserveContents)
             XRenderComposite(X11->display, PictOpSrc, picture, 0, p, 0, 0, 0, 0, 0, 0, w, h);
-        if (!read_only)
+        if (!(flags & Readonly))
             XRenderFreePicture(X11->display, picture);
     }
-    if (hd && !read_only)
+    if (hd && !(flags & Readonly))
         XFreePixmap(X11->display, hd);
     if (x11_mask) {
         XFreePixmap(X11->display, x11_mask);
@@ -2252,9 +2252,8 @@ QPixmap QPixmap::fromX11Pixmap(Qt::HANDLE pixmap, QPixmap::ShareMode mode)
 
     QX11PixmapData *data = new QX11PixmapData(depth == 1 ? QPixmapData::BitmapType : QPixmapData::PixmapType);
     data->setSerialNumber(++qt_pixmap_serial);
-    data->read_only = true;
+    data->flags = QX11PixmapData::Readonly;
     data->share_mode = mode;
-    data->uninit = false;
     data->w = width;
     data->h = height;
     data->is_null = (width <= 0 || height <= 0);
diff --git a/src/gui/image/qpixmap_x11_p.h b/src/gui/image/qpixmap_x11_p.h
index 3de9a0f..835fea4 100644
--- a/src/gui/image/qpixmap_x11_p.h
+++ b/src/gui/image/qpixmap_x11_p.h
@@ -99,6 +99,7 @@ private:
     friend class QX11PaintEngine;
     friend class QX11WindowSurface;
     friend class QRasterWindowSurface;
+    friend class QGLContextPrivate; // Needs to access xinfo, gl_surface & flags
 
     void release();
 
@@ -108,14 +109,21 @@ private:
 
     Qt::HANDLE hd;
 
-    uint uninit : 1;
-    uint read_only : 1;
+    enum Flag {
+         NoFlags = 0x0,
+         Uninitialized = 0x1,
+         Readonly = 0x2,
+         InvertedWhenBoundToTexture = 0x4,
+         GlSurfaceCreatedWithAlpha = 0x8
+    };
+    uint flags;
 
     QX11Info xinfo;
     Qt::HANDLE x11_mask;
     Qt::HANDLE picture;
     Qt::HANDLE mask_picture;
     Qt::HANDLE hd2; // sorted in the default display depth
+    Qt::HANDLE gl_surface;
 #ifndef QT_NO_XRENDER
     void convertToARGB32(bool preserveContents = true);
 #endif
diff --git a/src/gui/image/qpixmapdata_p.h b/src/gui/image/qpixmapdata_p.h
index 29dafaf..32b419e 100644
--- a/src/gui/image/qpixmapdata_p.h
+++ b/src/gui/image/qpixmapdata_p.h
@@ -116,6 +116,7 @@ private:
     friend class QPixmap;
     friend class QGLContextPrivate;
     friend class QX11PixmapData;
+    friend class QGLTextureCache; //Needs to check the reference count
 
     QAtomicInt ref;
     int detach_no;
diff --git a/src/gui/inputmethod/qinputcontextplugin.h b/src/gui/inputmethod/qinputcontextplugin.h
index 8ab8f84..c0c127b 100644
--- a/src/gui/inputmethod/qinputcontextplugin.h
+++ b/src/gui/inputmethod/qinputcontextplugin.h
@@ -66,7 +66,7 @@ QT_BEGIN_NAMESPACE
 
 QT_MODULE(Gui)
 
-#if !defined(QT_NO_IM) && !defined(QT_NO_LIBRARY)
+#if !defined(QT_NO_IM)
 
 class QInputContext;
 class QInputContextPluginPrivate;
diff --git a/src/gui/inputmethod/qximinputcontext_x11.cpp b/src/gui/inputmethod/qximinputcontext_x11.cpp
index edc6904..65b5a24 100644
--- a/src/gui/inputmethod/qximinputcontext_x11.cpp
+++ b/src/gui/inputmethod/qximinputcontext_x11.cpp
@@ -53,6 +53,7 @@
 **
 ****************************************************************************/
 
+#include "qplatformdefs.h"
 #include "qdebug.h"
 #include "qximinputcontext_p.h"
 
diff --git a/src/gui/itemviews/qitemdelegate.cpp b/src/gui/itemviews/qitemdelegate.cpp
index 6bcc153..2c3d127 100644
--- a/src/gui/itemviews/qitemdelegate.cpp
+++ b/src/gui/itemviews/qitemdelegate.cpp
@@ -1226,9 +1226,12 @@ bool QItemDelegate::eventFilter(QObject *object, QEvent *event)
     } else if (event->type() == QEvent::FocusOut || (event->type() == QEvent::Hide && editor->isWindow())) {
         //the Hide event will take care of he editors that are in fact complete dialogs
         if (!editor->isActiveWindow() || (QApplication::focusWidget() != editor)) {
-            if (editor->isAncestorOf(QApplication::focusWidget()))
-                return false; // don't worry about focus changes internally in the editor
-
+            QWidget *w = QApplication::focusWidget();
+            while (w) { // don't worry about focus changes internally in the editor
+                if (w == editor)
+                    return false;
+                w = w->parentWidget();
+            }
 #ifndef QT_NO_DRAGANDDROP
             // The window may lose focus during an drag operation.
             // i.e when dragging involves the taskbar on Windows.
diff --git a/src/gui/itemviews/qstyleditemdelegate.cpp b/src/gui/itemviews/qstyleditemdelegate.cpp
index df519ee..5730c86 100644
--- a/src/gui/itemviews/qstyleditemdelegate.cpp
+++ b/src/gui/itemviews/qstyleditemdelegate.cpp
@@ -674,9 +674,12 @@ bool QStyledItemDelegate::eventFilter(QObject *object, QEvent *event)
     } else if (event->type() == QEvent::FocusOut || (event->type() == QEvent::Hide && editor->isWindow())) {
         //the Hide event will take care of he editors that are in fact complete dialogs
         if (!editor->isActiveWindow() || (QApplication::focusWidget() != editor)) {
-            if (editor->isAncestorOf(QApplication::focusWidget()))
-                return false; // don't worry about focus changes internally in the editor
-
+            QWidget *w = QApplication::focusWidget();
+            while (w) { // don't worry about focus changes internally in the editor
+                if (w == editor)
+                    return false;
+                w = w->parentWidget();
+            }
 #ifndef QT_NO_DRAGANDDROP
             // The window may lose focus during an drag operation.
             // i.e when dragging involves the taskbar on Windows.
diff --git a/src/gui/kernel/qaction.h b/src/gui/kernel/qaction.h
index 3fd80b9..68f88c5 100644
--- a/src/gui/kernel/qaction.h
+++ b/src/gui/kernel/qaction.h
@@ -69,25 +69,25 @@ class Q_GUI_EXPORT QAction : public QObject
     Q_ENUMS(MenuRole)
     Q_ENUMS(SoftKeyRole)
     Q_ENUMS(Priority)
-    Q_PROPERTY(bool checkable READ isCheckable WRITE setCheckable)
+    Q_PROPERTY(bool checkable READ isCheckable WRITE setCheckable NOTIFY changed)
     Q_PROPERTY(bool checked READ isChecked WRITE setChecked DESIGNABLE isCheckable NOTIFY toggled)
-    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)
-    Q_PROPERTY(QIcon icon READ icon WRITE setIcon)
-    Q_PROPERTY(QString text READ text WRITE setText)
-    Q_PROPERTY(QString iconText READ iconText WRITE setIconText)
-    Q_PROPERTY(QString toolTip READ toolTip WRITE setToolTip)
-    Q_PROPERTY(QString statusTip READ statusTip WRITE setStatusTip)
-    Q_PROPERTY(QString whatsThis READ whatsThis WRITE setWhatsThis)
-    Q_PROPERTY(QFont font READ font WRITE setFont)
+    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY changed)
+    Q_PROPERTY(QIcon icon READ icon WRITE setIcon NOTIFY changed)
+    Q_PROPERTY(QString text READ text WRITE setText NOTIFY changed)
+    Q_PROPERTY(QString iconText READ iconText WRITE setIconText NOTIFY changed)
+    Q_PROPERTY(QString toolTip READ toolTip WRITE setToolTip NOTIFY changed)
+    Q_PROPERTY(QString statusTip READ statusTip WRITE setStatusTip NOTIFY changed)
+    Q_PROPERTY(QString whatsThis READ whatsThis WRITE setWhatsThis NOTIFY changed)
+    Q_PROPERTY(QFont font READ font WRITE setFont NOTIFY changed)
 #ifndef QT_NO_SHORTCUT
-    Q_PROPERTY(QKeySequence shortcut READ shortcut WRITE setShortcut)
-    Q_PROPERTY(Qt::ShortcutContext shortcutContext READ shortcutContext WRITE setShortcutContext)
-    Q_PROPERTY(bool autoRepeat READ autoRepeat WRITE setAutoRepeat)
+    Q_PROPERTY(QKeySequence shortcut READ shortcut WRITE setShortcut NOTIFY changed)
+    Q_PROPERTY(Qt::ShortcutContext shortcutContext READ shortcutContext WRITE setShortcutContext NOTIFY changed)
+    Q_PROPERTY(bool autoRepeat READ autoRepeat WRITE setAutoRepeat NOTIFY changed)
 #endif
-    Q_PROPERTY(bool visible READ isVisible WRITE setVisible)
-    Q_PROPERTY(MenuRole menuRole READ menuRole WRITE setMenuRole)
-    Q_PROPERTY(SoftKeyRole softKeyRole READ softKeyRole WRITE setSoftKeyRole)
-    Q_PROPERTY(bool iconVisibleInMenu READ isIconVisibleInMenu WRITE setIconVisibleInMenu)
+    Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY changed)
+    Q_PROPERTY(MenuRole menuRole READ menuRole WRITE setMenuRole NOTIFY changed)
+    Q_PROPERTY(SoftKeyRole softKeyRole READ softKeyRole WRITE setSoftKeyRole NOTIFY changed)
+    Q_PROPERTY(bool iconVisibleInMenu READ isIconVisibleInMenu WRITE setIconVisibleInMenu NOTIFY changed)
     Q_PROPERTY(Priority priority READ priority WRITE setPriority)
 
 public:
diff --git a/src/gui/kernel/qapplication.cpp b/src/gui/kernel/qapplication.cpp
index 700af43..7acba93 100644
--- a/src/gui/kernel/qapplication.cpp
+++ b/src/gui/kernel/qapplication.cpp
@@ -39,6 +39,7 @@
 **
 ****************************************************************************/
 
+#include "qplatformdefs.h"
 #include "qabstracteventdispatcher.h"
 #include "qaccessible.h"
 #include "qapplication.h"
@@ -183,11 +184,11 @@ QApplicationPrivate::~QApplicationPrivate()
 
     QApplication contains the main event loop, where all events from the window
     system and other sources are processed and dispatched. It also handles the
-    application's initialization and finalization, and provides session
-    management. In addition, it handles most system-wide and application-wide
-    settings.
+    application's initialization, finalization, and provides session
+    management. In addition, QApplication handles most of the system-wide and
+    application-wide settings.
 
-    For any GUI application using Qt, there is precisely one QApplication
+    For any GUI application using Qt, there is precisely \bold one QApplication
     object, no matter whether the application has 0, 1, 2 or more windows at
     any given time. For non-GUI Qt applications, use QCoreApplication instead,
     as it does not depend on the \l QtGui library.
@@ -243,9 +244,9 @@ QApplicationPrivate::~QApplicationPrivate()
                 saveState() for details.
         \endlist
 
-    The QApplication object does so much initialization. Hence, it \e{must} be
+    Since the QApplication object does so much initialization, it \e{must} be
     created before any other objects related to the user interface are created.
-    Since QApplication also deals with common command line arguments, it is
+    QApplication also deals with common command line arguments. Hence, it is
     usually a good idea to create it \e before any interpretation or
     modification of \c argv is done in the application itself.
 
@@ -687,9 +688,9 @@ QApplication::QApplication(int &argc, char **argv, int _internal)
 
     On X11, the window system is initialized if \a GUIenabled is true. If
     \a GUIenabled is false, the application does not connect to the X server.
-    On Windows and Macintosh, currently the window system is always
-    initialized, regardless of the value of GUIenabled. This may change in
-    future versions of Qt.
+    On Windows and Mac OS, currently the window system is always initialized,
+    regardless of the value of GUIenabled. This may change in future versions
+    of Qt.
 
     The following example shows how to create an application that uses a
     graphical interface when available.
@@ -1210,21 +1211,22 @@ bool QApplication::compressEvent(QEvent *event, QObject *receiver, QPostEventLis
     \since 4.4
     \brief defines a threshold for auto maximizing widgets
 
-    The auto maximize threshold is only available as part of Qt for Windows CE.
+    \bold{The auto maximize threshold is only available as part of Qt for
+    Windows CE.}
 
     This property defines a threshold for the size of a window as a percentage
     of the screen size. If the minimum size hint of a window exceeds the
-    threshold, calling show() will then cause the window to be maximized
+    threshold, calling show() will cause the window to be maximized
     automatically.
 
-    Setting the threshold to be 100 or greater means that it will cause it to
-    always be maximized. Setting it to be 50 means that the widget is maximized
-    if the vertical minimum size hint is at least 50% of the vertical screen
-    size.
+    Setting the threshold to 100 or greater means that the widget will always
+    be maximized. Alternatively, setting the threshold to 50 means that the
+    widget will be maximized only if the vertical minimum size hint is at least
+    50% of the vertical screen size.
 
-    If -1 is specified then this will disable the feature.
+    Setting the threshold to -1 disables the feature.
 
-    On Windows CE the default is -1 (i.e. it is disabled).
+    On Windows CE the default is -1 (i.e., it is disabled).
     On Windows Mobile the default is 40.
 */
 
@@ -1233,13 +1235,13 @@ bool QApplication::compressEvent(QEvent *event, QObject *receiver, QPostEventLis
     \since 4.5
     \brief toggles automatic SIP (software input panel) visibility
 
-    Set this property to true to automatically display the SIP when entering
+    Set this property to \c true to automatically display the SIP when entering
     widgets that accept keyboard input. This property only affects widgets with
     the WA_InputMethodEnabled attribute set, and is typically used to launch
     a virtual keyboard on devices which have very few or no keys.
 
-    The property only has an effect on platforms which use software input
-    panels, such as Windows CE and Symbian.
+    \bold{ The property only has an effect on platforms which use software input
+    panels, such as Windows CE and Symbian.}
 
     The default is platform dependent.
 */
@@ -1537,7 +1539,7 @@ int QApplication::colorSpec()
             strategy. Use this option if your application uses buttons, menus,
             texts and pixmaps with few colors. With this option, the
             application uses system global colors. This works fine for most
-            applications under X11, but on Windows machines it may cause
+            applications under X11, but on the Windows platform, it may cause
             dithering of non-standard colors.
         \o  QApplication::CustomColor. Use this option if your application
             needs a small number of custom colors. On X11, this option is the
@@ -3580,12 +3582,12 @@ void QApplication::changeOverrideCursor(const QCursor &cursor)
 
     We recommend that you connect clean-up code to the
     \l{QCoreApplication::}{aboutToQuit()} signal, instead of putting it in your
-    application's \c{main()} function because on some platforms the
-    QApplication::exec() call may not return. For example, on Windows when the
-    user logs off, the system terminates the process after Qt closes all
-    top-level windows. Hence, there is no guarantee that the application will
-    have time to exit its event loop and execute code at the end of the
-    \c{main()} function after the QApplication::exec() call.
+    application's \c{main()} function. This is because, on some platforms the
+    QApplication::exec() call may not return. For example, on the Windows
+    platform, when the user logs off, the system terminates the process after Qt
+    closes all top-level windows. Hence, there is \e{no guarantee} that the
+    application will have time to exit its event loop and execute code at the
+    end of the \c{main()} function, after the QApplication::exec() call.
 
     \sa quitOnLastWindowClosed, quit(), exit(), processEvents(),
         QCoreApplication::exec()
@@ -4851,7 +4853,7 @@ bool QApplication::keypadNavigationEnabled()
     On Mac OS X, this works more at the application level and will cause the
     application icon to bounce in the dock.
 
-    On Windows this causes the window's taskbar entry to flash for a time. If
+    On Windows, this causes the window's taskbar entry to flash for a time. If
     \a msec is zero, the flashing will stop and the taskbar entry will turn a
     different color (currently orange).
 
@@ -4868,24 +4870,22 @@ bool QApplication::keypadNavigationEnabled()
     caret display. Usually the text cursor is displayed for half the cursor
     flash time, then hidden for the same amount of time, but this may vary.
 
-    The default value on X11 is 1000 milliseconds. On Windows, the control
-    panel value is used. Widgets should not cache this value since it may be
-    changed at any time by the user changing the global desktop settings.
+    The default value on X11 is 1000 milliseconds. On Windows, the
+    \gui{Control Panel} value is used and setting this property sets the cursor
+    flash time for all applications.
 
-    \note On Microsoft Windows, setting this property sets the cursor flash
-    time for all applications.
+    We recommend that widgets do not cache this value as it may change at any
+    time if the user changes the global desktop settings.
 */
 
 /*!
     \property QApplication::doubleClickInterval
-    \brief the time limit in milliseconds that distinguishes a double click from two
-    consecutive mouse clicks
-
-    The default value on X11 is 400 milliseconds. On Windows and Mac OS X, the
-    operating system's value is used.
+    \brief the time limit in milliseconds that distinguishes a double click
+    from two consecutive mouse clicks
 
-    On Microsoft Windows and Symbian, calling this function sets the
-    double click interval for all applications.
+    The default value on X11 is 400 milliseconds. On Windows and Mac OS, the
+    operating system's value is used. However, on Windows and Symbian OS,
+    calling this function sets the double click interval for all applications.
 */
 
 /*!
@@ -4894,7 +4894,7 @@ bool QApplication::keypadNavigationEnabled()
     from two consecutive key presses
     \since 4.2
 
-    The default value on X11 is 400 milliseconds. On Windows and Mac OS X, the
+    The default value on X11 is 400 milliseconds. On Windows and Mac OS, the
     operating system's value is used.
 */
 
@@ -4959,7 +4959,7 @@ bool QApplication::keypadNavigationEnabled()
     You need not have a main widget; connecting lastWindowClosed() to quit()
     is an alternative.
 
-    For X11, this function also resizes and moves the main widget according
+    On X11, this function also resizes and moves the main widget according
     to the \e -geometry command-line option, so you should set the default
     geometry (using \l QWidget::setGeometry()) before calling setMainWidget().
 
@@ -4988,9 +4988,10 @@ bool QApplication::keypadNavigationEnabled()
     Application cursors are stored on an internal stack. setOverrideCursor()
     pushes the cursor onto the stack, and restoreOverrideCursor() pops the
     active cursor off the stack. changeOverrideCursor() changes the curently
-    active application override cursor. Every setOverrideCursor() must
-    eventually be followed by a corresponding restoreOverrideCursor(),
-    otherwise the stack will never be emptied.
+    active application override cursor.
+
+    Every setOverrideCursor() must eventually be followed by a corresponding
+    restoreOverrideCursor(), otherwise the stack will never be emptied.
 
     Example:
     \snippet doc/src/snippets/code/src_gui_kernel_qapplication_x11.cpp 0
@@ -5177,19 +5178,19 @@ bool QApplicationPrivate::shouldSetFocus(QWidget *w, Qt::FocusPolicy policy)
 */
 
 /*! \fn QDecoration* QApplication::qwsSetDecoration(const QString &decoration)
-  \overload
+    \overload
 
-  Requests a QDecoration object for \a decoration from the QDecorationFactory.
+    Requests a QDecoration object for \a decoration from the
+    QDecorationFactory.
 
-  The string must be one of the QDecorationFactory::keys(). Keys are
-  case insensitive.
+    The string must be one of the QDecorationFactory::keys(). Keys are case
+    insensitive.
 
-  A later call to the QApplication constructor will override the
-  requested style when a "-style" option is passed in as a commandline
-  parameter.
+    A later call to the QApplication constructor will override the requested
+    style when a "-style" option is passed in as a commandline parameter.
 
-  Returns 0 if an unknown \a decoration is passed, otherwise the QStyle object
-  returned is set as the application's GUI style.
+    Returns 0 if an unknown \a decoration is passed, otherwise the QStyle object
+    returned is set as the application's GUI style.
 */
 
 /*!
diff --git a/src/gui/kernel/qapplication_mac.mm b/src/gui/kernel/qapplication_mac.mm
index beccfb0..ac132aa 100644
--- a/src/gui/kernel/qapplication_mac.mm
+++ b/src/gui/kernel/qapplication_mac.mm
@@ -1480,6 +1480,7 @@ QWidget *QApplicationPrivate::tryModalHelper_sys(QWidget *top)
     return top;
 }
 
+#ifndef QT_MAC_USE_COCOA
 static bool qt_try_modal(QWidget *widget, EventRef event)
 {
     QWidget * top = 0;
@@ -1513,6 +1514,7 @@ static bool qt_try_modal(QWidget *widget, EventRef event)
 #endif
     return !block_event;
 }
+#endif
 
 OSStatus QApplicationPrivate::tabletProximityCallback(EventHandlerCallRef, EventRef carbonEvent,
                                                       void *)
@@ -2890,52 +2892,25 @@ bool QApplicationPrivate::canQuit()
 #endif
 }
 
-void onApplicationWindowChangedActivation( QWidget*widget, bool activated )
+void onApplicationWindowChangedActivation(QWidget *widget, bool activated)
 {
 #if QT_MAC_USE_COCOA
-    QApplication *app = qApp;
+    if (!widget)
+        return;
 
-    if ( activated )
-    {
-        if (QApplicationPrivate::app_style)
-        {
+    if (activated) {
+        if (QApplicationPrivate::app_style) {
             QEvent ev(QEvent::Style);
             qt_sendSpontaneousEvent(QApplicationPrivate::app_style, &ev);
         }
-
-        if (widget && app_do_modal && !qt_try_modal(widget, NULL))
-            return;
-
-        if (widget && widget->window()->isVisible())
-        {
-            QWidget *tlw = widget->window();
-
-            if (tlw->isWindow() && !(tlw->windowType() == Qt::Popup)
-                 && !qt_mac_is_macdrawer(tlw)
-                && (!tlw->parentWidget() || tlw->isModal() || !(tlw->windowType() == Qt::Tool))) {
-                bool just_send_event = false;
-#if 0
-                WindowActivationScope    scope;
-                if ( GetWindowActivationScope((OSWindowRef)wid, &scope) == noErr &&
-                        scope == kWindowActivationScopeIndependent) 
-                {
-                    if ( GetFrontWindowOfClass(kAllWindowClasses, true) != wid )
-                        just_send_event = true;
-                }
-#endif
-                if (just_send_event) {
-                    QEvent e(QEvent::WindowActivate);
-                    qt_sendSpontaneousEvent(widget, &e);
-                } else {
-                    app->setActiveWindow(tlw);
-                }
-            }
-        }
+        qApp->setActiveWindow(widget);
     } else { // deactivated
-        if (widget && QApplicationPrivate::active_window == widget)
-            app->setActiveWindow(0);
+        if (QApplicationPrivate::active_window == widget)
+            qApp->setActiveWindow(0);
     }
+
     QMenuBar::macUpdateMenuBar();
+
 #else
     Q_UNUSED(widget);
     Q_UNUSED(activated);
diff --git a/src/gui/kernel/qapplication_qws.cpp b/src/gui/kernel/qapplication_qws.cpp
index 83b2861..0f41025 100644
--- a/src/gui/kernel/qapplication_qws.cpp
+++ b/src/gui/kernel/qapplication_qws.cpp
@@ -101,7 +101,11 @@
 #include <locale.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <sys/time.h>
+#ifdef Q_OS_VXWORKS
+#  include <sys/times.h>
+#else
+#  include <sys/time.h>
+#endif
 #include <sys/stat.h>
 #include <sys/types.h>
 
@@ -196,7 +200,14 @@ QString qws_dataDir()
     static QString result;
     if (!result.isEmpty())
         return result;
-    QByteArray dataDir = QString::fromLatin1("/tmp/qtembedded-%1").arg(qws_display_id).toLocal8Bit();
+    QByteArray dataDir;
+#ifdef QT_QWS_TEMP_DIR
+    dataDir = QT_QWS_TEMP_DIR;
+#else
+    dataDir = "/tmp";
+#endif
+    dataDir += "/qtembedded-";
+    dataDir += QByteArray::number(qws_display_id);
     if (QT_MKDIR(dataDir, 0700)) {
         if (errno != EEXIST) {
             qFatal("Cannot create Qt for Embedded Linux data directory: %s", dataDir.constData());
@@ -210,7 +221,7 @@ QString qws_dataDir()
     if (!S_ISDIR(buf.st_mode))
         qFatal("%s is not a directory", dataDir.constData());
 
-#ifndef Q_OS_INTEGRITY
+#if !defined(Q_OS_INTEGRITY) && !defined(Q_OS_VXWORKS)
     if (buf.st_uid != getuid())
         qFatal("Qt for Embedded Linux data directory is not owned by user %d", getuid());
 
diff --git a/src/gui/kernel/qboxlayout.cpp b/src/gui/kernel/qboxlayout.cpp
index 770f5bb..23d20ff 100644
--- a/src/gui/kernel/qboxlayout.cpp
+++ b/src/gui/kernel/qboxlayout.cpp
@@ -527,7 +527,7 @@ void QBoxLayoutPrivate::calcHfw(int w)
     You will almost always want to use QVBoxLayout and QHBoxLayout
     rather than QBoxLayout because of their convenient constructors.
 
-    \sa QGridLayout, QStackedLayout, {Layout Classes}
+    \sa QGridLayout, QStackedLayout, {Layout Management}
 */
 
 /*!
@@ -1295,7 +1295,7 @@ QBoxLayout::Direction QBoxLayout::direction() const
 
     \image qhboxlayout-with-5-children.png Horizontal box layout with five child widgets
 
-    \sa QVBoxLayout, QGridLayout, QStackedLayout, {Layout Classes}, {Basic Layouts Example}
+    \sa QVBoxLayout, QGridLayout, QStackedLayout, {Layout Management}, {Basic Layouts Example}
 */
 
 
@@ -1413,7 +1413,7 @@ QHBoxLayout::~QHBoxLayout()
 
     \image qvboxlayout-with-5-children.png Horizontal box layout with five child widgets
 
-    \sa QHBoxLayout, QGridLayout, QStackedLayout, {Layout Classes}, {Basic Layouts Example}
+    \sa QHBoxLayout, QGridLayout, QStackedLayout, {Layout Management}, {Basic Layouts Example}
 */
 
 /*!
diff --git a/src/gui/kernel/qcocoaview_mac.mm b/src/gui/kernel/qcocoaview_mac.mm
index 57c9117..1d352cb 100644
--- a/src/gui/kernel/qcocoaview_mac.mm
+++ b/src/gui/kernel/qcocoaview_mac.mm
@@ -327,7 +327,7 @@ extern "C" {
         return NSDragOperationNone;
     } else {
         // save the mouse position, used by draggingExited handler.
-        DnDParams *dndParams = [QCocoaView currentMouseEvent];
+        DnDParams *dndParams = [QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent];
         dndParams->activeDragEnterPos = windowPoint;
         // send a drag move event immediately after a drag enter event (as per documentation).
         QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
@@ -406,7 +406,7 @@ extern "C" {
     dragEnterSequence = -1;
     if (qwidget->testAttribute(Qt::WA_TransparentForMouseEvents)) {
         // try sending the leave event to the last view which accepted drag enter.
-        DnDParams *dndParams = [QCocoaView currentMouseEvent];
+        DnDParams *dndParams = [QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent];
         NSView *candidateView = [[[self window] contentView] hitTest:dndParams->activeDragEnterPos];
         if (candidateView && candidateView != self)
             return [candidateView draggingExited:sender];
diff --git a/src/gui/kernel/qcursor.cpp b/src/gui/kernel/qcursor.cpp
index d665cc2..e5ca196 100644
--- a/src/gui/kernel/qcursor.cpp
+++ b/src/gui/kernel/qcursor.cpp
@@ -127,11 +127,11 @@ QT_BEGIN_NAMESPACE
          \o Qt::SizeAllCursor \o \c size_all
     \row \o \inlineimage      cursor-busy.png
          \o Qt::BusyCursor    \o \c left_ptr_watch
-         \o \inlineimage      cursor-hsplit.png
+         \o \inlineimage      cursor-vsplit.png
          \o Qt::SplitVCursor  \o \c split_v
     \row \o \inlineimage      cursor-forbidden.png
          \o Qt::ForbiddenCursor \o \c forbidden
-         \o \inlineimage      cursor-vsplit.png
+         \o \inlineimage      cursor-hsplit.png
          \o Qt::SplitHCursor  \o \c split_h
     \row \o \inlineimage      cursor-hand.png
          \o Qt::PointingHandCursor \o \c pointing_hand
diff --git a/src/gui/kernel/qformlayout.cpp b/src/gui/kernel/qformlayout.cpp
index 0b7656f..de33f93 100644
--- a/src/gui/kernel/qformlayout.cpp
+++ b/src/gui/kernel/qformlayout.cpp
@@ -689,16 +689,12 @@ void QFormLayoutPrivate::setupVerticalLayoutData(int width)
     // are split.
     maxLabelWidth = 0;
     if (!wrapAllRows) {
-        int maxFieldMinWidth = 0; //the maximum minimum size of the field
         for (int i = 0; i < rr; ++i) {
             const QFormLayoutItem *label = m_matrix(i, 0);
             const QFormLayoutItem *field = m_matrix(i, 1);
-            if (label && field && label->sideBySide)
+            if (label && (label->sizeHint.width() + (field ? field->minSize.width() : 0) <= width))
                 maxLabelWidth = qMax(maxLabelWidth, label->sizeHint.width());
-            if (field)
-                maxFieldMinWidth = qMax(maxFieldMinWidth, field->minSize.width() + field->sbsHSpace);
         }
-        maxLabelWidth = qMin(maxLabelWidth, width - maxFieldMinWidth);
     } else {
         maxLabelWidth = width;
     }
diff --git a/src/gui/kernel/qgesture.cpp b/src/gui/kernel/qgesture.cpp
index d53b419..1f98013 100644
--- a/src/gui/kernel/qgesture.cpp
+++ b/src/gui/kernel/qgesture.cpp
@@ -153,7 +153,7 @@ QGesture::QGesture(QObject *parent)
     : QObject(*new QGesturePrivate, parent)
 {
     if (parent)
-        installEventFilter(parent);
+        parent->installEventFilter(this);
 }
 
 /*! \internal
@@ -162,7 +162,7 @@ QGesture::QGesture(QGesturePrivate &dd, QObject *parent)
     : QObject(dd, parent)
 {
     if (parent)
-        installEventFilter(parent);
+        parent->installEventFilter(this);
 }
 
 /*!
diff --git a/src/gui/kernel/qgridlayout.cpp b/src/gui/kernel/qgridlayout.cpp
index 7ac874e..558f570 100644
--- a/src/gui/kernel/qgridlayout.cpp
+++ b/src/gui/kernel/qgridlayout.cpp
@@ -1046,7 +1046,7 @@ QRect QGridLayoutPrivate::cellRect(int row, int col) const
     the margin width for a top-level layout, or to the same as the
     parent layout.
 
-    \sa QBoxLayout, QStackedLayout, {Layout Classes}, {Basic Layouts Example}
+    \sa QBoxLayout, QStackedLayout, {Layout Management}, {Basic Layouts Example}
 */
 
 
diff --git a/src/gui/kernel/qlayout.cpp b/src/gui/kernel/qlayout.cpp
index 921afce..f41de11 100644
--- a/src/gui/kernel/qlayout.cpp
+++ b/src/gui/kernel/qlayout.cpp
@@ -83,7 +83,7 @@ static int menuBarHeightForWidth(QWidget *menubar, int w)
 
     For users of QLayout subclasses or of QMainWindow there is seldom
     any need to use the basic functions provided by QLayout, such as
-    setSizeConstraint() or setMenuBar(). See \l{Layout Classes}
+    setSizeConstraint() or setMenuBar(). See \l{Layout Management}
     for more information.
 
     To make your own layout manager, implement the functions
@@ -98,7 +98,7 @@ static int menuBarHeightForWidth(QWidget *menubar, int w)
 
     Geometry management stops when the layout manager is deleted.
 
-    \sa QLayoutItem, {Layout Classes}, {Basic Layouts Example},
+    \sa QLayoutItem, {Layout Management}, {Basic Layouts Example},
         {Border Layout Example}, {Flow Layout Example}
 */
 
diff --git a/src/gui/kernel/qt_cocoa_helpers_mac.mm b/src/gui/kernel/qt_cocoa_helpers_mac.mm
index 1c4177e..3104083 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac.mm
+++ b/src/gui/kernel/qt_cocoa_helpers_mac.mm
@@ -1211,7 +1211,10 @@ void qt_mac_menu_collapseSeparators(void */*NSMenu **/ theMenu, bool collapse)
     if (collapse) {
         bool previousIsSeparator = true; // setting to true kills all the separators placed at the top.
         NSMenuItem *previousItem = nil;
-        for (NSMenuItem *item in [menu itemArray]) {
+            
+        NSArray *itemArray = [menu itemArray];
+        for (unsigned int i = 0; i < [itemArray count]; ++i) {
+            NSMenuItem *item = reinterpret_cast<NSMenuItem *>([itemArray objectAtIndex:i]);
             if ([item isSeparatorItem]) {
                 [item setHidden:previousIsSeparator];
             }
@@ -1226,7 +1229,9 @@ void qt_mac_menu_collapseSeparators(void */*NSMenu **/ theMenu, bool collapse)
         if (previousItem && previousIsSeparator)
             [previousItem setHidden:YES];
     } else {
-        for (NSMenuItem *item in [menu itemArray]) {
+        NSArray *itemArray = [menu itemArray];
+        for (unsigned int i = 0; i < [itemArray count]; ++i) {
+            NSMenuItem *item = reinterpret_cast<NSMenuItem *>([itemArray objectAtIndex:i]);
             if (QAction *action = reinterpret_cast<QAction *>([item tag]))
                 [item setHidden:!action->isVisible()];
         }
diff --git a/src/gui/kernel/qt_x11_p.h b/src/gui/kernel/qt_x11_p.h
index 1c8394b..1ac51e0 100644
--- a/src/gui/kernel/qt_x11_p.h
+++ b/src/gui/kernel/qt_x11_p.h
@@ -74,11 +74,19 @@
 #include <X11/Xutil.h>
 #include <X11/Xos.h>
 #ifdef index
-# undef index
+#  undef index
 #endif
 #ifdef rindex
-# undef rindex
+#  undef rindex
 #endif
+#ifdef Q_OS_VXWORS
+#  ifdef open
+#    undef open
+#  endif
+#  ifdef getpid
+#    undef getpid
+#  endif
+#endif // Q_OS_VXWORKS
 #include <X11/Xatom.h>
 
 //#define QT_NO_SHAPE
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index c2fdadf..d7c89a6 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -511,7 +511,7 @@ void QWidget::setAutoFillBackground(bool enabled)
     been outlined to indicate their full sizes.
 
     If you want to use a QWidget to hold child widgets you will usually want to
-    add a layout to the parent QWidget. See \l{Layout Classes} for more
+    add a layout to the parent QWidget. See \l{Layout Management} for more
     information.
 
 
@@ -1438,6 +1438,12 @@ QWidget::~QWidget()
     // set all QPointers for this object to zero
     QObjectPrivate::clearGuards(this);
 
+    if(d->declarativeData) {
+        QDeclarativeData *dd = d->declarativeData;
+        d->declarativeData = 0;
+        dd->destroyed(this);
+    }
+
     if (!d->children.isEmpty())
         d->deleteChildren();
 
@@ -3567,11 +3573,16 @@ bool QWidgetPrivate::setMinimumSize_helper(int &minw, int &minh)
         minh = qMax(minh, 0);
     }
     createExtra();
-    if (extra->minw == minw && extra->minh == minh)
+    int mw = minw, mh = minh;
+    if (mw == QWIDGETSIZE_MAX)
+        mw = 0;
+    if (mh == QWIDGETSIZE_MAX)
+        mh = 0;
+    if (extra->minw == mw && extra->minh == mh)
         return false;
-    extra->minw = minw;
-    extra->minh = minh;
-    extra->explicitMinSize = (minw ? Qt::Horizontal : 0) | (minh ? Qt::Vertical : 0);
+    extra->minw = mw;
+    extra->minh = mh;
+    extra->explicitMinSize = (mw ? Qt::Horizontal : 0) | (mh ? Qt::Vertical : 0);
     return true;
 }
 
@@ -3631,7 +3642,8 @@ bool QWidgetPrivate::setMaximumSize_helper(int &maxw, int &maxh)
         return false;
     extra->maxw = maxw;
     extra->maxh = maxh;
-    extra->explicitMaxSize = (maxw != QWIDGETSIZE_MAX ? Qt::Horizontal : 0) | (maxh != QWIDGETSIZE_MAX ? Qt::Vertical : 0);
+    extra->explicitMaxSize = (maxw != QWIDGETSIZE_MAX ? Qt::Horizontal : 0) |
+                             (maxh != QWIDGETSIZE_MAX ? Qt::Vertical : 0);
     return true;
 }
 
@@ -3710,6 +3722,8 @@ void QWidget::setBaseSize(int basew, int baseh)
 
     This will override the default size constraints set by QLayout.
 
+    To remove constraints, set the size to QWIDGETSIZE_MAX.
+
     Alternatively, if you want the widget to have a
     fixed size based on its contents, you can call
     QLayout::setSizeConstraint(QLayout::SetFixedSize);
@@ -3751,7 +3765,8 @@ void QWidget::setFixedSize(int w, int h)
     else
         d->updateGeometry_helper(true);
 
-    resize(w, h);
+    if (w != QWIDGETSIZE_MAX || h != QWIDGETSIZE_MAX)
+        resize(w, h);
 }
 
 void QWidget::setMinimumWidth(int w)
@@ -8993,7 +9008,7 @@ QRegion QWidget::mask() const
     The layout manager sets the geometry of the widget's children
     that have been added to the layout.
 
-    \sa setLayout(), sizePolicy(), {Layout Classes}
+    \sa setLayout(), sizePolicy(), {Layout Management}
 */
 QLayout *QWidget::layout() const
 {
@@ -9023,7 +9038,7 @@ QLayout *QWidget::layout() const
 
     The QWidget will take ownership of \a layout.
 
-    \sa layout(), {Layout Classes}
+    \sa layout(), {Layout Management}
 */
 
 void QWidget::setLayout(QLayout *l)
@@ -9989,6 +10004,10 @@ void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
             data->window_modality = (w && w->testAttribute(Qt::WA_GroupLeader))
                                     ? Qt::WindowModal
                                     : Qt::ApplicationModal;
+            // Some window managers does not allow us to enter modal after the
+            // window is showing. Therefore, to be consistent, we cannot call
+            // QApplicationPrivate::enterModal(this) here. The window must be
+            // hidden before changing modality.
         }
         if (testAttribute(Qt::WA_WState_Created)) {
             // don't call setModal_sys() before create_sys()
diff --git a/src/gui/kernel/qwidget_mac.mm b/src/gui/kernel/qwidget_mac.mm
index 70eea3a..78df09d 100644
--- a/src/gui/kernel/qwidget_mac.mm
+++ b/src/gui/kernel/qwidget_mac.mm
@@ -3100,7 +3100,12 @@ void QWidgetPrivate::update_sys(const QRegion &rgn)
         return;
     dirtyOnWidget += rgn;
 #ifndef QT_MAC_USE_COCOA
-    HIViewSetNeedsDisplayInRegion(qt_mac_nativeview_for(q), QMacSmartQuickDrawRegion(rgn.toQDRgn()), true);
+    RgnHandle rgnHandle = rgn.toQDRgnForUpdate_sys();
+    if (rgnHandle) 
+        HIViewSetNeedsDisplayInRegion(qt_mac_nativeview_for(q), QMacSmartQuickDrawRegion(rgnHandle), true);
+    else {
+        HIViewSetNeedsDisplay(qt_mac_nativeview_for(q), true); // do a complete repaint on overflow.
+    }
 #else
     // Cocoa doesn't do regions, it seems more efficient to just update the bounding rect instead of a potential number of message passes for each rect.
     const QRect &boundingRect = rgn.boundingRect();
@@ -4584,6 +4589,7 @@ void QWidgetPrivate::setModal_sys()
     OSWindowRef windowRef = qt_mac_window_for(q);
 
 #ifdef QT_MAC_USE_COCOA
+    QMacCocoaAutoReleasePool pool;
     bool alreadySheet = [windowRef styleMask] & NSDocModalWindowMask;
 
     if (windowParent && q->windowModality() == Qt::WindowModal){
@@ -4660,31 +4666,40 @@ void QWidgetPrivate::setModal_sys()
                 || (primaryWindow && primaryWindow->windowModality() == Qt::WindowModal)){
             // Window should be window-modal (which implies a sheet).
             if (old_wclass != kSheetWindowClass){
-                // We cannot convert a created window to a sheet. So we recreate the window:
+                // We cannot convert a created window to a sheet.
+                // So we recreate the window:
                 recreateMacWindow();
                 return;
             }
-        } else if (!(q->data->window_flags & Qt::CustomizeWindowHint)) {
-            if (old_wclass == kDocumentWindowClass || old_wclass == kFloatingWindowClass || old_wclass == kUtilityWindowClass){
-                // Only change the class to kMovableModalWindowClass if the no explicit jewels
-                // are set (kMovableModalWindowClass can't contain them), and the current window class
-                // can be converted to modal (according to carbon doc). Mind the order of
-                // HIWindowChangeClass and ChangeWindowAttributes.
-                WindowGroupRef group = GetWindowGroup(windowRef);
-                HIWindowChangeClass(windowRef, kMovableModalWindowClass);
-                quint32 tmpWattr = kWindowCloseBoxAttribute | kWindowHorizontalZoomAttribute;
-                ChangeWindowAttributes(windowRef, tmpWattr, kWindowNoAttributes);
-                ChangeWindowAttributes(windowRef, kWindowNoAttributes, tmpWattr);
-                // If the window belongs to a qt-created group, set that group once more:
-                if (data.window_flags & Qt::WindowStaysOnTopHint
-                        || q->windowType() == Qt::Popup
-                        || q->windowType() == Qt::ToolTip)
-                    SetWindowGroup(windowRef, group);
+        } else {
+            // Window should be application-modal (which implies NOT using a sheet).
+            if (old_wclass == kSheetWindowClass){
+                // We cannot convert a sheet to a window.
+                // So we recreate the window:
+                recreateMacWindow();
+                return;
+            } else if (!(q->data->window_flags & Qt::CustomizeWindowHint)) {
+                if (old_wclass == kDocumentWindowClass || old_wclass == kFloatingWindowClass || old_wclass == kUtilityWindowClass){
+                    // Only change the class to kMovableModalWindowClass if the no explicit jewels
+                    // are set (kMovableModalWindowClass can't contain them), and the current window class
+                    // can be converted to modal (according to carbon doc). Mind the order of
+                    // HIWindowChangeClass and ChangeWindowAttributes.
+                    WindowGroupRef group = GetWindowGroup(windowRef);
+                    HIWindowChangeClass(windowRef, kMovableModalWindowClass);
+                    quint32 tmpWattr = kWindowCloseBoxAttribute | kWindowHorizontalZoomAttribute;
+                    ChangeWindowAttributes(windowRef, tmpWattr, kWindowNoAttributes);
+                    ChangeWindowAttributes(windowRef, kWindowNoAttributes, tmpWattr);
+                    // If the window belongs to a qt-created group, set that group once more:
+                    if (data.window_flags & Qt::WindowStaysOnTopHint
+                            || q->windowType() == Qt::Popup
+                            || q->windowType() == Qt::ToolTip)
+                        SetWindowGroup(windowRef, group);
+                }
+                // Popups are usually handled "special" and are never modal.
+                Qt::WindowType winType = q->windowType();
+                if (winType != Qt::Popup && winType != Qt::ToolTip)
+                    SetWindowModality(windowRef, kWindowModalityAppModal, 0);
             }
-            // Popups are usually handled "special" and are never modal.
-            Qt::WindowType winType = q->windowType();
-            if (winType != Qt::Popup && winType != Qt::ToolTip)
-                SetWindowModality(windowRef, kWindowModalityAppModal, 0);
         }
     } else if (windowRef) {
         if (old_wclass == kSheetWindowClass){
diff --git a/src/gui/kernel/qwidget_win.cpp b/src/gui/kernel/qwidget_win.cpp
index 46fa3be..b11b661 100644
--- a/src/gui/kernel/qwidget_win.cpp
+++ b/src/gui/kernel/qwidget_win.cpp
@@ -467,6 +467,17 @@ void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyO
         }
     }
 
+    if (topLevel) {
+        if (data.window_flags & Qt::CustomizeWindowHint
+            && data.window_flags & Qt::WindowTitleHint) {
+            HMENU systemMenu = GetSystemMenu((HWND)q->internalWinId(), FALSE);
+            if (data.window_flags & Qt::WindowCloseButtonHint)
+                EnableMenuItem(systemMenu, SC_CLOSE, MF_BYCOMMAND|MF_ENABLED);
+            else
+                EnableMenuItem(systemMenu, SC_CLOSE, MF_BYCOMMAND|MF_GRAYED);
+        }
+    }
+
     q->setAttribute(Qt::WA_WState_Created);                // accept move/resize events
     hd = 0;                                        // no display context
 
@@ -638,16 +649,6 @@ void QWidgetPrivate::setParent_sys(QWidget *parent, Qt::WindowFlags f)
         || (!q->isWindow() && q->parentWidget() && q->parentWidget()->testAttribute(Qt::WA_DropSiteRegistered)))
         q->setAttribute(Qt::WA_DropSiteRegistered, true);
 
-
-    if (data.window_flags & Qt::CustomizeWindowHint
-        && data.window_flags & Qt::WindowTitleHint) {
-        HMENU systemMenu = GetSystemMenu((HWND)q->internalWinId(), FALSE);
-        if (data.window_flags & Qt::WindowCloseButtonHint)
-            EnableMenuItem(systemMenu, SC_CLOSE, MF_BYCOMMAND|MF_ENABLED);
-        else
-            EnableMenuItem(systemMenu, SC_CLOSE, MF_BYCOMMAND|MF_GRAYED);
-    }
-
 #ifdef Q_WS_WINCE
     // Show borderless toplevel windows in tasklist & NavBar
     if (!parent) {
@@ -1431,10 +1432,7 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
                     qt_wince_maximize(q);
                 } else {
 #endif
-                    if (!isTranslucentWindow)
-                        MoveWindow(q->internalWinId(), fs.x(), fs.y(), fs.width(), fs.height(), true);
-                    else if (isMove && !isResize)
-                        SetWindowPos(q->internalWinId(), 0, fs.x(), fs.y(), 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
+                    MoveWindow(q->internalWinId(), fs.x(), fs.y(), fs.width(), fs.height(), true);
                 }
                 if (!q->isVisible())
                     InvalidateRect(q->internalWinId(), 0, FALSE);
@@ -1524,6 +1522,11 @@ bool QWidgetPrivate::shouldShowMaximizeButton()
 {
     if (data.window_flags & Qt::MSWindowsFixedSizeDialogHint)
         return false;
+    // if the user explicitely asked for the maximize button, we try to add
+    // it even if the window has fixed size.
+    if (data.window_flags & Qt::CustomizeWindowHint &&
+        data.window_flags & Qt::WindowMaximizeButtonHint)
+        return true;
     if (extra) {
         if ((extra->maxw && extra->maxw != QWIDGETSIZE_MAX && extra->maxw != QLAYOUTSIZE_MAX)
             || (extra->maxh && extra->maxh != QWIDGETSIZE_MAX && extra->maxh != QLAYOUTSIZE_MAX))
diff --git a/src/gui/kernel/qx11embed_x11.cpp b/src/gui/kernel/qx11embed_x11.cpp
index 659331f..359434e 100644
--- a/src/gui/kernel/qx11embed_x11.cpp
+++ b/src/gui/kernel/qx11embed_x11.cpp
@@ -39,6 +39,7 @@
 **
 ****************************************************************************/
 
+#include "qplatformdefs.h"
 #include "qx11embed_x11.h"
 #include <qapplication.h>
 #include <qevent.h>
diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri
index d153215..4121be6 100644
--- a/src/gui/painting/painting.pri
+++ b/src/gui/painting/painting.pri
@@ -101,8 +101,8 @@ win32 {
                 painting/qcolormap_win.cpp \
                 painting/qpaintdevice_win.cpp \
                 painting/qprintengine_win.cpp \
-                painting/qprinterinfo_win.cpp \
-                painting/qregion_win.cpp
+                painting/qprinterinfo_win.cpp
+
         !win32-borland:!wince*:LIBS += -lmsimg32
 }
 
@@ -127,10 +127,6 @@ embedded {
         painting/qwindowsurface_raster.cpp \
 }
 
-wince* {
-        SOURCES -= painting/qregion_win.cpp
-}
-
 unix:x11 {
         HEADERS += \
                 painting/qpaintengine_x11_p.h
diff --git a/src/gui/painting/qbackingstore.cpp b/src/gui/painting/qbackingstore.cpp
index 405acb7..40c9bf2 100644
--- a/src/gui/painting/qbackingstore.cpp
+++ b/src/gui/painting/qbackingstore.cpp
@@ -39,6 +39,9 @@
 **
 ****************************************************************************/
 
+
+#include "qplatformdefs.h"
+
 #include "qbackingstore_p.h"
 
 #include <QtCore/qglobal.h>
diff --git a/src/gui/painting/qblendfunctions.cpp b/src/gui/painting/qblendfunctions.cpp
index 831d389..fc2eb60 100644
--- a/src/gui/painting/qblendfunctions.cpp
+++ b/src/gui/painting/qblendfunctions.cpp
@@ -223,8 +223,8 @@ void qt_scale_image_16bit(uchar *destPixels, int dbpl,
     int h = ty2 - ty1;
     int w = tx2 - tx1;
 
-    const int dstx = int((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix);
-    const int dsty = int((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy);
+    const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1;
+    const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1;
 
     quint32 basex = quint32((sx < 0 ? srcRect.right() : srcRect.left()) * 65536) + dstx;
     quint32 srcy = quint32((sy < 0 ? srcRect.bottom() : srcRect.top()) * 65536) + dsty;
@@ -723,8 +723,8 @@ template <typename T> void qt_scale_image_32bit(uchar *destPixels, int dbpl,
     int h = ty2 - ty1;
     int w = tx2 - tx1;
 
-    const int dstx = int((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix);
-    const int dsty = int((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy);
+    const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1;
+    const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1;
 
     quint32 basex = quint32((sx < 0 ? srcRect.right() : srcRect.left()) * 65536) + dstx;
     quint32 srcy = quint32((sy < 0 ? srcRect.bottom() : srcRect.top()) * 65536) + dsty;
diff --git a/src/gui/painting/qbrush.h b/src/gui/painting/qbrush.h
index 5479305..fdb3a8a 100644
--- a/src/gui/painting/qbrush.h
+++ b/src/gui/painting/qbrush.h
@@ -52,6 +52,15 @@
 #include <QtGui/qimage.h>
 #include <QtGui/qpixmap.h>
 
+#if defined(Q_OS_VXWORKS)
+#  if defined(m_data)
+#    undef m_data
+#  endif
+#  if defined(m_type)
+#    undef m_type
+#  endif
+#endif
+
 QT_BEGIN_HEADER
 
 QT_BEGIN_NAMESPACE
diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
index a70923d..d77ed57 100644
--- a/src/gui/painting/qdrawhelper.cpp
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -4954,30 +4954,60 @@ Q_STATIC_TEMPLATE_FUNCTION void blendTiled(int count, const QSpan *spans, void *
         if (sy < 0)
             sy += image_height;
 
-        while (length) {
-            int l = qMin(image_width - sx, length);
-            if (buffer_size < l)
-                l = buffer_size;
-
-            DST *dest = ((DST*)data->rasterBuffer->scanLine(spans->y)) + x;
-            const SRC *src = (SRC*)data->texture.scanLine(sy) + sx;
-            if (modeSource && coverage == 255) {
+        if (modeSource && coverage == 255) {
+            // Copy the first texture block
+            length = image_width;
+            while (length) {
+                int l = qMin(image_width - sx, length);
+                if (buffer_size < l)
+                    l = buffer_size;
+                DST *dest = ((DST*)data->rasterBuffer->scanLine(spans->y)) + x;
+                const SRC *src = (SRC*)data->texture.scanLine(sy) + sx;
                 qt_memconvert<DST, SRC>(dest, src, l);
-            } else if (sizeof(DST) == 3 && sizeof(SRC) == 3 && l >= 4 &&
-                       (quintptr(dest) & 3) == (quintptr(src) & 3))
-            {
-                blendUntransformed_dest24(dest, src, coverage, l);
-            } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
-                       (quintptr(dest) & 3) == (quintptr(src) & 3))
-            {
-                blendUntransformed_dest16(dest, src, coverage, l);
-            } else {
-                blendUntransformed_unaligned(dest, src, coverage, l);
+                length -= l;
+                sx = 0;
             }
 
-            x += l;
-            length -= l;
-            sx = 0;
+            // Now use the rasterBuffer as the source of the texture,
+            // We can now progressively copy larger blocks
+            // - Less cpu time in code figuring out what to copy
+            // We are dealing with one block of data
+            // - More likely to fit in the cache
+            // - can use memcpy
+            int copy_image_width = image_width;
+            length = spans->len - image_width;
+            DST *src = ((DST*)data->rasterBuffer->scanLine(spans->y)) + x;
+            DST *dest = src + copy_image_width;
+            while (copy_image_width < length) {
+                qt_memconvert(dest, src, copy_image_width);
+                dest += copy_image_width;
+                length -= copy_image_width;
+                copy_image_width *= 2;
+            }
+            qt_memconvert(dest, src, length);
+        } else {
+            while (length) {
+                int l = qMin(image_width - sx, length);
+                if (buffer_size < l)
+                    l = buffer_size;
+                DST *dest = ((DST*)data->rasterBuffer->scanLine(spans->y)) + x;
+                const SRC *src = (SRC*)data->texture.scanLine(sy) + sx;
+                if (sizeof(DST) == 3 && sizeof(SRC) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(src) & 3))
+                {
+                    blendUntransformed_dest24(dest, src, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(src) & 3))
+                {
+                    blendUntransformed_dest16(dest, src, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, src, coverage, l);
+                }
+
+                x += l;
+                length -= l;
+                sx = 0;
+            }
         }
         ++spans;
     }
diff --git a/src/gui/painting/qgrayraster.c b/src/gui/painting/qgrayraster.c
index 888fd9a..6ab7055 100644
--- a/src/gui/painting/qgrayraster.c
+++ b/src/gui/painting/qgrayraster.c
@@ -134,7 +134,9 @@
 
 #define ErrRaster_MemoryOverflow   -4
 
-
+#if defined(VXWORKS)
+#  include <vxWorksCommon.h>    /* needed for setjmp.h */
+#endif
 #include <string.h>             /* for qt_ft_memcpy() */
 #include <setjmp.h>
 #include <limits.h>
diff --git a/src/gui/painting/qoutlinemapper.cpp b/src/gui/painting/qoutlinemapper.cpp
index 401fad9..70125b9 100644
--- a/src/gui/painting/qoutlinemapper.cpp
+++ b/src/gui/painting/qoutlinemapper.cpp
@@ -198,32 +198,8 @@ void QOutlineMapper::endOutline()
                                           m_m22 * e.y() + m_m12 * e.x() + m_dy);
             }
         } else {
-            // ## TODO: this case needs to be plain code polygonal paths
-            QPainterPath path;
-            if (m_element_types.isEmpty()) {
-                if (!m_elements.isEmpty())
-                    path.moveTo(m_elements.at(0));
-                for (int i=1; i<m_elements.size(); ++i)
-                    path.lineTo(m_elements.at(i));
-            } else {
-                for (int i=0; i<m_elements.size(); ++i) {
-                    switch (m_element_types.at(i)) {
-                    case QPainterPath::MoveToElement:
-                        path.moveTo(m_elements.at(i));
-                        break;
-                    case QPainterPath::LineToElement:
-                        path.lineTo(m_elements.at(i));
-                        break;
-                    case QPainterPath::CurveToElement:
-                        path.cubicTo(m_elements.at(i), m_elements.at(i+1), m_elements.at(i+2));
-                        i += 2;
-                        break;
-                    default:
-                        Q_ASSERT(false);
-                        break;
-                    }
-                }
-            }
+            const QVectorPath vp((qreal *)m_elements.data(), m_elements.size(), m_element_types.data());
+            QPainterPath path = vp.convertToPainterPath();
             path = QTransform(m_m11, m_m12, m_m13, m_m21, m_m22, m_m23, m_dx, m_dy, m_m33).map(path);
             uint old_txop = m_txop;
             m_txop = QTransform::TxNone;
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 3d8e349..d9af3f6 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -1675,34 +1675,6 @@ void QRasterPaintEngine::drawRects(const QRectF *rects, int rectCount)
     QPaintEngineEx::drawRects(rects, rectCount);
 }
 
-void QRasterPaintEnginePrivate::strokeProjective(const QPainterPath &path)
-{
-    Q_Q(QRasterPaintEngine);
-    QRasterPaintEngineState *s = q->state();
-
-    const QPen &pen = s->lastPen;
-    QPainterPathStroker pathStroker;
-    pathStroker.setWidth(pen.width() == 0 ? qreal(1) : pen.width());
-    pathStroker.setCapStyle(pen.capStyle());
-    pathStroker.setJoinStyle(pen.joinStyle());
-    pathStroker.setMiterLimit(pen.miterLimit());
-    pathStroker.setDashOffset(pen.dashOffset());
-
-    if (qpen_style(pen) == Qt::CustomDashLine)
-        pathStroker.setDashPattern(pen.dashPattern());
-    else
-        pathStroker.setDashPattern(qpen_style(pen));
-
-    outlineMapper->setMatrix(QTransform());
-    const QPainterPath stroke = pen.isCosmetic()
-        ? pathStroker.createStroke(s->matrix.map(path))
-        : s->matrix.map(pathStroker.createStroke(path));
-
-    rasterize(outlineMapper->convertPath(stroke), s->penData.blend, &s->penData, rasterBuffer);
-    outlinemapper_xform_dirty = true;
-}
-
-
 
 /*!
     \internal
@@ -1767,6 +1739,8 @@ void QRasterPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
         const QLineF *lines = reinterpret_cast<const QLineF *>(path.points());
 
         for (int i = 0; i < lineCount; ++i) {
+            if (path.shape() == QVectorPath::LinesHint)
+                dashOffset = s->lastPen.dashOffset();
             if (lines[i].p1() == lines[i].p2()) {
                 if (s->lastPen.capStyle() != Qt::FlatCap) {
                     QPointF p = lines[i].p1();
@@ -1972,67 +1946,6 @@ void QRasterPaintEngine::fillRect(const QRectF &r, const QColor &color)
     fillRect(r, &d->solid_color_filler);
 }
 
-/*!
-    \reimp
-*/
-void QRasterPaintEngine::drawPath(const QPainterPath &path)
-{
-#ifdef QT_DEBUG_DRAW
-    QRectF bounds = path.boundingRect();
-    qDebug(" - QRasterPaintEngine::drawPath(), [%.2f, %.2f, %.2f, %.2f]",
-           bounds.x(), bounds.y(), bounds.width(), bounds.height());
-#endif
-
-    if (path.isEmpty())
-        return;
-
-    // Filling..,
-    Q_D(QRasterPaintEngine);
-    QRasterPaintEngineState *s = state();
-
-    ensureBrush();
-    if (s->brushData.blend) {
-        ensureOutlineMapper();
-        fillPath(path, &s->brushData);
-    }
-
-    // Stroking...
-    ensurePen();
-    if (!s->penData.blend)
-        return;
-    {
-        if (s->matrix.type() >= QTransform::TxProject) {
-            d->strokeProjective(path);
-        } else {
-            Q_ASSERT(s->stroker);
-            d->outlineMapper->beginOutline(Qt::WindingFill);
-            qreal txscale = 1;
-            if (s->pen.isCosmetic() || (qt_scaleForTransform(s->matrix, &txscale) && txscale != 1)) {
-                const qreal strokeWidth = d->basicStroker.strokeWidth();
-                const QRectF clipRect = d->dashStroker ? d->dashStroker->clipRect() : QRectF();
-                if (d->dashStroker)
-                    d->dashStroker->setClipRect(d->deviceRect);
-                d->basicStroker.setStrokeWidth(strokeWidth * txscale);
-                d->outlineMapper->setMatrix(QTransform());
-                s->stroker->strokePath(path, d->outlineMapper, s->matrix);
-                d->outlinemapper_xform_dirty = true;
-                d->basicStroker.setStrokeWidth(strokeWidth);
-                if (d->dashStroker)
-                    d->dashStroker->setClipRect(clipRect);
-            } else {
-                ensureOutlineMapper();
-                s->stroker->strokePath(path, d->outlineMapper, QTransform());
-            }
-            d->outlineMapper->endOutline();
-
-            ProcessSpans blend = d->getPenFunc(d->outlineMapper->controlPointRect,
-                    &s->penData);
-            d->rasterize(d->outlineMapper->outline(), blend, &s->penData, d->rasterBuffer);
-        }
-    }
-
-}
-
 static inline bool isAbove(const QPointF *a, const QPointF *b)
 {
     return a->y() < b->y();
@@ -3546,8 +3459,8 @@ void QRasterPaintEngine::drawLines(const QLine *lines, int lineCount)
         int m22 = int(s->matrix.m22());
         int dx = qFloor(s->matrix.dx() + aliasedCoordinateDelta);
         int dy = qFloor(s->matrix.dy() + aliasedCoordinateDelta);
-        int dashOffset = int(s->lastPen.dashOffset());
         for (int i=0; i<lineCount; ++i) {
+            int dashOffset = int(s->lastPen.dashOffset());
             if (s->flags.int_xform) {
                 const QLine &l = lines[i];
                 int x1 = l.x1() * m11 + dx;
@@ -3646,8 +3559,8 @@ void QRasterPaintEngine::drawLines(const QLineF *lines, int lineCount)
                             ? LineDrawNormal
                             : LineDrawIncludeLastPixel;
 
-        int dashOffset = int(s->lastPen.dashOffset());
         for (int i=0; i<lineCount; ++i) {
+            int dashOffset = int(s->lastPen.dashOffset());
             QLineF line = (lines[i] * s->matrix).translated(aliasedCoordinateDelta, aliasedCoordinateDelta);
             const QRectF brect(QPointF(line.x1(), line.y1()),
                                QPointF(line.x2(), line.y2()));
diff --git a/src/gui/painting/qpaintengine_raster_p.h b/src/gui/painting/qpaintengine_raster_p.h
index 283c442..3dab491 100644
--- a/src/gui/painting/qpaintengine_raster_p.h
+++ b/src/gui/painting/qpaintengine_raster_p.h
@@ -165,7 +165,6 @@ public:
 
     void updateMatrix(const QTransform &matrix);
 
-    void drawPath(const QPainterPath &path);
     void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
     void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode);
     void fillPath(const QPainterPath &path, QSpanData *fillData);
@@ -327,7 +326,6 @@ public:
 
     inline const QClipData *clip() const;
 
-    void strokeProjective(const QPainterPath &path);
     void initializeRasterizer(QSpanData *data);
 
     void recalculateFastImages();
diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp
index a71fe52..81dce4f 100644
--- a/src/gui/painting/qpaintengineex.cpp
+++ b/src/gui/painting/qpaintengineex.cpp
@@ -42,6 +42,7 @@
 #include "qpaintengineex_p.h"
 #include "qpainter_p.h"
 #include "qstroker_p.h"
+#include "qbezier_p.h"
 #include <private/qpainterpath_p.h>
 
 #include <qvarlengtharray.h>
@@ -91,6 +92,40 @@ QRectF QVectorPath::controlPointRect() const
     return QRectF(QPointF(m_cp_rect.x1, m_cp_rect.y1), QPointF(m_cp_rect.x2, m_cp_rect.y2));
 }
 
+QPainterPath QVectorPath::convertToPainterPath() const
+{
+    QPainterPath path;
+
+    if (m_count == 0)
+        return path;
+
+    const QPointF *points = (const QPointF *) m_points;
+
+    if (m_elements) {
+        for (int i=0; i<m_count; ++i) {
+            switch (m_elements[i]) {
+            case QPainterPath::MoveToElement:
+                path.moveTo(points[i]);
+                break;
+            case QPainterPath::LineToElement:
+                path.lineTo(points[i]);
+                break;
+            case QPainterPath::CurveToElement:
+                path.cubicTo(points[i], points[i+1], points[i+2]);
+                break;
+            default:
+                break;
+            }
+        }
+    } else {
+        path.moveTo(points[0]);
+        for (int i=1; i<m_count; ++i)
+            path.lineTo(points[i]);
+    }
+
+    return path;
+}
+
 const QVectorPath &qtVectorPathForPath(const QPainterPath &path)
 {
     Q_ASSERT(path.d_func());
@@ -384,7 +419,6 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
 
     const qreal *lastPoint = points + (pointCount<<1);
 
-    d->activeStroker->begin(d->strokeHandler);
     d->strokeHandler->types.reset();
     d->strokeHandler->pts.reset();
 
@@ -393,13 +427,13 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
     if (d->stroker.capStyle() == Qt::RoundCap || d->stroker.joinStyle() == Qt::RoundJoin)
         flags |= QVectorPath::CurvedShapeHint;
 
-    // ### Perspective Xforms are currently not supported...
     qreal txscale = 1;
     if (!(pen.isCosmetic() || (qt_scaleForTransform(state()->matrix, &txscale) && txscale != 1))) {
         // We include cosmetic pens in this case to avoid having to
         // change the current transform. Normal transformed,
         // non-cosmetic pens will be transformed as part of fill
         // later, so they are also covered here..
+        d->activeStroker->begin(d->strokeHandler);
         if (types) {
             while (points < lastPoint) {
                 switch (*types) {
@@ -448,69 +482,75 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
         QVectorPath strokePath(d->strokeHandler->pts.data(),
                                d->strokeHandler->types.size(),
                                d->strokeHandler->types.data(),
-                               QVectorPath::WindingFill);
+                               flags);
         fill(strokePath, pen.brush());
     } else {
         const qreal strokeWidth = d->stroker.strokeWidth();
         d->stroker.setStrokeWidth(strokeWidth * txscale);
         // For cosmetic pens we need a bit of trickery... We to process xform the input points
-        if (types) {
-            while (points < lastPoint) {
-                switch (*types) {
-                case QPainterPath::MoveToElement: {
-                    QPointF pt = (*(QPointF *) points) * state()->matrix;
-                    d->activeStroker->moveTo(pt.x(), pt.y());
-                    points += 2;
-                    ++types;
-                    break;
+        if (state()->matrix.type() >= QTransform::TxProject) {
+            QPainterPath painterPath = state()->matrix.map(path.convertToPainterPath());
+            d->activeStroker->strokePath(painterPath, d->strokeHandler, QTransform());
+        } else {
+            d->activeStroker->begin(d->strokeHandler);
+            if (types) {
+                while (points < lastPoint) {
+                    switch (*types) {
+                    case QPainterPath::MoveToElement: {
+                        QPointF pt = (*(QPointF *) points) * state()->matrix;
+                        d->activeStroker->moveTo(pt.x(), pt.y());
+                        points += 2;
+                        ++types;
+                        break;
+                    }
+                    case QPainterPath::LineToElement: {
+                        QPointF pt = (*(QPointF *) points) * state()->matrix;
+                        d->activeStroker->lineTo(pt.x(), pt.y());
+                        points += 2;
+                        ++types;
+                        break;
+                    }
+                    case QPainterPath::CurveToElement: {
+                        QPointF c1 = ((QPointF *) points)[0] * state()->matrix;
+                        QPointF c2 = ((QPointF *) points)[1] * state()->matrix;
+                        QPointF e =  ((QPointF *) points)[2] * state()->matrix;
+                        d->activeStroker->cubicTo(c1.x(), c1.y(), c2.x(), c2.y(), e.x(), e.y());
+                        points += 6;
+                        types += 3;
+                        flags |= QVectorPath::CurvedShapeHint;
+                        break;
+                    }
+                    default:
+                        break;
+                    }
                 }
-                case QPainterPath::LineToElement: {
-                    QPointF pt = (*(QPointF *) points) * state()->matrix;
+                if (path.hasImplicitClose()) {
+                    QPointF pt = * ((QPointF *) path.points()) * state()->matrix;
                     d->activeStroker->lineTo(pt.x(), pt.y());
-                    points += 2;
-                    ++types;
-                    break;
                 }
-                case QPainterPath::CurveToElement: {
-                    QPointF c1 = ((QPointF *) points)[0] * state()->matrix;
-                    QPointF c2 = ((QPointF *) points)[1] * state()->matrix;
-                    QPointF e =  ((QPointF *) points)[2] * state()->matrix;
-                    d->activeStroker->cubicTo(c1.x(), c1.y(), c2.x(), c2.y(), e.x(), e.y());
-                    points += 6;
-                    types += 3;
-                    flags |= QVectorPath::CurvedShapeHint;
-                    break;
-                }
-                default:
-                    break;
-                }
-            }
-            if (path.hasImplicitClose()) {
-                QPointF pt = * ((QPointF *) path.points()) * state()->matrix;
-                d->activeStroker->lineTo(pt.x(), pt.y());
-            }
 
-        } else {
-            QPointF p = ((QPointF *)points)[0] * state()->matrix;
-            d->activeStroker->moveTo(p.x(), p.y());
-            points += 2;
-            ++types;
-            while (points < lastPoint) {
+            } else {
                 QPointF p = ((QPointF *)points)[0] * state()->matrix;
-                d->activeStroker->lineTo(p.x(), p.y());
+                d->activeStroker->moveTo(p.x(), p.y());
                 points += 2;
                 ++types;
+                while (points < lastPoint) {
+                    QPointF p = ((QPointF *)points)[0] * state()->matrix;
+                    d->activeStroker->lineTo(p.x(), p.y());
+                    points += 2;
+                    ++types;
+                }
+                if (path.hasImplicitClose())
+                    d->activeStroker->lineTo(p.x(), p.y());
             }
-            if (path.hasImplicitClose())
-                d->activeStroker->lineTo(p.x(), p.y());
+            d->activeStroker->end();
         }
 
-        d->activeStroker->end();
         d->stroker.setStrokeWidth(strokeWidth);
         QVectorPath strokePath(d->strokeHandler->pts.data(),
                                d->strokeHandler->types.size(),
                                d->strokeHandler->types.data(),
-                               QVectorPath::WindingFill);
+                               flags);
 
         QTransform xform = state()->matrix;
         state()->matrix = QTransform();
diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp
index b5301d1..f9fd61e 100644
--- a/src/gui/painting/qpainterpath.cpp
+++ b/src/gui/painting/qpainterpath.cpp
@@ -3280,6 +3280,8 @@ void QPainterPath::setDirty(bool dirty)
 {
     d_func()->dirtyBounds        = dirty;
     d_func()->dirtyControlBounds = dirty;
+    delete d_func()->pathConverter;
+    d_func()->pathConverter = 0;
 }
 
 void QPainterPath::computeBoundingRect() const
diff --git a/src/gui/painting/qregion.cpp b/src/gui/painting/qregion.cpp
index 7289a6b..47d24b3 100644
--- a/src/gui/painting/qregion.cpp
+++ b/src/gui/painting/qregion.cpp
@@ -49,7 +49,7 @@
 
 #include <qdebug.h>
 
-#if defined(Q_OS_UNIX) || defined(Q_OS_WINCE)
+#if defined(Q_OS_UNIX) || defined(Q_WS_WIN)
 #include "qimage.h"
 #include "qbitmap.h"
 #include <stdlib.h>
@@ -545,7 +545,7 @@ QRegion& QRegion::operator|=(const QRegion &r)
 
     \sa intersected()
 */
-#if !defined (Q_OS_UNIX) && !defined (Q_OS_WINCE)
+#if !defined (Q_OS_UNIX) && !defined (Q_WS_WIN)
 QRegion& QRegion::operator+=(const QRect &r)
 {
     return operator+=(QRegion(r));
@@ -561,16 +561,14 @@ QRegion& QRegion::operator+=(const QRect &r)
 
   \sa intersected()
 */
-#if !defined(Q_WS_WIN) || defined(Q_OS_WINCE)
 QRegion& QRegion::operator&=(const QRegion &r)
     { return *this = *this & r; }
-#endif
 
 /*!
    \overload
    \since 4.4
  */
-#if defined (Q_OS_UNIX) || defined (Q_OS_WINCE)
+#if defined (Q_OS_UNIX) || defined (Q_WS_WIN)
 QRegion& QRegion::operator&=(const QRect &r)
 {
     return *this = *this & r;
@@ -591,10 +589,8 @@ QRegion& QRegion::operator&=(const QRect &r)
 
   \sa subtracted()
 */
-#if !defined(Q_WS_WIN) || defined(Q_OS_WINCE)
 QRegion& QRegion::operator-=(const QRegion &r)
     { return *this = *this - r; }
-#endif
 
 /*!
     Applies the xored() function to this region and \a r and
@@ -731,7 +727,7 @@ bool QRegion::intersects(const QRect &rect) const
     return false;
 }
 
-#if !defined (Q_OS_UNIX) && !defined (Q_OS_WINCE)
+#if !defined (Q_OS_UNIX) && !defined (Q_WS_WIN)
 /*!
     \overload
     \since 4.4
@@ -1086,7 +1082,7 @@ Q_AUTOTEST_EXPORT QPainterPath qt_regionToPath(const QRegion &region)
     return result;
 }
 
-#if defined(Q_OS_UNIX) || defined(Q_OS_WINCE)
+#if defined(Q_OS_UNIX) || defined(Q_WS_WIN)
 
 //#define QT_REGION_DEBUG
 /*
@@ -1627,9 +1623,9 @@ QT_END_INCLUDE_NAMESPACE
 QT_BEGIN_INCLUDE_NAMESPACE
 # include "qregion_mac.cpp"
 QT_END_INCLUDE_NAMESPACE
-#elif defined(Q_OS_WINCE)
+#elif defined(Q_WS_WIN)
 QT_BEGIN_INCLUDE_NAMESPACE
-# include "qregion_wince.cpp"
+# include "qregion_win.cpp"
 QT_END_INCLUDE_NAMESPACE
 #elif defined(Q_WS_QWS)
 static QRegionPrivate qrp;
@@ -3846,7 +3842,7 @@ QRegion::QRegion(const QRect &r, RegionType t)
 #if defined(Q_WS_X11)
         d->rgn = 0;
         d->xrectangles = 0;
-#elif defined(Q_OS_WINCE)
+#elif defined(Q_WS_WIN)
         d->rgn = 0;
 #endif
         if (t == Rectangle) {
@@ -3868,7 +3864,7 @@ QRegion::QRegion(const QPolygon &a, Qt::FillRule fillRule)
 #if defined(Q_WS_X11)
         d->rgn = 0;
         d->xrectangles = 0;
-#elif defined(Q_OS_WINCE)
+#elif defined(Q_WS_WIN)
         d->rgn = 0;
 #endif
         d->qt_rgn = PolygonRegion(a.constData(), a.size(),
@@ -3898,7 +3894,7 @@ QRegion::QRegion(const QBitmap &bm)
 #if defined(Q_WS_X11)
         d->rgn = 0;
         d->xrectangles = 0;
-#elif defined(Q_OS_WINCE)
+#elif defined(Q_WS_WIN)
         d->rgn = 0;
 #endif
         d->qt_rgn = qt_bitmapToRegion(bm);
@@ -3913,7 +3909,7 @@ void QRegion::cleanUp(QRegion::QRegionData *x)
         XDestroyRegion(x->rgn);
     if (x->xrectangles)
         free(x->xrectangles);
-#elif defined(Q_OS_WINCE)
+#elif defined(Q_WS_WIN)
     if (x->rgn)
         qt_win_dispose_rgn(x->rgn);
 #endif
@@ -3948,7 +3944,7 @@ QRegion QRegion::copy() const
 #if defined(Q_WS_X11)
     x->rgn = 0;
     x->xrectangles = 0;
-#elif defined(Q_OS_WINCE)
+#elif defined(Q_WS_WIN)
     x->rgn = 0;
 #endif
     if (d->qt_rgn)
diff --git a/src/gui/painting/qregion.h b/src/gui/painting/qregion.h
index 61a0623..8a56d54 100644
--- a/src/gui/painting/qregion.h
+++ b/src/gui/painting/qregion.h
@@ -59,7 +59,7 @@ QT_MODULE(Gui)
 template <class T> class QVector;
 class QVariant;
 
-#if defined(Q_WS_QWS) || defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_OS_WINCE) || defined(Q_OS_SYMBIAN)
+#if defined(Q_WS_QWS) || defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_WIN) || defined(Q_OS_SYMBIAN)
 struct QRegionPrivate;
 #endif
 
@@ -148,6 +148,7 @@ public:
 #elif defined(Q_WS_MAC)
 #if defined Q_WS_MAC32
     RgnHandle toQDRgn() const;
+    RgnHandle toQDRgnForUpdate_sys() const;
     static QRegion fromQDRgn(RgnHandle shape);
 #endif
 #ifdef QT_MAC_USE_COCOA
@@ -199,7 +200,7 @@ private:
 #elif defined(Q_WS_MAC) && !defined(QT_MAC_USE_COCOA)
         mutable RgnHandle unused; // Here for binary compatability reasons. ### Qt 5 remove.
 #endif
-#if defined(Q_WS_QWS) || defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_OS_WINCE) || defined(Q_OS_SYMBIAN)
+#if defined(Q_WS_QWS) || defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_WIN) || defined(Q_OS_SYMBIAN)
         QRegionPrivate *qt_rgn;
 #endif
     };
diff --git a/src/gui/painting/qregion_mac.cpp b/src/gui/painting/qregion_mac.cpp
index b57f234..9b0e99f 100644
--- a/src/gui/painting/qregion_mac.cpp
+++ b/src/gui/painting/qregion_mac.cpp
@@ -155,6 +155,44 @@ RgnHandle QRegion::toQDRgn() const
     }
     return rgnHandle;
 }
+
+/*!
+    \internal
+     Create's a RegionHandle, it's the caller's responsibility to release.
+     Returns 0 if the QRegion overflows.
+*/
+RgnHandle QRegion::toQDRgnForUpdate_sys() const
+{
+    RgnHandle rgnHandle = qt_mac_get_rgn();
+    if(d->qt_rgn && d->qt_rgn->numRects) {
+        RgnHandle tmp_rgn = qt_mac_get_rgn();
+        int n = d->qt_rgn->numRects;
+        const QRect *qt_r = (n == 1) ? &d->qt_rgn->extents : d->qt_rgn->rects.constData();
+        while (n--) {
+
+            // detect overflow. Tested for use with HIViewSetNeedsDisplayInRegion
+            // in QWidgetPrivate::update_sys().
+            enum { HIViewSetNeedsDisplayInRegionOverflow = 10000 }; // empirically determined conservative value
+            qDebug() << qt_r->x() << qt_r->y() << qt_r->right() << qt_r->bottom();
+            if (qt_r->right() > HIViewSetNeedsDisplayInRegionOverflow || qt_r->bottom() > HIViewSetNeedsDisplayInRegionOverflow) {
+                qt_mac_dispose_rgn(tmp_rgn);
+                qt_mac_dispose_rgn(rgnHandle);
+                return 0;
+            }
+
+            SetRectRgn(tmp_rgn,
+                       qMax(SHRT_MIN, qt_r->x()),
+                       qMax(SHRT_MIN, qt_r->y()),
+                       qMin(SHRT_MAX, qt_r->right() + 1),
+                       qMin(SHRT_MAX, qt_r->bottom() + 1));
+            UnionRgn(rgnHandle, tmp_rgn, rgnHandle);
+            ++qt_r;
+        }
+        qt_mac_dispose_rgn(tmp_rgn);
+    }
+    return rgnHandle;
+}
+
 #endif
 
 #if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
diff --git a/src/gui/painting/qregion_win.cpp b/src/gui/painting/qregion_win.cpp
index 249b1a6..2d5e76b 100644
--- a/src/gui/painting/qregion_win.cpp
+++ b/src/gui/painting/qregion_win.cpp
@@ -39,27 +39,25 @@
 **
 ****************************************************************************/
 
+#include "qatomic.h"
 #include "qbitmap.h"
 #include "qbuffer.h"
 #include "qimage.h"
 #include "qpolygon.h"
 #include "qregion.h"
 #include "qt_windows.h"
+#include "qpainterpath.h"
+#include "qguifunctions_wince.h"
 
 QT_BEGIN_NAMESPACE
 
+QRegion::QRegionData QRegion::shared_empty = { Q_BASIC_ATOMIC_INITIALIZER(1), 0, 0 };
 
-/*
-    In Windows versions before Windows Vista CreateRectRgn - when called in a multi-threaded
-    environment - might return an invalid handle. This function works around this limitation
-    by verifying the handle with a quick GetRegionData() call and re-creates the region
-    if necessary.
-*/
 HRGN qt_tryCreateRegion(QRegion::RegionType type, int left, int top, int right, int bottom)
 {
     const int tries = 10;
     for (int i = 0; i < tries; ++i) {
-        HRGN region = 0;
+        HRGN region;
         switch (type) {
         case QRegion::Rectangle:
             region = CreateRectRgn(left, top, right, bottom);
@@ -80,497 +78,73 @@ HRGN qt_tryCreateRegion(QRegion::RegionType type, int left, int top, int right,
     return 0;
 }
 
-#ifndef Q_OS_WINCE
-HRGN qt_tryCreatePolygonRegion(const QPolygon &a, Qt::FillRule fillRule)
-{
-    const int tries = 10;
-    for (int i = 0; i < tries; ++i) {
-        HRGN region = CreatePolygonRgn(reinterpret_cast<const POINT*>(a.data()), a.size(),
-                                       fillRule == Qt::OddEvenFill ? ALTERNATE : WINDING);
-        if (region) {
-            if (GetRegionData(region, 0, 0))
-                return region;
-            else
-                DeleteObject(region);
-        }
-    }
-    return 0;
-}
-#endif
-
-QRegion::QRegionData QRegion::shared_empty = { Q_BASIC_ATOMIC_INITIALIZER(1), 0 };
-
-QRegion::QRegion()
-    : d(&shared_empty)
-{
-    d->ref.ref();
-}
-
-#ifndef Q_OS_WINCE //implementation for WindowsCE in qregion_wce.cpp
-QRegion::QRegion(const QRect &r, RegionType t)
-{
-    if (r.isEmpty()) {
-        d = &shared_empty;
-        d->ref.ref();
-    } else {
-        d = new QRegionData;
-        d->ref = 1;
-        if (t == Rectangle)
-            d->rgn = qt_tryCreateRegion(t, r.left(), r.top(), r.x() + r.width(), r.y() + r.height());
-        else if (t == Ellipse) {
-            // need to add 1 to width/height for the ellipse to have correct boundingrect.
-            d->rgn = qt_tryCreateRegion(t, r.x(), r.y(), r.x() + r.width() + 1, r.y() + r.height() + 1);
-        }
-    }
-}
-#endif
-
-#ifndef Q_OS_WINCE //implementation for WindowsCE in qregion_wce.cpp
-QRegion::QRegion(const QPolygon &a, Qt::FillRule fillRule)
-{
-    if (a.size() < 3) {
-        d = &shared_empty;
-        d->ref.ref();
-    } else {
-        d = new QRegionData;
-        d->ref = 1;
-        d->rgn = qt_tryCreatePolygonRegion(a, fillRule);
-    }
-}
-#endif
-
-QRegion::QRegion(const QRegion &r)
-{
-    d = r.d;
-    d->ref.ref();
-}
-
-HRGN qt_win_bitmapToRegion(const QBitmap& bitmap)
-{
-    HRGN region=0;
-    QImage image = bitmap.toImage();
-    const int MAXRECT = 256;
-    struct RData {
-        RGNDATAHEADER header;
-        RECT rect[MAXRECT];
-    };
-    RData data;
-
-#define FlushSpans \
-    { \
-                data.header.dwSize = sizeof(RGNDATAHEADER); \
-                data.header.iType = RDH_RECTANGLES; \
-                data.header.nCount = n; \
-                data.header.nRgnSize = 0; \
-                data.header.rcBound.bottom = y; \
-                HRGN r = ExtCreateRegion(0, \
-                    sizeof(RGNDATAHEADER)+n*sizeof(RECT),(RGNDATA*)&data); \
-                if (region) { \
-                    CombineRgn(region, region, r, RGN_OR); \
-                    DeleteObject(r); \
-                } else { \
-                    region = r; \
-                } \
-                data.header.rcBound.top = y; \
-        }
-
-#define AddSpan \
-        { \
-            data.rect[n].left=prev1; \
-            data.rect[n].top=y; \
-            data.rect[n].right=x-1+1; \
-            data.rect[n].bottom=y+1; \
-            n++; \
-            if (n == MAXRECT) { \
-                FlushSpans \
-                n=0; \
-            } \
-        }
-
-    data.header.rcBound.top = 0;
-    data.header.rcBound.left = 0;
-    data.header.rcBound.right = image.width()-1;
-    int n = 0;
-
-    int zero = 0x00;
-
-    int x, y;
-    for (y = 0; y < image.height(); ++y) {
-        uchar *line = image.scanLine(y);
-        int w = image.width();
-        uchar all=zero;
-        int prev1 = -1;
-        for (x = 0; x < w;) {
-            uchar byte = line[x/8];
-            if (x > w - 8 || byte != all) {
-                for (int b = 8; b > 0 && x < w; --b) {
-                    if (!(byte & 0x01) == !all) {
-                        // More of the same
-                    } else {
-                        // A change.
-                        if (all != zero) {
-                            AddSpan;
-                            all = zero;
-                        } else {
-                            prev1 = x;
-                            all = ~zero;
-                        }
-                    }
-                    byte >>= 1;
-                    ++x;
-                }
-            } else {
-                x += 8;
-            }
-        }
-        if (all != zero) {
-            AddSpan;
-        }
-    }
-    if (n) {
-        FlushSpans;
-    }
-
-    if (!region) {
-        // Surely there is some better way.
-        region = qt_tryCreateRegion(QRegion::Rectangle, 0,0,1,1);
-        CombineRgn(region, region, region, RGN_XOR);
-    }
-    return region;
-}
-
-#ifndef Q_OS_WINCE //implementation for WindowsCE in qregion_wce.cpp
-QRegion::QRegion(const QBitmap &bm)
-{
-    if (bm.isNull()) {
-        d = &shared_empty;
-        d->ref.ref();
-    } else {
-        d = new QRegionData;
-        d->ref = 1;
-        d->rgn = qt_win_bitmapToRegion(bm);
-    }
-}
-#endif
-
-void QRegion::cleanUp(QRegion::QRegionData *x)
-{
-    if (x->rgn)
-        DeleteObject(x->rgn);
-    delete x;
-}
-
-QRegion::~QRegion()
-{
-    if (!d->ref.deref())
-        cleanUp(d);
-}
-
-QRegion &QRegion::operator=(const QRegion &r)
-{
-    r.d->ref.ref();
-    if (!d->ref.deref())
-        cleanUp(d);
-    d = r.d;
-    return *this;
-}
-
-
-QRegion QRegion::copy() const
-{
-    QRegion r;
-    QRegionData *x = new QRegionData;
-    x->ref = 1;
-    if (d->rgn) {
-        x->rgn = qt_tryCreateRegion(QRegion::Rectangle, 0, 0, 2, 2);
-        CombineRgn(x->rgn, d->rgn, 0, RGN_COPY);
-    } else {
-        x->rgn = 0;
-    }
-    if (!r.d->ref.deref())
-        cleanUp(r.d);
-    r.d = x;
-    return r;
-}
-
-bool QRegion::isEmpty() const
-{
-    return (d == &shared_empty || boundingRect().isEmpty());
-}
-
-
-bool QRegion::contains(const QPoint &p) const
-{
-    return d->rgn ? PtInRegion(d->rgn, p.x(), p.y()) : false;
-}
-
-bool QRegion::contains(const QRect &r) const
-{
-    if (!d->rgn)
-        return false;
-    RECT rect;
-    SetRect(&rect, r.left(), r.top(), r.right(), r.bottom());
-    return RectInRegion(d->rgn, &rect);
-}
-
-
-void QRegion::translate(int dx, int dy)
-{
-    if (!d->rgn || (dx == 0 && dy == 0))
-        return;
-    detach();
-    OffsetRgn(d->rgn, dx, dy);
-}
-
-
-#define RGN_NOP -1
-
-// Duplicates of those in qregion.cpp
-#define QRGN_OR               6
-#define QRGN_AND              7
-#define QRGN_SUB              8
-#define QRGN_XOR              9
-
-/*
-  Performs the actual OR, AND, SUB and XOR operation between regions.
-  Sets the resulting region handle to 0 to indicate an empty region.
-*/
-
-QRegion QRegion::winCombine(const QRegion &r, int op) const
+QRegion qt_region_from_HRGN(HRGN rgn)
 {
-    int both=RGN_NOP,
-        left=RGN_NOP,
-        right=RGN_NOP;
-    switch (op) {
-        case QRGN_OR:
-            both = RGN_OR;
-            left = right = RGN_COPY;
-            break;
-        case QRGN_AND:
-            both = RGN_AND;
-            break;
-        case QRGN_SUB:
-            both = RGN_DIFF;
-            left = RGN_COPY;
-            break;
-        case QRGN_XOR:
-            both = RGN_XOR;
-            left = right = RGN_COPY;
-            break;
-        default:
-            qWarning("QRegion: Internal error in winCombine");
-    }
-
-    int allCombineRgnResults = NULLREGION;
-    QRegion result;
-    result.detach();
-    result.d->rgn = qt_tryCreateRegion(QRegion::Rectangle, 0, 0, 0, 0);
-    if (d->rgn && r.d->rgn)
-        allCombineRgnResults = CombineRgn(result.d->rgn, d->rgn, r.d->rgn, both);
-    else if (d->rgn && left != RGN_NOP)
-        allCombineRgnResults = CombineRgn(result.d->rgn, d->rgn, d->rgn, left);
-    else if (r.d->rgn && right != RGN_NOP)
-        allCombineRgnResults = CombineRgn(result.d->rgn, r.d->rgn, r.d->rgn, right);
-
-    if (allCombineRgnResults == NULLREGION || allCombineRgnResults == ERROR)
-        result = QRegion();
-
-    //##### do not delete this. A null pointer is different from an empty region in SelectClipRgn in qpainter_win! (M)
-//     if (allCombineRgnResults == NULLREGION) {
-//         if (result.data->rgn)
-//             DeleteObject(result.data->rgn);
-//         result.data->rgn = 0;                        // empty region
-//     }
-    return result;
-}
-
-QRegion QRegion::unite(const QRegion &r) const
-{
-    if (!d->rgn)
-        return r;
-    if (!r.d->rgn)
-        return *this;
-    return winCombine(r, QRGN_OR);
-}
-
-QRegion QRegion::unite(const QRect &r) const
-{
-    return unite(QRegion(r));
-}
-
-QRegion QRegion::intersect(const QRegion &r) const
-{
-    if (!r.d->rgn || !d->rgn)
-        return QRegion();
-     return winCombine(r, QRGN_AND);
-}
-
-QRegion QRegion::subtract(const QRegion &r) const
-{
-    if (!r.d->rgn || !d->rgn)
-        return *this;
-    return winCombine(r, QRGN_SUB);
-}
-
-QRegion QRegion::eor(const QRegion &r) const
-{
-    if (!d->rgn)
-        return r;
-    if (!r.d->rgn)
-        return *this;
-    return winCombine(r, QRGN_XOR);
-}
-
-
-QRect QRegion::boundingRect() const
-{
-    if (!d->rgn)
-        return QRect();
-    RECT r;
-    if (GetRgnBox(d->rgn, &r) == NULLREGION)
-        return QRect();
-    else
-        return QRect(r.left, r.top, r.right - r.left, r.bottom - r.top);
-}
-
-QVector<QRect> QRegion::rects() const
-{
-    if (d->rgn == 0)
-        return QVector<QRect>();
-
-    int numBytes = GetRegionData(d->rgn, 0, 0);
+    int numBytes = GetRegionData(rgn, 0, 0);
     if (numBytes == 0)
-        return QVector<QRect>();
+        return QRegion();
 
     char *buf = new char[numBytes];
     if (buf == 0)
-        return QVector<QRect>();
+        return QRegion();
 
     RGNDATA *rd = reinterpret_cast<RGNDATA*>(buf);
-    if (GetRegionData(d->rgn, numBytes, rd) == 0) {
+    if (GetRegionData(rgn, numBytes, rd) == 0) {
         delete [] buf;
-        return QVector<QRect>();
+        return QRegion();
     }
 
-    QVector<QRect> a(rd->rdh.nCount);
+    QRegion region;
     RECT *r = reinterpret_cast<RECT*>(rd->Buffer);
-    for (int i = 0; i < a.size(); ++i) {
-        a[i].setCoords(r->left, r->top, r->right - 1, r->bottom - 1);
+    for (int i = 0; i < rd->rdh.nCount; ++i) {
+        QRect rect;
+        rect.setCoords(r->left, r->top, r->right - 1, r->bottom - 1);
         ++r;
+        region |= rect;
     }
 
     delete [] buf;
-    return a;
-}
-
-void QRegion::setRects(const QRect *rects, int num)
-{
-    *this = QRegion();
-    if (!rects || num == 0 || (num == 1 && rects->isEmpty()))
-        return;
-    for (int i = 0; i < num; ++i)
-        *this |= rects[i];
-}
-
-int QRegion::numRects() const
-{
-    if (d->rgn == 0)
-        return 0;
-
-    const int numBytes = GetRegionData(d->rgn, 0, 0);
-    if (numBytes == 0)
-        return 0;
-
-    char *buf = new char[numBytes];
-    if (buf == 0)
-        return 0;
-
-    RGNDATA *rd = reinterpret_cast<RGNDATA*>(buf);
-    if (GetRegionData(d->rgn, numBytes, rd) == 0) {
-        delete[] buf;
-        return 0;
-    }
-
-    const int n = rd->rdh.nCount;
-    delete[] buf;
 
-    return n;
+    return region;
 }
 
-bool QRegion::operator==(const QRegion &r) const
+void qt_win_dispose_rgn(HRGN r)
 {
-    if (d == r.d)
-        return true;
-    if ((d->rgn == 0) ^ (r.d->rgn == 0)) // one is empty, not both
-        return false;
-    return d->rgn == 0 ? true // both empty
-                       : EqualRgn(d->rgn, r.d->rgn); // both non-empty
+    if (r)
+        DeleteObject(r);
 }
 
-QRegion& QRegion::operator+=(const QRegion &r)
+static void qt_add_rect(HRGN &winRegion, QRect r)
 {
-    if (!r.d->rgn)
-        return *this;
-
-    if (!d->rgn) {
-        *this = r;
-        return *this;
+    HRGN rgn = CreateRectRgn(r.left(), r.top(), r.x() + r.width(), r.y() + r.height());
+    if (rgn) {
+        HRGN dest = CreateRectRgn(0,0,0,0);
+        int result = CombineRgn(dest, winRegion, rgn, RGN_OR);
+        if (result) {
+            DeleteObject(winRegion);
+            winRegion = dest;
+        }
+        DeleteObject(rgn);
     }
-
-    detach();
-
-    int result;
-    result = CombineRgn(d->rgn, d->rgn, r.d->rgn, RGN_OR);
-    if (result == NULLREGION || result == ERROR)
-        *this = QRegion();
-
-    return *this;
-}
-
-QRegion& QRegion::operator-=(const QRegion &r)
-{
-    if (!r.d->rgn || !d->rgn)
-        return *this;
-
-    detach();
-
-    int result;
-    result = CombineRgn(d->rgn, d->rgn, r.d->rgn, RGN_DIFF);
-    if (result == NULLREGION || result == ERROR)
-        *this = QRegion();
-
-    return *this;
 }
 
-QRegion& QRegion::operator&=(const QRegion &r)
+void QRegion::ensureHandle() const
 {
-    if (!d->rgn)
-        return *this;
-
-    if (!r.d->rgn) {
-        *this = QRegion();
-        return *this;
+    if (d->rgn)
+        DeleteObject(d->rgn);
+    d->rgn = CreateRectRgn(0,0,0,0);
+    if (d->qt_rgn) {
+        if (d->qt_rgn->numRects == 1) {
+            QRect r = d->qt_rgn->extents;
+            qt_add_rect(d->rgn, r);
+            return;
+        }
+        for (int i = 0;i < d->qt_rgn->numRects;i++) {
+            QRect r = d->qt_rgn->rects.at(i);
+            qt_add_rect(d->rgn, r);
+        }
     }
-
-    detach();
-
-    int result;
-    result = CombineRgn(d->rgn, d->rgn, r.d->rgn, RGN_AND);
-    if (result == NULLREGION || result == ERROR)
-        *this = QRegion();
-
-    return *this;
-}
-
-bool qt_region_strictContains(const QRegion &region, const QRect &rect)
-{
-    Q_UNUSED(region);
-    Q_UNUSED(rect);
-    return false;
 }
 
-void QRegion::ensureHandle() const
-{
-}
 
 QT_END_NAMESPACE
diff --git a/src/gui/painting/qtextureglyphcache_p.h b/src/gui/painting/qtextureglyphcache_p.h
index 6968f4e..a34c354 100644
--- a/src/gui/painting/qtextureglyphcache_p.h
+++ b/src/gui/painting/qtextureglyphcache_p.h
@@ -60,6 +60,10 @@
 
 #include <private/qfontengineglyphcache_p.h>
 
+#if defined(Q_OS_VXWORKS) && defined(m_type)
+#  undef m_type
+#endif
+
 struct glyph_metrics_t;
 typedef unsigned int glyph_t;
 
diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp
index a322fe4..0a64e4e 100644
--- a/src/gui/painting/qtransform.cpp
+++ b/src/gui/painting/qtransform.cpp
@@ -48,6 +48,8 @@
 #include "qvariant.h"
 #include <qmath.h>
 
+#include <private/qbezier_p.h>
+
 QT_BEGIN_NAMESPACE
 
 #define Q_NEAR_CLIP 0.000001
@@ -1492,27 +1494,12 @@ static inline bool lineTo_clipped(QPainterPath &path, const QTransform &transfor
 
 static inline bool cubicTo_clipped(QPainterPath &path, const QTransform &transform, const QPointF &a, const QPointF &b, const QPointF &c, const QPointF &d, bool needsMoveTo)
 {
-    const QHomogeneousCoordinate ha = mapHomogeneous(transform, a);
-    const QHomogeneousCoordinate hb = mapHomogeneous(transform, b);
-    const QHomogeneousCoordinate hc = mapHomogeneous(transform, c);
-    const QHomogeneousCoordinate hd = mapHomogeneous(transform, d);
-
-    if (ha.w < Q_NEAR_CLIP && hb.w < Q_NEAR_CLIP && hc.w < Q_NEAR_CLIP && hd.w < Q_NEAR_CLIP)
-        return false;
+    // Convert projective xformed curves to line
+    // segments so they can be transformed more accurately
+    QPolygonF segment = QBezier::fromPoints(a, b, c, d).toPolygon();
 
-    if (ha.w >= Q_NEAR_CLIP && hb.w >= Q_NEAR_CLIP && hc.w >= Q_NEAR_CLIP && hd.w >= Q_NEAR_CLIP) {
-        if (needsMoveTo)
-            path.moveTo(ha.toPoint());
-
-        path.cubicTo(hb.toPoint(), hc.toPoint(), hd.toPoint());
-        return true;
-    }
-
-    if (lineTo_clipped(path, transform, a, b, needsMoveTo))
-            needsMoveTo = false;
-    if (lineTo_clipped(path, transform, b, c, needsMoveTo))
-            needsMoveTo = false;
-    if (lineTo_clipped(path, transform, c, d, needsMoveTo))
+    for (int i = 0; i < segment.size() - 1; ++i)
+        if (lineTo_clipped(path, transform, segment.at(i), segment.at(i+1), needsMoveTo))
             needsMoveTo = false;
 
     return !needsMoveTo;
@@ -1793,6 +1780,14 @@ void QTransform::setMatrix(qreal m11, qreal m12, qreal m13,
     m_dirty = TxProject;
 }
 
+static inline bool needsPerspectiveClipping(const QRectF &rect, const QTransform &transform)
+{
+    const qreal wx = qMin(transform.m13() * rect.left(), transform.m13() * rect.right());
+    const qreal wy = qMin(transform.m23() * rect.top(), transform.m23() * rect.bottom());
+
+    return wx + wy + transform.m33() < Q_NEAR_CLIP;
+}
+
 QRect QTransform::mapRect(const QRect &rect) const
 {
     TransformationType t = inline_type();
@@ -1813,7 +1808,7 @@ QRect QTransform::mapRect(const QRect &rect) const
             y -= h;
         }
         return QRect(x, y, w, h);
-    } else {
+    } else if (t < TxProject || !needsPerspectiveClipping(rect, *this)) {
         // see mapToPolygon for explanations of the algorithm.
         qreal x = 0, y = 0;
         MAP(rect.left(), rect.top(), x, y);
@@ -1837,6 +1832,10 @@ QRect QTransform::mapRect(const QRect &rect) const
         xmax = qMax(xmax, x);
         ymax = qMax(ymax, y);
         return QRect(qRound(xmin), qRound(ymin), qRound(xmax)-qRound(xmin), qRound(ymax)-qRound(ymin));
+    } else {
+        QPainterPath path;
+        path.addRect(rect);
+        return map(path).boundingRect().toRect();
     }
 }
 
@@ -1879,7 +1878,7 @@ QRectF QTransform::mapRect(const QRectF &rect) const
             y -= h;
         }
         return QRectF(x, y, w, h);
-    } else {
+    } else if (t < TxProject || !needsPerspectiveClipping(rect, *this)) {
         qreal x = 0, y = 0;
         MAP(rect.x(), rect.y(), x, y);
         qreal xmin = x;
@@ -1902,6 +1901,10 @@ QRectF QTransform::mapRect(const QRectF &rect) const
         xmax = qMax(xmax, x);
         ymax = qMax(ymax, y);
         return QRectF(xmin, ymin, xmax-xmin, ymax - ymin);
+    } else {
+        QPainterPath path;
+        path.addRect(rect);
+        return map(path).boundingRect();
     }
 }
 
diff --git a/src/gui/painting/qtransform.h b/src/gui/painting/qtransform.h
index 291d35c..69d4de2 100644
--- a/src/gui/painting/qtransform.h
+++ b/src/gui/painting/qtransform.h
@@ -50,6 +50,10 @@
 #include <QtCore/qpoint.h>
 #include <QtCore/qrect.h>
 
+#if defined(Q_OS_VXWORKS) && defined(m_type)
+#  undef m_type
+#endif
+
 QT_BEGIN_HEADER
 
 QT_BEGIN_NAMESPACE
diff --git a/src/gui/painting/qvectorpath_p.h b/src/gui/painting/qvectorpath_p.h
index e3cb333..df49500 100644
--- a/src/gui/painting/qvectorpath_p.h
+++ b/src/gui/painting/qvectorpath_p.h
@@ -130,6 +130,8 @@ public:
 
     static inline uint polygonFlags(QPaintEngine::PolygonDrawMode mode);
 
+    QPainterPath convertToPainterPath() const;
+
 private:
     Q_DISABLE_COPY(QVectorPath)
 
diff --git a/src/gui/painting/qwindowsurface_raster.cpp b/src/gui/painting/qwindowsurface_raster.cpp
index 63b39b2..863237b 100644
--- a/src/gui/painting/qwindowsurface_raster.cpp
+++ b/src/gui/painting/qwindowsurface_raster.cpp
@@ -116,7 +116,7 @@ QPaintDevice *QRasterWindowSurface::paintDevice()
 void QRasterWindowSurface::beginPaint(const QRegion &rgn)
 {
 #if (defined(Q_WS_X11) && !defined(QT_NO_XRENDER)) || (defined(Q_WS_WIN) && !defined(Q_WS_WINCE))
-    if (!qt_widget_private(window())->isOpaque) {
+    if (!qt_widget_private(window())->isOpaque && window()->testAttribute(Qt::WA_TranslucentBackground)) {
 #if defined(Q_WS_WIN) && !defined(Q_WS_WINCE)
         if (d_ptr->image->image.format() != QImage::Format_ARGB32_Premultiplied)
             prepareBuffer(QImage::Format_ARGB32_Premultiplied, window());
@@ -147,7 +147,7 @@ void QRasterWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoi
     QRect br = rgn.boundingRect();
 
 #ifndef Q_WS_WINCE
-    if (!qt_widget_private(window())->isOpaque) {
+    if (!qt_widget_private(window())->isOpaque && window()->testAttribute(Qt::WA_TranslucentBackground)) {
         QRect r = window()->frameGeometry();
         QPoint frameOffset = qt_widget_private(window())->frameStrut().topLeft();
         QRect dirtyRect = br.translated(offset + frameOffset);
diff --git a/src/gui/painting/qwindowsurface_x11.cpp b/src/gui/painting/qwindowsurface_x11.cpp
index d8b0d9e..95f6ce3 100644
--- a/src/gui/painting/qwindowsurface_x11.cpp
+++ b/src/gui/painting/qwindowsurface_x11.cpp
@@ -154,7 +154,7 @@ void QX11WindowSurface::setGeometry(const QRect &rect)
 
         QX11PixmapData *oldData = static_cast<QX11PixmapData *>(d_ptr->device.pixmapData());
         Q_ASSERT(oldData);
-        if (!oldData->uninit && hasStaticContents()) {
+        if (!(oldData->flags & QX11PixmapData::Uninitialized) && hasStaticContents()) {
             // Copy the content of the old pixmap into the new one.
             QX11PixmapData *newData = new QX11PixmapData(QPixmapData::PixmapType);
             newData->resize(size.width(), size.height());
@@ -175,7 +175,7 @@ void QX11WindowSurface::setGeometry(const QRect &rect)
                       dx, dy, qMin(boundingRect.width(), size.width()),
                       qMin(boundingRect.height(), size.height()), dx, dy);
             XFreeGC(X11->display, tmpGc);
-            newData->uninit = false;
+            newData->flags &= ~QX11PixmapData::Uninitialized;
 
             d_ptr->device = QPixmap(newData);
         } else {
diff --git a/src/gui/statemachine/qkeyeventtransition.cpp b/src/gui/statemachine/qkeyeventtransition.cpp
index 51b3ccc..21a0736 100644
--- a/src/gui/statemachine/qkeyeventtransition.cpp
+++ b/src/gui/statemachine/qkeyeventtransition.cpp
@@ -106,19 +106,6 @@ QKeyEventTransition::QKeyEventTransition(QObject *object, QEvent::Type type,
 }
 
 /*!
-  Constructs a new key event transition for events of the given \a type for
-  the given \a object, with the given \a key, \a targets and \a sourceState.
-*/
-QKeyEventTransition::QKeyEventTransition(QObject *object, QEvent::Type type,
-                                         int key, const QList<QAbstractState*> &targets,
-                                         QState *sourceState)
-    : QEventTransition(*new QKeyEventTransitionPrivate, object, type, targets, sourceState)
-{
-    Q_D(QKeyEventTransition);
-    d->transition = new QBasicKeyEventTransition(type, key);
-}
-
-/*!
   Destroys this key event transition.
 */
 QKeyEventTransition::~QKeyEventTransition()
diff --git a/src/gui/statemachine/qkeyeventtransition.h b/src/gui/statemachine/qkeyeventtransition.h
index f5e8de3..45ae684 100644
--- a/src/gui/statemachine/qkeyeventtransition.h
+++ b/src/gui/statemachine/qkeyeventtransition.h
@@ -62,9 +62,6 @@ public:
     QKeyEventTransition(QState *sourceState = 0);
     QKeyEventTransition(QObject *object, QEvent::Type type, int key,
                         QState *sourceState = 0);
-    QKeyEventTransition(QObject *object, QEvent::Type type, int key,
-                        const QList<QAbstractState*> &targets,
-                        QState *sourceState = 0);
     ~QKeyEventTransition();
 
     int key() const;
diff --git a/src/gui/statemachine/qmouseeventtransition.cpp b/src/gui/statemachine/qmouseeventtransition.cpp
index 0cd096a..dbe50b3 100644
--- a/src/gui/statemachine/qmouseeventtransition.cpp
+++ b/src/gui/statemachine/qmouseeventtransition.cpp
@@ -112,21 +112,6 @@ QMouseEventTransition::QMouseEventTransition(QObject *object, QEvent::Type type,
 }
 
 /*!
-  Constructs a new mouse event transition for events of the given \a type for
-  the given \a object, with the given \a button, \a targets and \a
-  sourceState.
-*/
-QMouseEventTransition::QMouseEventTransition(QObject *object, QEvent::Type type,
-                                             Qt::MouseButton button,
-                                             const QList<QAbstractState*> &targets,
-                                             QState *sourceState)
-    : QEventTransition(*new QMouseEventTransitionPrivate, object, type, targets, sourceState)
-{
-    Q_D(QMouseEventTransition);
-    d->transition = new QBasicMouseEventTransition(type, button);
-}
-
-/*!
   Destroys this mouse event transition.
 */
 QMouseEventTransition::~QMouseEventTransition()
diff --git a/src/gui/statemachine/qmouseeventtransition.h b/src/gui/statemachine/qmouseeventtransition.h
index 73ae6c9..a56a554 100644
--- a/src/gui/statemachine/qmouseeventtransition.h
+++ b/src/gui/statemachine/qmouseeventtransition.h
@@ -63,10 +63,6 @@ public:
     QMouseEventTransition(QState *sourceState = 0);
     QMouseEventTransition(QObject *object, QEvent::Type type,
                           Qt::MouseButton button, QState *sourceState = 0);
-    QMouseEventTransition(QObject *object, QEvent::Type type,
-                          Qt::MouseButton button,
-                          const QList<QAbstractState*> &targets,
-                          QState *sourceState = 0);
     ~QMouseEventTransition();
 
     Qt::MouseButton button() const;
diff --git a/src/gui/styles/qwindowsxpstyle.cpp b/src/gui/styles/qwindowsxpstyle.cpp
index 9560c4b..ad87354 100644
--- a/src/gui/styles/qwindowsxpstyle.cpp
+++ b/src/gui/styles/qwindowsxpstyle.cpp
@@ -134,6 +134,7 @@ static const int windowsRightBorder      = 12; // right border on windows
 
 // External function calls
 extern Q_GUI_EXPORT HDC qt_win_display_dc();
+extern QRegion qt_region_from_HRGN(HRGN rgn);
 
 
 
@@ -445,6 +446,7 @@ bool QWindowsXPStylePrivate::isTransparent(XPThemeData &themeData)
                                                   themeData.stateId);
 }
 
+
 /*! \internal
     Returns a QRegion of the region of the part
 */
@@ -456,12 +458,18 @@ QRegion QWindowsXPStylePrivate::region(XPThemeData &themeData)
                                              themeData.stateId, &rect, &hRgn)))
         return QRegion();
 
-    QRegion rgn = QRegion(0,0,1,1);
-    const bool success = CombineRgn(rgn.handle(), hRgn, 0, RGN_COPY) != ERROR;
-    DeleteObject(hRgn);
+    HRGN dest = CreateRectRgn(0, 0, 0, 0);
+    const bool success = CombineRgn(dest, hRgn, 0, RGN_COPY) != ERROR;
+
+    QRegion region;
+
     if (success)
-        return rgn;
-    return QRegion();
+        region = qt_region_from_HRGN(dest);
+
+    DeleteObject(hRgn);
+    DeleteObject(dest);
+
+    return region;
 }
 
 /*! \internal
diff --git a/src/gui/text/qcssparser_p.h b/src/gui/text/qcssparser_p.h
index b07acd5..9f046ff 100644
--- a/src/gui/text/qcssparser_p.h
+++ b/src/gui/text/qcssparser_p.h
@@ -67,6 +67,11 @@
 
 #ifndef QT_NO_CSSPARSER
 
+// VxWorks defines NONE as (-1) "for times when NULL won't do"
+#if defined(Q_OS_VXWORKS) && defined(NONE)
+#  undef NONE
+#endif
+
 QT_BEGIN_NAMESPACE
 
 namespace QCss
diff --git a/src/gui/text/qfontdatabase_qws.cpp b/src/gui/text/qfontdatabase_qws.cpp
index ff6af98..0407508 100644
--- a/src/gui/text/qfontdatabase_qws.cpp
+++ b/src/gui/text/qfontdatabase_qws.cpp
@@ -257,7 +257,7 @@ static QString qwsFontPath()
     return fontpath;
 }
 
-#ifdef QFONTDATABASE_DEBUG
+#if defined(QFONTDATABASE_DEBUG) && defined(QT_FONTS_ARE_RESOURCES)
 class FriendlyResource : public QResource
 {
 public:
@@ -591,8 +591,12 @@ QFontEngine *loadSingleEngine(int script, const QFontPrivate *fp,
         QFontDef def = request;
         def.pixelSize = pixelSize;
 
+#ifdef QT_NO_QWS_SHARE_FONTS
+        bool shareFonts = false;
+#else
         static bool dontShareFonts = !qgetenv("QWS_NO_SHARE_FONTS").isEmpty();
         bool shareFonts = !dontShareFonts;
+#endif
 
         QScopedPointer<QFontEngine> engine;
 
diff --git a/src/gui/text/qfontengine_ft.cpp b/src/gui/text/qfontengine_ft.cpp
index ab04dc7..499d28c 100644
--- a/src/gui/text/qfontengine_ft.cpp
+++ b/src/gui/text/qfontengine_ft.cpp
@@ -1380,8 +1380,8 @@ bool QFontEngineFT::loadGlyphs(QGlyphSet *gs, glyph_t *glyphs, int num_glyphs, G
     FT_Face face = 0;
 
     for (int i = 0; i < num_glyphs; ++i) {
-        if (!gs->glyph_data.contains(glyphs[i])
-            || gs->glyph_data.value(glyphs[i])->format != format) {
+        Glyph *glyph = gs->glyph_data.value(glyphs[i]);
+        if (glyph == 0 || glyph->format != format) {
             if (!face) {
                 face = lockFace();
                 FT_Matrix m = matrix;
diff --git a/src/gui/text/qfontengine_mac.mm b/src/gui/text/qfontengine_mac.mm
index 76132df..dbf3015 100644
--- a/src/gui/text/qfontengine_mac.mm
+++ b/src/gui/text/qfontengine_mac.mm
@@ -156,7 +156,7 @@ QCoreTextFontEngineMulti::QCoreTextFontEngineMulti(const ATSFontFamilyRef &, con
     if (!kerning) {
         float zero = 0.0;
         QCFType<CFNumberRef> noKern = CFNumberCreate(kCFAllocatorDefault, kCFNumberFloatType, &zero);
-        CFDictionaryAddValue(attributeDict, kCTKernAttributeName, &noKern);
+        CFDictionaryAddValue(attributeDict, kCTKernAttributeName, noKern);
     }
 
     QCoreTextFontEngine *fe = new QCoreTextFontEngine(ctfont, fontDef, this);
@@ -1588,6 +1588,7 @@ QFontEngine::FaceId QFontEngineMac::faceId() const
 {
     FaceId ret;
 #if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
     // CTFontGetPlatformFont
     FSRef ref;
     if (ATSFontGetFileReference(FMGetATSFontRefFromFont(fontID), &ref) != noErr)
@@ -1595,7 +1596,9 @@ QFontEngine::FaceId QFontEngineMac::faceId() const
     ret.filename = QByteArray(128, 0);
     ret.index = fontID;
     FSRefMakePath(&ref, (UInt8 *)ret.filename.data(), ret.filename.size());
-#else
+}else
+#endif
+{
     FSSpec spec;
     if (ATSFontGetFileSpecification(FMGetATSFontRefFromFont(fontID), &spec) != noErr)
         return ret;
@@ -1605,7 +1608,7 @@ QFontEngine::FaceId QFontEngineMac::faceId() const
     ret.filename = QByteArray(128, 0);
     ret.index = fontID;
     FSRefMakePath(&ref, (UInt8 *)ret.filename.data(), ret.filename.size());
-#endif
+}
     return ret;
 }
 
diff --git a/src/gui/text/qfontengine_qpf.cpp b/src/gui/text/qfontengine_qpf.cpp
index 232f839..e7826cc 100644
--- a/src/gui/text/qfontengine_qpf.cpp
+++ b/src/gui/text/qfontengine_qpf.cpp
@@ -331,16 +331,37 @@ QFontEngineQPF::QFontEngineQPF(const QFontDef &def, int fileDescriptor, QFontEng
 #if defined(DEBUG_FONTENGINE)
             qDebug() << "found existing qpf:" << fileName;
 #endif
-            if (::access(encodedName, W_OK | R_OK) == 0)
-                fd = QT_OPEN(encodedName, O_RDWR, 0);
-            else if (::access(encodedName, R_OK) == 0)
-                fd = QT_OPEN(encodedName, O_RDONLY, 0);
+            if (::access(encodedName, W_OK | R_OK) == 0) {
+                fd = QT_OPEN(encodedName, O_RDWR);
+            }
+            // read-write access failed - try read-only access
+            if (fd == -1 && ::access(encodedName, R_OK) == 0) {
+                fd = QT_OPEN(encodedName, O_RDONLY);
+                if (fd == -1) {
+#if defined(DEBUG_FONTENGINE)
+                    qErrnoWarning("QFontEngineQPF: unable to open %s", encodedName.constData());
+#endif
+                    return;
+                }
+            }
+            if (fd == -1) {
+#if defined(DEBUG_FONTENGINE)
+                qWarning("QFontEngineQPF: insufficient access rights to %s", encodedName.constData());
+#endif
+                return;
+            }
         } else {
 #if defined(DEBUG_FONTENGINE)
             qDebug() << "creating qpf on the fly:" << fileName;
 #endif
             if (::access(QFile::encodeName(qws_fontCacheDir()), W_OK) == 0) {
                 fd = QT_OPEN(encodedName, O_RDWR | O_EXCL | O_CREAT, 0644);
+                if (fd == -1) {
+#if defined(DEBUG_FONTENGINE)
+                    qErrnoWarning(errno, "QFontEngineQPF: open() failed for %s", encodedName.constData());
+#endif
+                    return;
+                }
 
                 QBuffer buffer;
                 buffer.open(QIODevice::ReadWrite);
@@ -348,7 +369,17 @@ QFontEngineQPF::QFontEngineQPF(const QFontDef &def, int fileDescriptor, QFontEng
                 generator.generate();
                 buffer.close();
                 const QByteArray &data = buffer.data();
-                QT_WRITE(fd, data.constData(), data.size());
+                if (QT_WRITE(fd, data.constData(), data.size()) == -1) {
+#if defined(DEBUG_FONTENGINE)
+                    qErrnoWarning(errno, "QFontEngineQPF: write() failed for %s", encodedName.constData());
+#endif
+                    return;
+                }
+            } else {
+#if defined(DEBUG_FONTENGINE)
+                qErrnoWarning(errno, "QFontEngineQPF: access() failed for %s", qPrintable(qws_fontCacheDir()));
+#endif
+                return;
             }
         }
     }
@@ -356,7 +387,7 @@ QFontEngineQPF::QFontEngineQPF(const QFontDef &def, int fileDescriptor, QFontEng
     QT_STATBUF st;
     if (QT_FSTAT(fd, &st)) {
 #if defined(DEBUG_FONTENGINE)
-        qDebug() << "stat failed!";
+        qErrnoWarning(errno, "QFontEngineQPF: fstat failed!");
 #endif
         return;
     }
@@ -492,8 +523,13 @@ QFontEngineQPF::~QFontEngineQPF()
     }
 #endif
     delete renderingFontEngine;
-    if (fontData)
-        munmap((void *)fontData, dataSize);
+    if (fontData) {
+        if (munmap((void *)fontData, dataSize) == -1) {
+#if defined(DEBUG_FONTENGINE)
+            qErrnoWarning(errno, "~QFontEngineQPF: Unable to munmap");
+#endif
+        }
+    }
     if (fd != -1)
         ::close(fd);
 #if !defined(QT_NO_FREETYPE)
diff --git a/src/gui/text/qfontengine_qws.cpp b/src/gui/text/qfontengine_qws.cpp
index 70ce8f9..10bee2c 100644
--- a/src/gui/text/qfontengine_qws.cpp
+++ b/src/gui/text/qfontengine_qws.cpp
@@ -396,7 +396,7 @@ QFontEngineQPF1::QFontEngineQPF1(const QFontDef&, const QString &fn)
     uchar* data = (uchar*)mmap( 0, // any address
                                 st.st_size, // whole file
                                 PROT_READ, // read-only memory
-#if !defined(Q_OS_SOLARIS) && !defined(Q_OS_QNX4) && !defined(Q_OS_INTEGRITY)
+#if !defined(Q_OS_SOLARIS) && !defined(Q_OS_QNX4) && !defined(Q_OS_INTEGRITY) && !defined(Q_OS_VXWORKS)
                                 MAP_FILE | MAP_PRIVATE, // swap-backed map from file
 #else
                                 MAP_PRIVATE,
diff --git a/src/gui/text/qtextcontrol_p.h b/src/gui/text/qtextcontrol_p.h
index 872bcd5..eb0d749 100644
--- a/src/gui/text/qtextcontrol_p.h
+++ b/src/gui/text/qtextcontrol_p.h
@@ -83,7 +83,7 @@ class QAbstractScrollArea;
 class QEvent;
 class QTimerEvent;
 
-class Q_AUTOTEST_EXPORT QTextControl : public QObject
+class Q_GUI_EXPORT QTextControl : public QObject
 {
     Q_OBJECT
     Q_DECLARE_PRIVATE(QTextControl)
diff --git a/src/gui/text/qtextdocument_p.cpp b/src/gui/text/qtextdocument_p.cpp
index ea37e04..e66b07c 100644
--- a/src/gui/text/qtextdocument_p.cpp
+++ b/src/gui/text/qtextdocument_p.cpp
@@ -60,6 +60,15 @@ QT_BEGIN_NAMESPACE
 
 #define PMDEBUG if(0) qDebug
 
+// The VxWorks DIAB compiler crashes when initializing the anonymouse union with { a7 }
+#if !defined(Q_CC_DIAB)
+#  define QT_INIT_TEXTUNDOCOMMAND(c, a1, a2, a3, a4, a5, a6, a7, a8) \
+          QTextUndoCommand c = { a1, a2, a3, a4, a5, a6, { a7 }, a8 }
+#else
+#  define QT_INIT_TEXTUNDOCOMMAND(c, a1, a2, a3, a4, a5, a6, a7, a8) \
+          QTextUndoCommand c = { a1, a2, a3, a4, a5, a6 }; c.blockFormat = a7; c.revision = a8
+#endif
+
 /*
   Structure of a document:
 
@@ -406,9 +415,9 @@ int QTextDocumentPrivate::insertBlock(const QChar &blockSeparator,
     int b = blocks.findNode(pos);
     QTextBlockData *B = blocks.fragment(b);
 
-    QTextUndoCommand c = { QTextUndoCommand::BlockInserted, editBlock != 0,
-                           op, charFormat, strPos, pos, { blockFormat },
-                           B->revision };
+    QT_INIT_TEXTUNDOCOMMAND(c, QTextUndoCommand::BlockInserted, editBlock != 0,
+                            op, charFormat, strPos, pos, blockFormat,
+                            B->revision);
 
     appendUndoItem(c);
     Q_ASSERT(undoState == undoStack.size());
@@ -447,9 +456,9 @@ void QTextDocumentPrivate::insert(int pos, int strPos, int strLength, int format
         int b = blocks.findNode(pos);
         QTextBlockData *B = blocks.fragment(b);
 
-        QTextUndoCommand c = { QTextUndoCommand::Inserted, editBlock != 0,
-                               QTextUndoCommand::MoveCursor, format, strPos, pos, { strLength },
-                               B->revision };
+        QT_INIT_TEXTUNDOCOMMAND(c, QTextUndoCommand::Inserted, editBlock != 0,
+                                QTextUndoCommand::MoveCursor, format, strPos, pos, strLength,
+                                B->revision);
         appendUndoItem(c);
         B->revision = undoState;
         Q_ASSERT(undoState == undoStack.size());
@@ -606,12 +615,12 @@ void QTextDocumentPrivate::move(int pos, int to, int length, QTextUndoCommand::O
         int blockRevision = B->revision;
 
         QTextFragmentData *X = fragments.fragment(x);
-        QTextUndoCommand c = { QTextUndoCommand::Removed, editBlock != 0,
-                               op, X->format, X->stringPosition, key, { X->size_array[0] },
-                               blockRevision };
-        QTextUndoCommand cInsert = { QTextUndoCommand::Inserted, editBlock != 0,
-                                     op, X->format, X->stringPosition, dstKey, { X->size_array[0] },
-                                     blockRevision };
+        QT_INIT_TEXTUNDOCOMMAND(c, QTextUndoCommand::Removed, editBlock != 0,
+                                op, X->format, X->stringPosition, key, X->size_array[0],
+                                blockRevision);
+        QT_INIT_TEXTUNDOCOMMAND(cInsert, QTextUndoCommand::Inserted, editBlock != 0,
+                                op, X->format, X->stringPosition, dstKey, X->size_array[0],
+                                blockRevision);
 
         if (key+1 != blocks.position(b)) {
 //	    qDebug("remove_string from %d length %d", key, X->size_array[0]);
@@ -723,8 +732,8 @@ void QTextDocumentPrivate::setCharFormat(int pos, int length, const QTextCharFor
             fragment->format = newFormatIdx;
         }
 
-        QTextUndoCommand c = { QTextUndoCommand::CharFormatChanged, true, QTextUndoCommand::MoveCursor, oldFormat,
-                               0, pos, { length }, 0 };
+        QT_INIT_TEXTUNDOCOMMAND(c, QTextUndoCommand::CharFormatChanged, true, QTextUndoCommand::MoveCursor, oldFormat,
+                                0, pos, length, 0);
         appendUndoItem(c);
 
         pos += length;
@@ -783,8 +792,8 @@ void QTextDocumentPrivate::setBlockFormat(const QTextBlock &from, const QTextBlo
 
         block(it)->invalidate();
 
-        QTextUndoCommand c = { QTextUndoCommand::BlockFormatChanged, true, QTextUndoCommand::MoveCursor, oldFormat,
-                               0, it.position(), { 1 }, 0 };
+        QT_INIT_TEXTUNDOCOMMAND(c, QTextUndoCommand::BlockFormatChanged, true, QTextUndoCommand::MoveCursor, oldFormat,
+                                0, it.position(), 1, 0);
         appendUndoItem(c);
 
         if (group != oldGroup) {
@@ -1298,8 +1307,8 @@ void QTextDocumentPrivate::changeObjectFormat(QTextObject *obj, int format)
     if (f)
         documentChange(f->firstPosition(), f->lastPosition() - f->firstPosition());
 
-    QTextUndoCommand c = { QTextUndoCommand::GroupFormatChange, editBlock != 0, QTextUndoCommand::MoveCursor, oldFormatIndex,
-                           0, 0, { obj->d_func()->objectIndex }, 0 };
+    QT_INIT_TEXTUNDOCOMMAND(c, QTextUndoCommand::GroupFormatChange, editBlock != 0, QTextUndoCommand::MoveCursor, oldFormatIndex,
+                            0, 0, obj->d_func()->objectIndex, 0);
     appendUndoItem(c);
 
     endEditBlock();
diff --git a/src/gui/text/qtextdocumentfragment.cpp b/src/gui/text/qtextdocumentfragment.cpp
index a940aa4..cb09452 100644
--- a/src/gui/text/qtextdocumentfragment.cpp
+++ b/src/gui/text/qtextdocumentfragment.cpp
@@ -54,7 +54,11 @@
 QT_BEGIN_NAMESPACE
 
 QTextCopyHelper::QTextCopyHelper(const QTextCursor &_source, const QTextCursor &_destination, bool forceCharFormat, const QTextCharFormat &fmt)
+#if defined(Q_CC_DIAB) // compiler bug
+    : formatCollection(*_destination.d->priv->formatCollection()), originalText((const QString)_source.d->priv->buffer())
+#else
     : formatCollection(*_destination.d->priv->formatCollection()), originalText(_source.d->priv->buffer())
+#endif
 {
     src = _source.d->priv;
     dst = _destination.d->priv;
diff --git a/src/gui/util/qcompleter.cpp b/src/gui/util/qcompleter.cpp
index 0ce3b3c..b823100 100644
--- a/src/gui/util/qcompleter.cpp
+++ b/src/gui/util/qcompleter.cpp
@@ -824,6 +824,9 @@ void QCompleterPrivate::_q_complete(QModelIndex index, bool highlighted)
     Q_Q(QCompleter);
     QString completion;
 
+    if (!(index.flags() & Qt::ItemIsEnabled))
+        return;
+
     if (!index.isValid() || (!proxy->showAll && (index.row() >= proxy->engine->matchCount()))) {
         completion = prefix;
     } else {
@@ -1102,7 +1105,8 @@ void QCompleter::setPopup(QAbstractItemView *popup)
 
     QObject::connect(popup, SIGNAL(clicked(QModelIndex)),
                      this, SLOT(_q_complete(QModelIndex)));
-    QObject::connect(popup, SIGNAL(clicked(QModelIndex)), popup, SLOT(hide()));
+    QObject::connect(this, SIGNAL(activated(QModelIndex)),
+                     popup, SLOT(hide()));
 
     QObject::connect(popup->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
                      this, SLOT(_q_completionSelected(QItemSelection)));
diff --git a/src/gui/util/qdesktopservices_x11.cpp b/src/gui/util/qdesktopservices_x11.cpp
index f0202d4..0a3c2d0 100644
--- a/src/gui/util/qdesktopservices_x11.cpp
+++ b/src/gui/util/qdesktopservices_x11.cpp
@@ -56,7 +56,11 @@ QT_BEGIN_NAMESPACE
 
 inline static bool launch(const QUrl &url, const QString &client)
 {
+#if !defined(QT_NO_PROCESS)
     return (QProcess::startDetached(client + QLatin1Char(' ') + QString::fromLatin1(url.toEncoded().constData())));
+#else
+    return (::system((client + QLatin1Char(' ') + QString::fromLatin1(url.toEncoded().constData())).toLocal8Bit().constData()) != -1);
+#endif
 }
 
 static bool openDocument(const QUrl &url)
diff --git a/src/gui/widgets/qabstractspinbox.cpp b/src/gui/widgets/qabstractspinbox.cpp
index 8027f9e..bcc5c92 100644
--- a/src/gui/widgets/qabstractspinbox.cpp
+++ b/src/gui/widgets/qabstractspinbox.cpp
@@ -987,7 +987,7 @@ void QAbstractSpinBox::keyPressEvent(QKeyEvent *event)
 #endif
     case Qt::Key_Enter:
     case Qt::Key_Return:
-        d->edit->d_func()->modifiedState = d->edit->d_func()->undoState = 0;
+        d->edit->d_func()->control->clearUndo();
         d->interpret(d->keyboardTracking ? AlwaysEmit : EmitIfChanged);
         selectAll();
         event->ignore();
diff --git a/src/gui/widgets/qlinecontrol.cpp b/src/gui/widgets/qlinecontrol.cpp
new file mode 100644
index 0000000..106d8f2
--- /dev/null
+++ b/src/gui/widgets/qlinecontrol.cpp
@@ -0,0 +1,1749 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qlinecontrol_p.h"
+
+#ifndef QT_NO_LINEEDIT
+
+#include "qabstractitemview.h"
+#include "qclipboard.h"
+#ifndef QT_NO_ACCESSIBILITY
+#include "qaccessible.h"
+#endif
+#ifndef QT_NO_IM
+#include "qinputcontext.h"
+#include "qlist.h"
+#endif
+#include "qapplication.h"
+#ifndef QT_NO_GRAPHICSVIEW
+#include "qgraphicssceneevent.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \internal
+
+    Updates the display text based of the current edit text
+    If the text has changed will emit displayTextChanged()
+*/
+void QLineControl::updateDisplayText()
+{
+    QString orig = m_textLayout.text();
+    QString str;
+    if (m_echoMode == QLineEdit::NoEcho)
+        str = QString::fromLatin1("");
+    else
+        str = m_text;
+
+    if (m_echoMode == QLineEdit::Password || (m_echoMode == QLineEdit::PasswordEchoOnEdit
+                && !m_passwordEchoEditing))
+        str.fill(m_passwordCharacter);
+
+    // replace certain non-printable characters with spaces (to avoid
+    // drawing boxes when using fonts that don't have glyphs for such
+    // characters)
+    QChar* uc = str.data();
+    for (int i = 0; i < (int)str.length(); ++i) {
+        if ((uc[i] < 0x20 && uc[i] != 0x09)
+            || uc[i] == QChar::LineSeparator
+            || uc[i] == QChar::ParagraphSeparator
+            || uc[i] == QChar::ObjectReplacementCharacter)
+            uc[i] = QChar(0x0020);
+    }
+
+    m_textLayout.setText(str);
+
+    QTextOption option;
+    option.setTextDirection(m_layoutDirection);
+    option.setFlags(QTextOption::IncludeTrailingSpaces);
+    m_textLayout.setTextOption(option);
+
+    m_textLayout.beginLayout();
+    QTextLine l = m_textLayout.createLine();
+    m_textLayout.endLayout();
+    m_ascent = qRound(l.ascent());
+
+    if (str != orig)
+        emit displayTextChanged(str);
+}
+
+#ifndef QT_NO_CLIPBOARD
+/*!
+    \internal
+
+    Copies the currently selected text into the clipboard using the given
+    \a mode.
+  
+    \note If the echo mode is set to a mode other than Normal then copy
+    will not work.  This is to prevent using copy as a method of bypassing
+    password features of the line control.
+*/
+void QLineControl::copy(QClipboard::Mode mode) const
+{
+    QString t = selectedText();
+    if (!t.isEmpty() && m_echoMode == QLineEdit::Normal) {
+        disconnect(QApplication::clipboard(), SIGNAL(selectionChanged()), this, 0);
+        QApplication::clipboard()->setText(t, mode);
+        connect(QApplication::clipboard(), SIGNAL(selectionChanged()),
+                   this, SLOT(_q_clipboardChanged()));
+    }
+}
+
+/*!
+    \internal
+
+    Inserts the text stored in the application clipboard into the line
+    control.
+
+    \sa insert()
+*/
+void QLineControl::paste()
+{
+    insert(QApplication::clipboard()->text(QClipboard::Clipboard));
+}
+
+#endif // !QT_NO_CLIPBOARD
+
+/*!
+    \internal
+
+    Handles the behavior for the backspace key or function.
+    Removes the current selection if there is a selection, otherwise
+    removes the character prior to the cursor position.
+
+    \sa del()
+*/
+void QLineControl::backspace()
+{
+    int priorState = m_undoState;
+    if (hasSelectedText()) {
+        removeSelectedText();
+    } else if (m_cursor) {
+            --m_cursor;
+            if (m_maskData)
+                m_cursor = prevMaskBlank(m_cursor);
+            QChar uc = m_text.at(m_cursor);
+            if (m_cursor > 0 && uc.unicode() >= 0xdc00 && uc.unicode() < 0xe000) {
+                // second half of a surrogate, check if we have the first half as well,
+                // if yes delete both at once
+                uc = m_text.at(m_cursor - 1);
+                if (uc.unicode() >= 0xd800 && uc.unicode() < 0xdc00) {
+                    internalDelete(true);
+                    --m_cursor;
+                }
+            }
+            internalDelete(true);
+    }
+    finishChange(priorState);
+}
+
+/*!
+    \internal
+
+    Handles the behavior for the delete key or function.
+    Removes the current selection if there is a selection, otherwise
+    removes the character after the cursor position.
+
+    \sa del()
+*/
+void QLineControl::del()
+{
+    int priorState = m_undoState;
+    if (hasSelectedText()) {
+        removeSelectedText();
+    } else {
+        int n = m_textLayout.nextCursorPosition(m_cursor) - m_cursor;
+        while (n--)
+            internalDelete();
+    }
+    finishChange(priorState);
+}
+
+/*!
+    \internal
+
+    Inserts the given \a newText at the current cursor position.
+    If there is any selected text it is removed prior to insertion of
+    the new text.
+*/
+void QLineControl::insert(const QString &newText)
+{
+    int priorState = m_undoState;
+    removeSelectedText();
+    internalInsert(newText);
+    finishChange(priorState);
+}
+
+/*!
+    \internal
+
+    Clears the line control text.
+*/
+void QLineControl::clear()
+{
+    int priorState = m_undoState;
+    m_selstart = 0;
+    m_selend = m_text.length();
+    removeSelectedText();
+    separate();
+    finishChange(priorState, /*update*/false, /*edited*/false);
+}
+
+/*!
+    \internal
+
+    Sets \a length characters from the given \a start position as selected.
+    The given \a start position must be within the current text for
+    the line control.  If \a length characters cannot be selected, then
+    the selection will extend to the end of the current text.
+*/
+void QLineControl::setSelection(int start, int length)
+{
+    if(start < 0 || start > (int)m_text.length()){
+        qWarning("QLineControl::setSelection: Invalid start position");
+        return;
+    }
+
+    if (length > 0) {
+        if (start == m_selstart && start + length == m_selend)
+            return;
+        m_selstart = start;
+        m_selend = qMin(start + length, (int)m_text.length());
+        m_cursor = m_selend;
+    } else {
+        if (start == m_selend && start + length == m_selstart)
+            return;
+        m_selstart = qMax(start + length, 0);
+        m_selend = start;
+        m_cursor = m_selstart;
+    }
+    emit selectionChanged();
+}
+
+void QLineControl::_q_clipboardChanged()
+{
+}
+
+void QLineControl::_q_deleteSelected()
+{
+    if (!hasSelectedText())
+        return;
+
+    int priorState = m_undoState;
+    emit resetInputContext();
+    removeSelectedText();
+    separate();
+    finishChange(priorState);
+}
+
+/*!
+    \internal
+
+    Initializes the line control with a starting text value of \a txt.
+*/
+void QLineControl::init(const QString &txt)
+{
+    m_text = txt;
+    updateDisplayText();
+    m_cursor = m_text.length();
+}
+
+/*!
+    \internal
+
+    Sets the password echo editing to \a editing.  If password echo editing
+    is true, then the text of the password is displayed even if the echo
+    mode is set to QLineEdit::PasswordEchoOnEdit.  Password echoing editing
+    does not affect other echo modes.
+*/
+void QLineControl::updatePasswordEchoEditing(bool editing)
+{
+    m_passwordEchoEditing = editing;
+    updateDisplayText();
+}
+
+/*!
+    \internal
+
+    Returns the cursor position of the given \a x pixel value in relation
+    to the displayed text.  The given \a betweenOrOn specified what kind
+    of cursor position is requested.
+*/
+int QLineControl::xToPos(int x, QTextLine::CursorPosition betweenOrOn) const
+{
+    return m_textLayout.lineAt(0).xToCursor(x, betweenOrOn);
+}
+
+/*!
+    \internal
+
+    Returns the bounds of the current cursor, as defined as a
+    between characters cursor.
+*/
+QRect QLineControl::cursorRect() const
+{
+    QTextLine l = m_textLayout.lineAt(0);
+    int c = m_cursor;
+    if (m_preeditCursor != -1)
+        c += m_preeditCursor;
+    int cix = qRound(l.cursorToX(c));
+    int w = m_cursorWidth;
+    int ch = l.height() + 1;
+
+    return QRect(cix-5, 0, w+9, ch);
+}
+
+/*!
+    \internal
+
+    Fixes the current text so that it is valid given any set validators.
+
+    Returns true if the text was changed.  Otherwise returns false.
+*/
+bool QLineControl::fixup() // this function assumes that validate currently returns != Acceptable
+{
+#ifndef QT_NO_VALIDATOR
+    if (m_validator) {
+        QString textCopy = m_text;
+        int cursorCopy = m_cursor;
+        m_validator->fixup(textCopy);
+        if (m_validator->validate(textCopy, cursorCopy) == QValidator::Acceptable) {
+            if (textCopy != m_text || cursorCopy != m_cursor)
+                internalSetText(textCopy, cursorCopy);
+            return true;
+        }
+    }
+#endif
+    return false;
+}
+
+/*!
+    \internal
+
+    Moves the cursor to the given position \a pos.   If \a mark is true will
+    adjust the currently selected text.
+*/
+void QLineControl::moveCursor(int pos, bool mark)
+{
+    if (pos != m_cursor) {
+        separate();
+        if (m_maskData)
+            pos = pos > m_cursor ? nextMaskBlank(pos) : prevMaskBlank(pos);
+    }
+    if (mark) {
+        int anchor;
+        if (m_selend > m_selstart && m_cursor == m_selstart)
+            anchor = m_selend;
+        else if (m_selend > m_selstart && m_cursor == m_selend)
+            anchor = m_selstart;
+        else
+            anchor = m_cursor;
+        m_selstart = qMin(anchor, pos);
+        m_selend = qMax(anchor, pos);
+        updateDisplayText();
+    } else {
+        internalDeselect();
+    }
+    m_cursor = pos;
+    if (mark || m_selDirty) {
+        m_selDirty = false;
+        emit selectionChanged();
+    }
+    emitCursorPositionChanged();
+}
+
+/*!
+    \internal
+
+    Applies the given input method event \a event to the text of the line
+    control
+*/
+void QLineControl::processInputMethodEvent(QInputMethodEvent *event)
+{
+    int priorState = m_undoState;
+    removeSelectedText();
+
+    int c = m_cursor; // cursor position after insertion of commit string
+    if (event->replacementStart() <= 0)
+        c += event->commitString().length() + qMin(-event->replacementStart(), event->replacementLength());
+
+    m_cursor += event->replacementStart();
+
+    // insert commit string
+    if (event->replacementLength()) {
+        m_selstart = m_cursor;
+        m_selend = m_selstart + event->replacementLength();
+        removeSelectedText();
+    }
+    if (!event->commitString().isEmpty())
+        insert(event->commitString());
+
+    m_cursor = qMin(c, m_text.length());
+
+    setPreeditArea(m_cursor, event->preeditString());
+    m_preeditCursor = event->preeditString().length();
+    m_hideCursor = false;
+    QList<QTextLayout::FormatRange> formats;
+    for (int i = 0; i < event->attributes().size(); ++i) {
+        const QInputMethodEvent::Attribute &a = event->attributes().at(i);
+        if (a.type == QInputMethodEvent::Cursor) {
+            m_preeditCursor = a.start;
+            m_hideCursor = !a.length;
+        } else if (a.type == QInputMethodEvent::TextFormat) {
+            QTextCharFormat f = qvariant_cast<QTextFormat>(a.value).toCharFormat();
+            if (f.isValid()) {
+                QTextLayout::FormatRange o;
+                o.start = a.start + m_cursor;
+                o.length = a.length;
+                o.format = f;
+                formats.append(o);
+            }
+        }
+    }
+    m_textLayout.setAdditionalFormats(formats);
+    updateDisplayText();
+    if (!event->commitString().isEmpty())
+        emitCursorPositionChanged();
+    finishChange(priorState);
+}
+
+/*!
+    \internal
+
+    Draws the display text for the line control using the given 
+    \a painter, \a clip, and \a offset.  Which aspects of the display text
+    are drawn is specified by the given \a flags.
+
+    If the flags contain DrawSelections, then the selection or input mask
+    backgrounds and foregrounds will be applied before drawing the text.
+
+    If the flags contain DrawCursor a cursor of the current cursorWidth()
+    will be drawn after drawing the text.
+
+    The display text will only be drawn if the flags contain DrawText
+*/
+void QLineControl::draw(QPainter *painter, const QPoint &offset, const QRect &clip, int flags)
+{
+    QVector<QTextLayout::FormatRange> selections;
+    if (flags & DrawSelections) {
+        QTextLayout::FormatRange o;
+        if (m_selstart < m_selend) {
+            o.start = m_selstart;
+            o.length = m_selend - m_selstart;
+            o.format.setBackground(m_palette.brush(QPalette::Highlight));
+            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));
+        }
+        selections.append(o);
+    }
+
+    if (flags & DrawText)
+        m_textLayout.draw(painter, offset, selections, clip);
+
+    if (flags & DrawCursor){
+        if(!m_blinkPeriod || m_blinkStatus)
+            m_textLayout.drawCursor(painter, offset, m_cursor, m_cursorWidth);
+    }
+}
+
+/*!
+    \internal
+
+    Sets the selection to cover the word at the given cursor position.
+    The word boundries is defined by the behavior of QTextLayout::SkipWords
+    cursor mode.
+*/
+void QLineControl::selectWordAtPos(int cursor)
+{
+    int c = m_textLayout.previousCursorPosition(cursor, QTextLayout::SkipWords);
+    moveCursor(c, false);
+    // ## text layout should support end of words.
+    int end = m_textLayout.nextCursorPosition(cursor, QTextLayout::SkipWords);
+    while (end > cursor && m_text[end-1].isSpace())
+        --end;
+    moveCursor(end, true);
+}
+
+/*!
+    \internal
+
+    Completes a change to the line control text.  If the change is not valid
+    will undo the line control state back to the given \a validateFromState.
+
+    If \a edited is true and the change is valid, will emit textEdited() in
+    addition to textChanged().  Otherwise only emits textChanged() on a valid
+    change.
+
+    The \a update value is currently unused.
+*/
+bool QLineControl::finishChange(int validateFromState, bool update, bool edited)
+{
+    Q_UNUSED(update)
+    bool lineDirty = m_selDirty;
+    if (m_textDirty) {
+        // do validation
+        bool wasValidInput = m_validInput;
+        m_validInput = true;
+#ifndef QT_NO_VALIDATOR
+        if (m_validator) {
+            m_validInput = false;
+            QString textCopy = m_text;
+            int cursorCopy = m_cursor;
+            m_validInput = (m_validator->validate(textCopy, cursorCopy) != QValidator::Invalid);
+            if (m_validInput) {
+                if (m_text != textCopy) {
+                    internalSetText(textCopy, cursorCopy);
+                    return true;
+                }
+                m_cursor = cursorCopy;
+            }
+        }
+#endif
+        if (validateFromState >= 0 && wasValidInput && !m_validInput) {
+            if (m_transactions.count())
+                return false;
+            internalUndo(validateFromState);
+            m_history.resize(m_undoState);
+            if (m_modifiedState > m_undoState)
+                m_modifiedState = -1;
+            m_validInput = true;
+            m_textDirty = false;
+        }
+        updateDisplayText();
+        lineDirty |= m_textDirty;
+        if (m_textDirty) {
+            m_textDirty = false;
+            QString actualText = text();
+            if (edited)
+                emit textEdited(actualText);
+            emit textChanged(actualText);
+        }
+    }
+    if (m_selDirty) {
+        m_selDirty = false;
+        emit selectionChanged();
+    }
+    emitCursorPositionChanged();
+    return true;
+}
+
+/*!
+    \internal
+
+    An internal function for setting the text of the line control.
+*/
+void QLineControl::internalSetText(const QString &txt, int pos, bool edited)
+{
+    internalDeselect();
+    emit resetInputContext();
+    QString oldText = m_text;
+    if (m_maskData) {
+        m_text = maskString(0, txt, true);
+        m_text += clearString(m_text.length(), m_maxLength - m_text.length());
+    } else {
+        m_text = txt.isEmpty() ? txt : txt.left(m_maxLength);
+    }
+    m_history.clear();
+    m_modifiedState =  m_undoState = 0;
+    m_cursor = (pos < 0 || pos > m_text.length()) ? m_text.length() : pos;
+    m_textDirty = (oldText != m_text);
+    finishChange(-1, true, edited);
+}
+
+
+/*!
+    \internal
+
+    Adds the given \a command to the undo history
+    of the line control.  Does not apply the command.
+*/
+void QLineControl::addCommand(const Command &cmd)
+{
+    if (m_separator && m_undoState && m_history[m_undoState - 1].type != Separator) {
+        m_history.resize(m_undoState + 2);
+        m_history[m_undoState++] = Command(Separator, m_cursor, 0, m_selstart, m_selend);
+    } else {
+        m_history.resize(m_undoState + 1);
+    }
+    m_separator = false;
+    m_history[m_undoState++] = cmd;
+}
+
+/*!
+    \internal
+
+    Inserts the given string \a s into the line
+    control.
+
+    Also adds the appropriate commands into the undo history.
+    This function does not call finishChange(), and may leave the text
+    in an invalid state.
+*/
+void QLineControl::internalInsert(const QString &s)
+{
+    if (hasSelectedText())
+        addCommand(Command(SetSelection, m_cursor, 0, m_selstart, m_selend));
+    if (m_maskData) {
+        QString ms = maskString(m_cursor, s);
+        for (int i = 0; i < (int) ms.length(); ++i) {
+            addCommand (Command(DeleteSelection, m_cursor + i, m_text.at(m_cursor + i), -1, -1));
+            addCommand(Command(Insert, m_cursor + i, ms.at(i), -1, -1));
+        }
+        m_text.replace(m_cursor, ms.length(), ms);
+        m_cursor += ms.length();
+        m_cursor = nextMaskBlank(m_cursor);
+        m_textDirty = true;
+    } else {
+        int remaining = m_maxLength - m_text.length();
+        if (remaining != 0) {
+            m_text.insert(m_cursor, s.left(remaining));
+            for (int i = 0; i < (int) s.left(remaining).length(); ++i)
+               addCommand(Command(Insert, m_cursor++, s.at(i), -1, -1));
+            m_textDirty = true;
+        }
+    }
+}
+
+/*!
+    \internal
+
+    deletes a single character from the current text.  If \a wasBackspace,
+    the character prior to the cursor is removed.  Otherwise the character
+    after the cursor is removed.
+
+    Also adds the appropriate commands into the undo history.
+    This function does not call finishChange(), and may leave the text
+    in an invalid state.
+*/
+void QLineControl::internalDelete(bool wasBackspace)
+{
+    if (m_cursor < (int) m_text.length()) {
+        if (hasSelectedText())
+            addCommand(Command(SetSelection, m_cursor, 0, m_selstart, m_selend));
+        addCommand(Command((CommandType)((m_maskData ? 2 : 0) + (wasBackspace ? Remove : Delete)),
+                   m_cursor, m_text.at(m_cursor), -1, -1));
+        if (m_maskData) {
+            m_text.replace(m_cursor, 1, clearString(m_cursor, 1));
+            addCommand(Command(Insert, m_cursor, m_text.at(m_cursor), -1, -1));
+        } else {
+            m_text.remove(m_cursor, 1);
+        }
+        m_textDirty = true;
+    }
+}
+
+/*!
+    \internal
+
+    removes the currently selected text from the line control.
+
+    Also adds the appropriate commands into the undo history.
+    This function does not call finishChange(), and may leave the text
+    in an invalid state.
+*/
+void QLineControl::removeSelectedText()
+{
+    if (m_selstart < m_selend && m_selend <= (int) m_text.length()) {
+        separate();
+        int i ;
+        addCommand(Command(SetSelection, m_cursor, 0, m_selstart, m_selend));
+        if (m_selstart <= m_cursor && m_cursor < m_selend) {
+            // cursor is within the selection. Split up the commands
+            // to be able to restore the correct cursor position
+            for (i = m_cursor; i >= m_selstart; --i)
+                addCommand (Command(DeleteSelection, i, m_text.at(i), -1, 1));
+            for (i = m_selend - 1; i > m_cursor; --i)
+                addCommand (Command(DeleteSelection, i - m_cursor + m_selstart - 1, m_text.at(i), -1, -1));
+        } else {
+            for (i = m_selend-1; i >= m_selstart; --i)
+                addCommand (Command(RemoveSelection, i, m_text.at(i), -1, -1));
+        }
+        if (m_maskData) {
+            m_text.replace(m_selstart, m_selend - m_selstart,  clearString(m_selstart, m_selend - m_selstart));
+            for (int i = 0; i < m_selend - m_selstart; ++i)
+                addCommand(Command(Insert, m_selstart + i, m_text.at(m_selstart + i), -1, -1));
+        } else {
+            m_text.remove(m_selstart, m_selend - m_selstart);
+        }
+        if (m_cursor > m_selstart)
+            m_cursor -= qMin(m_cursor, m_selend) - m_selstart;
+        internalDeselect();
+        m_textDirty = true;
+    }
+}
+
+/*!
+    \internal
+
+    Parses the input mask specified by \a maskFields to generate
+    the mask data used to handle input masks.
+*/
+void QLineControl::parseInputMask(const QString &maskFields)
+{
+    int delimiter = maskFields.indexOf(QLatin1Char(';'));
+    if (maskFields.isEmpty() || delimiter == 0) {
+        if (m_maskData) {
+            delete [] m_maskData;
+            m_maskData = 0;
+            m_maxLength = 32767;
+            internalSetText(QString());
+        }
+        return;
+    }
+
+    if (delimiter == -1) {
+        m_blank = QLatin1Char(' ');
+        m_inputMask = maskFields;
+    } else {
+        m_inputMask = maskFields.left(delimiter);
+        m_blank = (delimiter + 1 < maskFields.length()) ? maskFields[delimiter + 1] : QLatin1Char(' ');
+    }
+
+    // calculate m_maxLength / m_maskData length
+    m_maxLength = 0;
+    QChar c = 0;
+    for (int i=0; i<m_inputMask.length(); i++) {
+        c = m_inputMask.at(i);
+        if (i > 0 && m_inputMask.at(i-1) == QLatin1Char('\\')) {
+            m_maxLength++;
+            continue;
+        }
+        if (c != QLatin1Char('\\') && c != QLatin1Char('!') &&
+             c != QLatin1Char('<') && c != QLatin1Char('>') &&
+             c != QLatin1Char('{') && c != QLatin1Char('}') &&
+             c != QLatin1Char('[') && c != QLatin1Char(']'))
+            m_maxLength++;
+    }
+
+    delete [] m_maskData;
+    m_maskData = new MaskInputData[m_maxLength];
+
+    MaskInputData::Casemode m = MaskInputData::NoCaseMode;
+    c = 0;
+    bool s;
+    bool escape = false;
+    int index = 0;
+    for (int i = 0; i < m_inputMask.length(); i++) {
+        c = m_inputMask.at(i);
+        if (escape) {
+            s = true;
+            m_maskData[index].maskChar = c;
+            m_maskData[index].separator = s;
+            m_maskData[index].caseMode = m;
+            index++;
+            escape = false;
+        } else if (c == QLatin1Char('<')) {
+                m = MaskInputData::Lower;
+        } else if (c == QLatin1Char('>')) {
+            m = MaskInputData::Upper;
+        } else if (c == QLatin1Char('!')) {
+            m = MaskInputData::NoCaseMode;
+        } else if (c != QLatin1Char('{') && c != QLatin1Char('}') && c != QLatin1Char('[') && c != QLatin1Char(']')) {
+            switch (c.unicode()) {
+            case 'A':
+            case 'a':
+            case 'N':
+            case 'n':
+            case 'X':
+            case 'x':
+            case '9':
+            case '0':
+            case 'D':
+            case 'd':
+            case '#':
+            case 'H':
+            case 'h':
+            case 'B':
+            case 'b':
+                s = false;
+                break;
+            case '\\':
+                escape = true;
+            default:
+                s = true;
+                break;
+            }
+
+            if (!escape) {
+                m_maskData[index].maskChar = c;
+                m_maskData[index].separator = s;
+                m_maskData[index].caseMode = m;
+                index++;
+            }
+        }
+    }
+    internalSetText(m_text);
+}
+
+
+/*!
+    \internal
+
+    checks if the key is valid compared to the inputMask
+*/
+bool QLineControl::isValidInput(QChar key, QChar mask) const
+{
+    switch (mask.unicode()) {
+    case 'A':
+        if (key.isLetter())
+            return true;
+        break;
+    case 'a':
+        if (key.isLetter() || key == m_blank)
+            return true;
+        break;
+    case 'N':
+        if (key.isLetterOrNumber())
+            return true;
+        break;
+    case 'n':
+        if (key.isLetterOrNumber() || key == m_blank)
+            return true;
+        break;
+    case 'X':
+        if (key.isPrint())
+            return true;
+        break;
+    case 'x':
+        if (key.isPrint() || key == m_blank)
+            return true;
+        break;
+    case '9':
+        if (key.isNumber())
+            return true;
+        break;
+    case '0':
+        if (key.isNumber() || key == m_blank)
+            return true;
+        break;
+    case 'D':
+        if (key.isNumber() && key.digitValue() > 0)
+            return true;
+        break;
+    case 'd':
+        if ((key.isNumber() && key.digitValue() > 0) || key == m_blank)
+            return true;
+        break;
+    case '#':
+        if (key.isNumber() || key == QLatin1Char('+') || key == QLatin1Char('-') || key == m_blank)
+            return true;
+        break;
+    case 'B':
+        if (key == QLatin1Char('0') || key == QLatin1Char('1'))
+            return true;
+        break;
+    case 'b':
+        if (key == QLatin1Char('0') || key == QLatin1Char('1') || key == m_blank)
+            return true;
+        break;
+    case 'H':
+        if (key.isNumber() || (key >= QLatin1Char('a') && key <= QLatin1Char('f')) || (key >= QLatin1Char('A') && key <= QLatin1Char('F')))
+            return true;
+        break;
+    case 'h':
+        if (key.isNumber() || (key >= QLatin1Char('a') && key <= QLatin1Char('f')) || (key >= QLatin1Char('A') && key <= QLatin1Char('F')) || key == m_blank)
+            return true;
+        break;
+    default:
+        break;
+    }
+    return false;
+}
+
+/*!
+    \internal
+
+    Returns true if the given text \a str is valid for any
+    validator or input mask set for the line control.
+
+    Otherwise returns false
+*/
+bool QLineControl::hasAcceptableInput(const QString &str) const
+{
+#ifndef QT_NO_VALIDATOR
+    QString textCopy = str;
+    int cursorCopy = m_cursor;
+    if (m_validator && m_validator->validate(textCopy, cursorCopy)
+        != QValidator::Acceptable)
+        return false;
+#endif
+
+    if (!m_maskData)
+        return true;
+
+    if (str.length() != m_maxLength)
+        return false;
+
+    for (int i=0; i < m_maxLength; ++i) {
+        if (m_maskData[i].separator) {
+            if (str.at(i) != m_maskData[i].maskChar)
+                return false;
+        } else {
+            if (!isValidInput(str.at(i), m_maskData[i].maskChar))
+                return false;
+        }
+    }
+    return true;
+}
+
+/*!
+    \internal
+
+    Applies the inputMask on \a str starting from position \a pos in the mask. \a clear
+    specifies from where characters should be gotten when a separator is met in \a str - true means
+    that blanks will be used, false that previous input is used.
+    Calling this when no inputMask is set is undefined.
+*/
+QString QLineControl::maskString(uint pos, const QString &str, bool clear) const
+{
+    if (pos >= (uint)m_maxLength)
+        return QString::fromLatin1("");
+
+    QString fill;
+    fill = clear ? clearString(0, m_maxLength) : m_text;
+
+    int strIndex = 0;
+    QString s = QString::fromLatin1("");
+    int i = pos;
+    while (i < m_maxLength) {
+        if (strIndex < str.length()) {
+            if (m_maskData[i].separator) {
+                s += m_maskData[i].maskChar;
+                if (str[(int)strIndex] == m_maskData[i].maskChar)
+                    strIndex++;
+                ++i;
+            } else {
+                if (isValidInput(str[(int)strIndex], m_maskData[i].maskChar)) {
+                    switch (m_maskData[i].caseMode) {
+                    case MaskInputData::Upper:
+                        s += str[(int)strIndex].toUpper();
+                        break;
+                    case MaskInputData::Lower:
+                        s += str[(int)strIndex].toLower();
+                        break;
+                    default:
+                        s += str[(int)strIndex];
+                    }
+                    ++i;
+                } else {
+                    // search for separator first
+                    int n = findInMask(i, true, true, str[(int)strIndex]);
+                    if (n != -1) {
+                        if (str.length() != 1 || i == 0 || (i > 0 && (!m_maskData[i-1].separator || m_maskData[i-1].maskChar != str[(int)strIndex]))) {
+                            s += fill.mid(i, n-i+1);
+                            i = n + 1; // update i to find + 1
+                        }
+                    } else {
+                        // search for valid m_blank if not
+                        n = findInMask(i, true, false, str[(int)strIndex]);
+                        if (n != -1) {
+                            s += fill.mid(i, n-i);
+                            switch (m_maskData[n].caseMode) {
+                            case MaskInputData::Upper:
+                                s += str[(int)strIndex].toUpper();
+                                break;
+                            case MaskInputData::Lower:
+                                s += str[(int)strIndex].toLower();
+                                break;
+                            default:
+                                s += str[(int)strIndex];
+                            }
+                            i = n + 1; // updates i to find + 1
+                        }
+                    }
+                }
+                ++strIndex;
+            }
+        } else
+            break;
+    }
+
+    return s;
+}
+
+
+
+/*!
+    \internal
+
+    Returns a "cleared" string with only separators and blank chars.
+    Calling this when no inputMask is set is undefined.
+*/
+QString QLineControl::clearString(uint pos, uint len) const
+{
+    if (pos >= (uint)m_maxLength)
+        return QString();
+
+    QString s;
+    int end = qMin((uint)m_maxLength, pos + len);
+    for (int i = pos; i < end; ++i)
+        if (m_maskData[i].separator)
+            s += m_maskData[i].maskChar;
+        else
+            s += m_blank;
+
+    return s;
+}
+
+/*!
+    \internal
+
+    Strips blank parts of the input in a QLineControl when an inputMask is set,
+    separators are still included. Typically "127.0__.0__.1__" becomes "127.0.0.1".
+*/
+QString QLineControl::stripString(const QString &str) const
+{
+    if (!m_maskData)
+        return str;
+
+    QString s;
+    int end = qMin(m_maxLength, (int)str.length());
+    for (int i = 0; i < end; ++i)
+        if (m_maskData[i].separator)
+            s += m_maskData[i].maskChar;
+        else
+            if (str[i] != m_blank)
+                s += str[i];
+
+    return s;
+}
+
+/*!
+    \internal
+    searches forward/backward in m_maskData for either a separator or a m_blank
+*/
+int QLineControl::findInMask(int pos, bool forward, bool findSeparator, QChar searchChar) const
+{
+    if (pos >= m_maxLength || pos < 0)
+        return -1;
+
+    int end = forward ? m_maxLength : -1;
+    int step = forward ? 1 : -1;
+    int i = pos;
+
+    while (i != end) {
+        if (findSeparator) {
+            if (m_maskData[i].separator && m_maskData[i].maskChar == searchChar)
+                return i;
+        } else {
+            if (!m_maskData[i].separator) {
+                if (searchChar.isNull())
+                    return i;
+                else if (isValidInput(searchChar, m_maskData[i].maskChar))
+                    return i;
+            }
+        }
+        i += step;
+    }
+    return -1;
+}
+
+void QLineControl::internalUndo(int until)
+{
+    if (!isUndoAvailable())
+        return;
+    internalDeselect();
+    while (m_undoState && m_undoState > until) {
+        Command& cmd = m_history[--m_undoState];
+        switch (cmd.type) {
+        case Insert:
+            m_text.remove(cmd.pos, 1);
+            m_cursor = cmd.pos;
+            break;
+        case SetSelection:
+            m_selstart = cmd.selStart;
+            m_selend = cmd.selEnd;
+            m_cursor = cmd.pos;
+            break;
+        case Remove:
+        case RemoveSelection:
+            m_text.insert(cmd.pos, cmd.uc);
+            m_cursor = cmd.pos + 1;
+            break;
+        case Delete:
+        case DeleteSelection:
+            m_text.insert(cmd.pos, cmd.uc);
+            m_cursor = cmd.pos;
+            break;
+        case Separator:
+            continue;
+        }
+        if (until < 0 && m_undoState) {
+            Command& next = m_history[m_undoState-1];
+            if (next.type != cmd.type && next.type < RemoveSelection
+                 && (cmd.type < RemoveSelection || next.type == Separator))
+                break;
+        }
+    }
+    m_textDirty = true;
+    emitCursorPositionChanged();
+}
+
+void QLineControl::internalRedo()
+{
+    if (!isRedoAvailable())
+        return;
+    internalDeselect();
+    while (m_undoState < (int)m_history.size()) {
+        Command& cmd = m_history[m_undoState++];
+        switch (cmd.type) {
+        case Insert:
+            m_text.insert(cmd.pos, cmd.uc);
+            m_cursor = cmd.pos + 1;
+            break;
+        case SetSelection:
+            m_selstart = cmd.selStart;
+            m_selend = cmd.selEnd;
+            m_cursor = cmd.pos;
+            break;
+        case Remove:
+        case Delete:
+        case RemoveSelection:
+        case DeleteSelection:
+            m_text.remove(cmd.pos, 1);
+            m_selstart = cmd.selStart;
+            m_selend = cmd.selEnd;
+            m_cursor = cmd.pos;
+            break;
+        case Separator:
+            m_selstart = cmd.selStart;
+            m_selend = cmd.selEnd;
+            m_cursor = cmd.pos;
+            break;
+        }
+        if (m_undoState < (int)m_history.size()) {
+            Command& next = m_history[m_undoState];
+            if (next.type != cmd.type && cmd.type < RemoveSelection && next.type != Separator
+                 && (next.type < RemoveSelection || cmd.type == Separator))
+                break;
+        }
+    }
+    m_textDirty = true;
+    emitCursorPositionChanged();
+}
+
+/*!
+    \internal
+
+    If the current cursor position differs from the last emited cursor
+    position, emits cursorPositionChanged().
+*/
+void QLineControl::emitCursorPositionChanged()
+{
+    if (m_cursor != m_lastCursorPos) {
+        const int oldLast = m_lastCursorPos;
+        m_lastCursorPos = m_cursor;
+        cursorPositionChanged(oldLast, m_cursor);
+    }
+}
+
+#ifndef QT_NO_COMPLETER
+// iterating forward(dir=1)/backward(dir=-1) from the
+// current row based. dir=0 indicates a new completion prefix was set.
+bool QLineControl::advanceToEnabledItem(int dir)
+{
+    int start = m_completer->currentRow();
+    if (start == -1)
+        return false;
+    int i = start + dir;
+    if (dir == 0) dir = 1;
+    do {
+        if (!m_completer->setCurrentRow(i)) {
+            if (!m_completer->wrapAround())
+                break;
+            i = i > 0 ? 0 : m_completer->completionCount() - 1;
+        } else {
+            QModelIndex currentIndex = m_completer->currentIndex();
+            if (m_completer->completionModel()->flags(currentIndex) & Qt::ItemIsEnabled)
+                return true;
+            i += dir;
+        }
+    } while (i != start);
+
+    m_completer->setCurrentRow(start); // restore
+    return false;
+}
+
+void QLineControl::complete(int key)
+{
+    if (!m_completer || isReadOnly() || echoMode() != QLineEdit::Normal)
+        return;
+
+    QString text = this->text();
+    if (m_completer->completionMode() == QCompleter::InlineCompletion) {
+        if (key == Qt::Key_Backspace)
+            return;
+        int n = 0;
+        if (key == Qt::Key_Up || key == Qt::Key_Down) {
+            if (textAfterSelection().length())
+                return;
+            QString prefix = hasSelectedText() ? textBeforeSelection()
+                : text;
+            if (text.compare(m_completer->currentCompletion(), m_completer->caseSensitivity()) != 0
+                || prefix.compare(m_completer->completionPrefix(), m_completer->caseSensitivity()) != 0) {
+                m_completer->setCompletionPrefix(prefix);
+            } else {
+                n = (key == Qt::Key_Up) ? -1 : +1;
+            }
+        } else {
+            m_completer->setCompletionPrefix(text);
+        }
+        if (!advanceToEnabledItem(n))
+            return;
+    } else {
+#ifndef QT_KEYPAD_NAVIGATION
+        if (text.isEmpty()) {
+            m_completer->popup()->hide();
+            return;
+        }
+#endif
+        m_completer->setCompletionPrefix(text);
+    }
+
+    m_completer->complete();
+}
+#endif
+
+void QLineControl::setCursorBlinkPeriod(int msec)
+{
+    if (msec == m_blinkPeriod)
+        return;
+    if (m_blinkTimer) {
+        killTimer(m_blinkTimer);
+    }
+    if (msec) {
+        m_blinkTimer = startTimer(msec / 2);
+        m_blinkStatus = 1;
+    } else {
+        m_blinkTimer = 0;
+        if (m_blinkStatus == 0)
+            emit updateNeeded(inputMask().isEmpty() ? cursorRect() : QRect());
+    }
+    m_blinkPeriod = msec;
+}
+
+void QLineControl::timerEvent(QTimerEvent *event)
+{
+    if (event->timerId() == m_blinkTimer) {
+        m_blinkStatus = !m_blinkStatus;
+        emit updateNeeded(inputMask().isEmpty() ? cursorRect() : QRect());
+    } else if (event->timerId() == m_deleteAllTimer) {
+        killTimer(m_deleteAllTimer);
+        m_deleteAllTimer = 0;
+        clear();
+    } else if (event->timerId() == m_tripleClickTimer) {
+        killTimer(m_tripleClickTimer);
+        m_tripleClickTimer = 0;
+    }
+}
+
+bool QLineControl::processEvent(QEvent* ev)
+{
+#ifdef QT_KEYPAD_NAVIGATION
+    if (QApplication::keypadNavigationEnabled()) {
+        if ((ev->type() == QEvent::KeyPress) || (ev->type() == QEvent::KeyRelease)) {
+            QKeyEvent *ke = (QKeyEvent *)ev;
+            if (ke->key() == Qt::Key_Back) {
+                if (ke->isAutoRepeat()) {
+                    // Swallow it. We don't want back keys running amok.
+                    ke->accept();
+                    return true;
+                }
+                if ((ev->type() == QEvent::KeyRelease)
+                    && !isReadOnly()
+                    && deleteAllTimer) {
+                    killTimer(m_deleteAllTimer);
+                    m_deleteAllTimer = 0;
+                    backspace();
+                    ke->accept();
+                    return true;
+                }
+            }
+        }
+    }
+#endif
+    switch(ev->type()){
+#ifndef QT_NO_GRAPHICSVIEW
+        case QEvent::GraphicsSceneMouseMove:
+        case QEvent::GraphicsSceneMouseRelease:
+        case QEvent::GraphicsSceneMousePress:{
+               QGraphicsSceneMouseEvent *gvEv = static_cast<QGraphicsSceneMouseEvent*>(ev);
+               QMouseEvent* mouse = new QMouseEvent(ev->type(),
+                    gvEv->pos().toPoint(), gvEv->button(), gvEv->buttons(), gvEv->modifiers());
+               processMouseEvent(mouse); break;
+        }
+#endif
+        case QEvent::MouseButtonPress:
+        case QEvent::MouseButtonRelease:
+        case QEvent::MouseButtonDblClick:
+        case QEvent::MouseMove:
+            processMouseEvent(static_cast<QMouseEvent*>(ev)); break;
+        case QEvent::KeyPress:
+        case QEvent::KeyRelease:
+            processKeyEvent(static_cast<QKeyEvent*>(ev)); break;
+        case QEvent::InputMethod:
+            processInputMethodEvent(static_cast<QInputMethodEvent*>(ev)); break;
+#ifndef QT_NO_SHORTCUT
+        case QEvent::ShortcutOverride:{
+            QKeyEvent* ke = static_cast<QKeyEvent*>(ev);
+            if (ke == QKeySequence::Copy
+                || ke == QKeySequence::Paste
+                || ke == QKeySequence::Cut
+                || ke == QKeySequence::Redo
+                || ke == QKeySequence::Undo
+                || ke == QKeySequence::MoveToNextWord
+                || ke == QKeySequence::MoveToPreviousWord
+                || ke == QKeySequence::MoveToStartOfDocument
+                || ke == QKeySequence::MoveToEndOfDocument
+                || ke == QKeySequence::SelectNextWord
+                || ke == QKeySequence::SelectPreviousWord
+                || ke == QKeySequence::SelectStartOfLine
+                || ke == QKeySequence::SelectEndOfLine
+                || ke == QKeySequence::SelectStartOfBlock
+                || ke == QKeySequence::SelectEndOfBlock
+                || ke == QKeySequence::SelectStartOfDocument
+                || ke == QKeySequence::SelectAll
+                || ke == QKeySequence::SelectEndOfDocument) {
+                ke->accept();
+            } else if (ke->modifiers() == Qt::NoModifier || ke->modifiers() == Qt::ShiftModifier
+                       || ke->modifiers() == Qt::KeypadModifier) {
+                if (ke->key() < Qt::Key_Escape) {
+                    ke->accept();
+                } else {
+                    switch (ke->key()) {
+                    case Qt::Key_Delete:
+                    case Qt::Key_Home:
+                    case Qt::Key_End:
+                    case Qt::Key_Backspace:
+                    case Qt::Key_Left:
+                    case Qt::Key_Right:
+                        ke->accept();
+                    default:
+                        break;
+                    }
+                }
+            }
+        }
+#endif
+        default:
+            return false;
+    }
+    return true;
+}
+
+void QLineControl::processMouseEvent(QMouseEvent* ev)
+{
+
+    switch (ev->type()) {
+        case QEvent::GraphicsSceneMousePress:
+        case QEvent::MouseButtonPress:{
+            if (m_tripleClickTimer
+                && (ev->pos() - m_tripleClick).manhattanLength()
+                    < QApplication::startDragDistance()) {
+                selectAll();
+                return;
+            }
+            if (ev->button() == Qt::RightButton)
+                return;
+
+            bool mark = ev->modifiers() & Qt::ShiftModifier;
+            int cursor = xToPos(ev->pos().x());
+            moveCursor(cursor, mark);
+            break;
+        }
+        case QEvent::MouseButtonDblClick:
+            if (ev->button() == Qt::LeftButton) {
+                selectWordAtPos(xToPos(ev->pos().x()));
+                if (m_tripleClickTimer)
+                    killTimer(m_tripleClickTimer);
+                m_tripleClickTimer = startTimer(QApplication::doubleClickInterval());
+                m_tripleClick = ev->pos();
+            }
+            break;
+        case QEvent::GraphicsSceneMouseRelease:
+        case QEvent::MouseButtonRelease:
+#ifndef QT_NO_CLIPBOARD
+            if (QApplication::clipboard()->supportsSelection()) {
+                if (ev->button() == Qt::LeftButton) {
+                    copy(QClipboard::Selection);
+                } else if (!isReadOnly() && ev->button() == Qt::MidButton) {
+                    deselect();
+                    insert(QApplication::clipboard()->text(QClipboard::Selection));
+                }
+            }
+#endif
+            break;
+        case QEvent::GraphicsSceneMouseMove:
+        case QEvent::MouseMove:
+            if (ev->buttons() & Qt::LeftButton) {
+                moveCursor(xToPos(ev->pos().x()), true);
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+void QLineControl::processKeyEvent(QKeyEvent* event)
+{
+    bool inlineCompletionAccepted = false;
+
+#ifndef QT_NO_COMPLETER
+    if (m_completer) {
+        QCompleter::CompletionMode completionMode = m_completer->completionMode();
+        if ((completionMode == QCompleter::PopupCompletion
+             || completionMode == QCompleter::UnfilteredPopupCompletion)
+            && m_completer->popup()
+            && m_completer->popup()->isVisible()) {
+            // The following keys are forwarded by the completer to the widget
+            // Ignoring the events lets the completer provide suitable default behavior
+            switch (event->key()) {
+            case Qt::Key_Escape:
+                event->ignore();
+                return;
+            case Qt::Key_Enter:
+            case Qt::Key_Return:
+            case Qt::Key_F4:
+#ifdef QT_KEYPAD_NAVIGATION
+            case Qt::Key_Select:
+                if (!QApplication::keypadNavigationEnabled())
+                    break;
+#endif
+                m_completer->popup()->hide(); // just hide. will end up propagating to parent
+            default:
+                break; // normal key processing
+            }
+        } else if (completionMode == QCompleter::InlineCompletion) {
+            switch (event->key()) {
+            case Qt::Key_Enter:
+            case Qt::Key_Return:
+            case Qt::Key_F4:
+#ifdef QT_KEYPAD_NAVIGATION
+            case Qt::Key_Select:
+                if (!QApplication::keypadNavigationEnabled())
+                    break;
+#endif
+                if (!m_completer->currentCompletion().isEmpty() && hasSelectedText()
+                    && textAfterSelection().isEmpty()) {
+                    setText(m_completer->currentCompletion());
+                    inlineCompletionAccepted = true;
+                }
+            default:
+                break; // normal key processing
+            }
+        }
+    }
+#endif // QT_NO_COMPLETER
+
+    if (echoMode() == QLineEdit::PasswordEchoOnEdit
+        && !passwordEchoEditing()
+        && !isReadOnly()
+        && !event->text().isEmpty()
+#ifdef QT_KEYPAD_NAVIGATION
+        && event->key() != Qt::Key_Select
+        && event->key() != Qt::Key_Up
+        && event->key() != Qt::Key_Down
+        && event->key() != Qt::Key_Back
+#endif
+        && !(event->modifiers() & Qt::ControlModifier)) {
+        // Clear the edit and reset to normal echo mode while editing; the
+        // echo mode switches back when the edit loses focus
+        // ### resets current content.  dubious code; you can
+        // navigate with keys up, down, back, and select(?), but if you press
+        // "left" or "right" it clears?
+        updatePasswordEchoEditing(true);
+        clear();
+    }
+
+    if (event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return) {
+        if (hasAcceptableInput() || fixup()) {
+            emit accepted();
+            emit editingFinished();
+        }
+        if (inlineCompletionAccepted)
+            event->accept();
+        else
+            event->ignore();
+        return;
+    }
+    bool unknown = false;
+
+    if (false) {
+    }
+#ifndef QT_NO_SHORTCUT
+    else if (event == QKeySequence::Undo) {
+        if (!isReadOnly())
+            undo();
+    }
+    else if (event == QKeySequence::Redo) {
+        if (!isReadOnly())
+            redo();
+    }
+    else if (event == QKeySequence::SelectAll) {
+        selectAll();
+    }
+#ifndef QT_NO_CLIPBOARD
+    else if (event == QKeySequence::Copy) {
+        copy();
+    }
+    else if (event == QKeySequence::Paste) {
+        if (!isReadOnly())
+            paste();
+    }
+    else if (event == QKeySequence::Cut) {
+        if (!isReadOnly()) {
+            copy();
+            del();
+        }
+    }
+    else if (event == QKeySequence::DeleteEndOfLine) {
+        if (!isReadOnly()) {
+            setSelection(cursor(), end());
+            copy();
+            del();
+        }
+    }
+#endif //QT_NO_CLIPBOARD
+    else if (event == QKeySequence::MoveToStartOfLine) {
+        home(0);
+    }
+    else if (event == QKeySequence::MoveToEndOfLine) {
+        end(0);
+    }
+    else if (event == QKeySequence::SelectStartOfLine) {
+        home(1);
+    }
+    else if (event == QKeySequence::SelectEndOfLine) {
+        end(1);
+    }
+    else if (event == QKeySequence::MoveToNextChar) {
+#if !defined(Q_WS_WIN) || defined(QT_NO_COMPLETER)
+        if (hasSelectedText()) {
+#else
+        if (hasSelectedText() && m_completer
+            && m_completer->completionMode() == QCompleter::InlineCompletion) {
+#endif
+            moveCursor(selectionEnd(), false);
+        } else {
+            cursorForward(0, layoutDirection() == Qt::LeftToRight ? 1 : -1);
+        }
+    }
+    else if (event == QKeySequence::SelectNextChar) {
+        cursorForward(1, layoutDirection() == Qt::LeftToRight ? 1 : -1);
+    }
+    else if (event == QKeySequence::MoveToPreviousChar) {
+#if !defined(Q_WS_WIN) || defined(QT_NO_COMPLETER)
+        if (hasSelectedText()) {
+#else
+        if (hasSelectedText() && m_completer
+            && m_completer->completionMode() == QCompleter::InlineCompletion) {
+#endif
+            moveCursor(selectionStart(), false);
+        } else {
+            cursorForward(0, layoutDirection() == Qt::LeftToRight ? -1 : 1);
+        }
+    }
+    else if (event == QKeySequence::SelectPreviousChar) {
+        cursorForward(1, layoutDirection() == Qt::LeftToRight ? -1 : 1);
+    }
+    else if (event == QKeySequence::MoveToNextWord) {
+        if (echoMode() == QLineEdit::Normal)
+            layoutDirection() == Qt::LeftToRight ? cursorWordForward(0) : cursorWordBackward(0);
+        else
+            layoutDirection() == Qt::LeftToRight ? end(0) : home(0);
+    }
+    else if (event == QKeySequence::MoveToPreviousWord) {
+        if (echoMode() == QLineEdit::Normal)
+            layoutDirection() == Qt::LeftToRight ? cursorWordBackward(0) : cursorWordForward(0);
+        else if (!isReadOnly()) {
+            layoutDirection() == Qt::LeftToRight ? home(0) : end(0);
+        }
+    }
+    else if (event == QKeySequence::SelectNextWord) {
+        if (echoMode() == QLineEdit::Normal)
+            layoutDirection() == Qt::LeftToRight ? cursorWordForward(1) : cursorWordBackward(1);
+        else
+            layoutDirection() == Qt::LeftToRight ? end(1) : home(1);
+    }
+    else if (event == QKeySequence::SelectPreviousWord) {
+        if (echoMode() == QLineEdit::Normal)
+            layoutDirection() == Qt::LeftToRight ? cursorWordBackward(1) : cursorWordForward(1);
+        else
+            layoutDirection() == Qt::LeftToRight ? home(1) : end(1);
+    }
+    else if (event == QKeySequence::Delete) {
+        if (!isReadOnly())
+            del();
+    }
+    else if (event == QKeySequence::DeleteEndOfWord) {
+        if (!isReadOnly()) {
+            cursorWordForward(true);
+            del();
+        }
+    }
+    else if (event == QKeySequence::DeleteStartOfWord) {
+        if (!isReadOnly()) {
+            cursorWordBackward(true);
+            del();
+        }
+    }
+#endif // QT_NO_SHORTCUT
+    else {
+#ifdef Q_WS_MAC
+        if (event->key() == Qt::Key_Up || event->key() == Qt::Key_Down) {
+            Qt::KeyboardModifiers myModifiers = (event->modifiers() & ~Qt::KeypadModifier);
+            if (myModifiers & Qt::ShiftModifier) {
+                if (myModifiers == (Qt::ControlModifier|Qt::ShiftModifier)
+                        || myModifiers == (Qt::AltModifier|Qt::ShiftModifier)
+                        || myModifiers == Qt::ShiftModifier) {
+
+                    event->key() == Qt::Key_Up ? home(1) : end(1);
+                }
+            } else {
+                if ((myModifiers == Qt::ControlModifier
+                     || myModifiers == Qt::AltModifier
+                     || myModifiers == Qt::NoModifier)) {
+                    event->key() == Qt::Key_Up ? home(0) : end(0);
+                }
+            }
+        }
+#endif
+        if (event->modifiers() & Qt::ControlModifier) {
+            switch (event->key()) {
+            case Qt::Key_Backspace:
+                if (!isReadOnly()) {
+                    cursorWordBackward(true);
+                    del();
+                }
+                break;
+#ifndef QT_NO_COMPLETER
+            case Qt::Key_Up:
+            case Qt::Key_Down:
+                complete(event->key());
+                break;
+#endif
+#if defined(Q_WS_X11)
+            case Qt::Key_E:
+                end(0);
+                break;
+
+            case Qt::Key_U:
+                if (!isReadOnly()) {
+                    setSelection(0, text().size());
+#ifndef QT_NO_CLIPBOARD
+                    copy();
+#endif
+                    del();
+                }
+            break;
+#endif
+            default:
+                unknown = true;
+            }
+        } else { // ### check for *no* modifier
+            switch (event->key()) {
+            case Qt::Key_Backspace:
+                if (!isReadOnly()) {
+                    backspace();
+#ifndef QT_NO_COMPLETER
+                    complete(Qt::Key_Backspace);
+#endif
+                }
+                break;
+#ifdef QT_KEYPAD_NAVIGATION
+            case Qt::Key_Back:
+                if (QApplication::keypadNavigationEnabled() && !event->isAutoRepeat()
+                    && !isReadOnly()) {
+                    if (text().length() == 0) {
+                        setText(m_cancelText);
+
+                        if (passwordEchoEditing)
+                            updatePasswordEchoEditing(false);
+
+                        setEditFocus(false);
+                    } else if (!deleteAllTimer) {
+                        deleteAllTimer = startTimer(750);
+                    }
+                } else {
+                    unknown = true;
+                }
+                break;
+#endif
+
+            default:
+                unknown = true;
+            }
+        }
+    }
+
+    if (event->key() == Qt::Key_Direction_L || event->key() == Qt::Key_Direction_R) {
+        setLayoutDirection((event->key() == Qt::Key_Direction_L) ? Qt::LeftToRight : Qt::RightToLeft);
+        unknown = false;
+    }
+
+    if (unknown && !isReadOnly()) {
+        QString t = event->text();
+        if (!t.isEmpty() && t.at(0).isPrint()) {
+            insert(t);
+#ifndef QT_NO_COMPLETER
+            complete(event->key());
+#endif
+            event->accept();
+            return;
+        }
+    }
+
+    if (unknown)
+        event->ignore();
+    else
+        event->accept();
+}
+
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/widgets/qlinecontrol_p.h b/src/gui/widgets/qlinecontrol_p.h
new file mode 100644
index 0000000..9cad857
--- /dev/null
+++ b/src/gui/widgets/qlinecontrol_p.h
@@ -0,0 +1,741 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QLINECONTROL_P_H
+#define QLINECONTROL_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qglobal.h"
+
+#ifndef QT_NO_LINEEDIT
+#include "private/qwidget_p.h"
+#include "QtGui/qlineedit.h"
+#include "QtGui/qtextlayout.h"
+#include "QtGui/qstyleoption.h"
+#include "QtCore/qpointer.h"
+#include "QtGui/qlineedit.h"
+#include "QtGui/qclipboard.h"
+#include "QtCore/qpoint.h"
+#include "QtGui/qcompleter.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class Q_GUI_EXPORT QLineControl : public QObject
+{
+    Q_OBJECT
+
+public:
+    QLineControl(const QString &txt = QString())
+        : m_cursor(0), m_preeditCursor(0), m_layoutDirection(Qt::LeftToRight),
+        m_hideCursor(false), m_separator(0), m_readOnly(0),
+        m_dragEnabled(0), m_echoMode(0), m_textDirty(0), m_selDirty(0),
+        m_validInput(1), m_blinkPeriod(0), m_blinkTimer(0), m_deleteAllTimer(0),
+        m_ascent(0), m_maxLength(32767), m_lastCursorPos(-1),
+        m_tripleClickTimer(0), m_maskData(0), m_modifiedState(0), m_undoState(0),
+        m_selstart(0), m_selend(0), m_passwordEchoEditing(false)
+    {
+        init(txt);
+    }
+
+    ~QLineControl()
+    {
+        delete [] m_maskData;
+    }
+
+    int nextMaskBlank(int pos);
+    int prevMaskBlank(int pos);
+
+    bool isUndoAvailable() const;
+    bool isRedoAvailable() const;
+    void clearUndo();
+    bool isModified() const;
+    void setModified(bool modified);
+
+    bool allSelected() const;
+    bool hasSelectedText() const;
+
+    int width() const;
+    int height() const;
+    int ascent() const;
+
+    void setSelection(int start, int length);
+
+    QString selectedText() const;
+    QString textBeforeSelection() const;
+    QString textAfterSelection() const;
+
+    int selectionStart() const;
+    int selectionEnd() const;
+    bool inSelection(int x) const;
+
+    void removeSelection();
+
+    int start() const;
+    int end() const;
+
+#ifndef QT_NO_CLIPBOARD
+    void copy(QClipboard::Mode mode = QClipboard::Clipboard) const;
+    void paste();
+#endif
+
+    int cursor() const;
+    int preeditCursor() const;
+
+    int cursorWidth() const;
+    void setCursorWidth(int value);
+
+    void moveCursor(int pos, bool mark = false);
+    void cursorForward(bool mark, int steps);
+    void cursorWordForward(bool mark);
+    void cursorWordBackward(bool mark);
+    void home(bool mark);
+    void end(bool mark);
+
+    int xToPos(int x, QTextLine::CursorPosition = QTextLine::CursorBetweenCharacters) const;
+    QRect cursorRect() const;
+
+    qreal cursorToX(int cursor) const;
+    qreal cursorToX() const;
+
+    bool isReadOnly() const;
+    void setReadOnly(bool enable);
+
+    QString text() const;
+    void setText(const QString &txt);
+
+    QString displayText() const;
+
+    void backspace();
+    void del();
+    void deselect();
+    void selectAll();
+    void insert(const QString &);
+    void clear();
+    void undo();
+    void redo();
+    void selectWordAtPos(int);
+
+    uint echoMode() const;
+    void setEchoMode(uint mode);
+
+    void setMaxLength(int maxLength);
+    int maxLength() const;
+
+    const QValidator *validator() const;
+    void setValidator(const QValidator *);
+
+#ifndef QT_NO_COMPLETER
+    QCompleter *completer() const;
+    void setCompleter(const QCompleter*);
+    void complete(int key);
+#endif
+
+    void setCursorPosition(int pos);
+    int cursorPosition() const;
+
+    bool hasAcceptableInput() const;
+    bool fixup();
+
+    QString inputMask() const;
+    void setInputMask(const QString &mask);
+
+    // input methods
+#ifndef QT_NO_IM
+    bool composeMode() const;
+    void setPreeditArea(int cursor, const QString &text);
+#endif
+
+    QString preeditAreaText() const;
+
+    void updatePasswordEchoEditing(bool editing);
+    bool passwordEchoEditing() const;
+
+    QChar passwordCharacter() const;
+    void setPasswordCharacter(const QChar &character);
+
+    Qt::LayoutDirection layoutDirection() const;
+    void setLayoutDirection(Qt::LayoutDirection direction);
+    void setFont(const QFont &font);
+
+    void processInputMethodEvent(QInputMethodEvent *event);
+    void processMouseEvent(QMouseEvent* ev);
+    void processKeyEvent(QKeyEvent* ev);
+
+    int cursorBlinkPeriod() const;
+    void setCursorBlinkPeriod(int msec);
+
+    QString cancelText() const;
+    void setCancelText(const QString &text);
+
+    enum DrawFlags {
+        DrawText = 0x01,
+        DrawSelections = 0x02,
+        DrawCursor = 0x04,
+        DrawAll = DrawText | DrawSelections | DrawCursor
+    };
+    void draw(QPainter *, const QPoint &, const QRect &, int flags = DrawAll);
+
+    bool processEvent(QEvent *ev);
+
+private:
+    void init(const QString &txt);
+    void removeSelectedText();
+    void internalSetText(const QString &txt, int pos = -1, bool edited = true);
+    void updateDisplayText();
+
+    void internalInsert(const QString &s);
+    void internalDelete(bool wasBackspace = false);
+    void internalRemove(int pos);
+
+    inline void internalDeselect()
+    {
+        m_selDirty |= (m_selend > m_selstart);
+        m_selstart = m_selend = 0;
+    }
+
+    void internalUndo(int until = -1);
+    void internalRedo();
+
+    QString m_text;
+    QPalette m_palette;
+    int m_cursor;
+    int m_preeditCursor;
+    int m_cursorWidth;
+    Qt::LayoutDirection m_layoutDirection;
+    uint m_hideCursor : 1; // used to hide the m_cursor inside preedit areas
+    uint m_separator : 1;
+    uint m_readOnly : 1;
+    uint m_dragEnabled : 1;
+    uint m_echoMode : 2;
+    uint m_textDirty : 1;
+    uint m_selDirty : 1;
+    uint m_validInput : 1;
+    int m_blinkPeriod; // 0 for non-blinking cursor
+    int m_blinkTimer;
+    int m_deleteAllTimer;
+    int m_blinkStatus;
+    int m_ascent;
+    int m_maxLength;
+    int m_lastCursorPos;
+    QList<int> m_transactions;
+    QPoint m_tripleClick;
+    int m_tripleClickTimer;
+    QString m_cancelText;
+
+    void emitCursorPositionChanged();
+
+    bool finishChange(int validateFromState = -1, bool update = false, bool edited = true);
+
+    QPointer<QValidator> m_validator;
+    QPointer<QCompleter> m_completer;
+#ifndef QT_NO_COMPLETER
+    bool advanceToEnabledItem(int dir);
+#endif
+
+    struct MaskInputData {
+        enum Casemode { NoCaseMode, Upper, Lower };
+        QChar maskChar; // either the separator char or the inputmask
+        bool separator;
+        Casemode caseMode;
+    };
+    QString m_inputMask;
+    QChar m_blank;
+    MaskInputData *m_maskData;
+
+    // undo/redo handling
+    enum CommandType { Separator, Insert, Remove, Delete, RemoveSelection, DeleteSelection, SetSelection };
+    struct Command {
+        inline Command() {}
+        inline Command(CommandType t, int p, QChar c, int ss, int se) : type(t),uc(c),pos(p),selStart(ss),selEnd(se) {}
+        uint type : 4;
+        QChar uc;
+        int pos, selStart, selEnd;
+    };
+    int m_modifiedState;
+    int m_undoState;
+    QVector<Command> m_history;
+    void addCommand(const Command& cmd);
+
+    inline void separate() { m_separator = true; }
+
+    // selection
+    int m_selstart;
+    int m_selend;
+
+    // masking
+    void parseInputMask(const QString &maskFields);
+    bool isValidInput(QChar key, QChar mask) const;
+    bool hasAcceptableInput(const QString &text) const;
+    QString maskString(uint pos, const QString &str, bool clear = false) const;
+    QString clearString(uint pos, uint len) const;
+    QString stripString(const QString &str) const;
+    int findInMask(int pos, bool forward, bool findSeparator, QChar searchChar = QChar()) const;
+
+    // complex text layout
+    QTextLayout m_textLayout;
+
+    bool m_passwordEchoEditing;
+    QChar m_passwordCharacter;
+
+Q_SIGNALS:
+    void cursorPositionChanged(int, int);
+    void selectionChanged();
+
+    void displayTextChanged(const QString &);
+    void textChanged(const QString &);
+    void textEdited(const QString &);
+
+    void resetInputContext();
+
+    void accepted();
+    void editingFinished();
+    void updateNeeded(const QRect &);
+
+protected:
+    virtual void timerEvent(QTimerEvent *event);
+
+private slots:
+    void _q_clipboardChanged();
+    void _q_deleteSelected();
+
+};
+
+inline int QLineControl::nextMaskBlank(int pos)
+{
+    int c = findInMask(pos, true, false);
+    m_separator |= (c != pos);
+    return (c != -1 ?  c : m_maxLength);
+}
+
+inline int QLineControl::prevMaskBlank(int pos)
+{
+    int c = findInMask(pos, false, false);
+    m_separator |= (c != pos);
+    return (c != -1 ? c : 0);
+}
+
+inline bool QLineControl::isUndoAvailable() const
+{ 
+    return !m_readOnly && m_undoState;
+}
+
+inline bool QLineControl::isRedoAvailable() const
+{
+    return !m_readOnly && m_undoState < (int)m_history.size();
+}
+
+inline void QLineControl::clearUndo()
+{
+    m_history.clear();
+    m_modifiedState = m_undoState = 0;
+}
+
+inline bool QLineControl::isModified() const
+{
+    return m_modifiedState != m_undoState;
+}
+
+inline void QLineControl::setModified(bool modified)
+{
+    m_modifiedState = modified ? -1 : m_undoState;
+}
+
+inline bool QLineControl::allSelected() const
+{
+    return !m_text.isEmpty() && m_selstart == 0 && m_selend == (int)m_text.length();
+}
+
+inline bool QLineControl::hasSelectedText() const
+{
+    return !m_text.isEmpty() && m_selend > m_selstart;
+}
+
+inline int QLineControl::width() const
+{
+    return qRound(m_textLayout.lineAt(0).width()) + 1;
+}
+
+inline int QLineControl::height() const
+{
+    return qRound(m_textLayout.lineAt(0).height()) + 1;
+}
+
+inline int QLineControl::ascent() const
+{
+    return m_ascent;
+}
+
+inline QString QLineControl::selectedText() const
+{
+    if (hasSelectedText())
+        return m_text.mid(m_selstart, m_selend - m_selstart);
+    return QString();
+}
+
+inline QString QLineControl::textBeforeSelection() const
+{
+    if (hasSelectedText())
+        return m_text.left(m_selstart);
+    return QString();
+}
+
+inline QString QLineControl::textAfterSelection() const
+{
+    if (hasSelectedText())
+        return m_text.mid(m_selend);
+    return QString();
+}
+
+inline int QLineControl::selectionStart() const
+{
+    return hasSelectedText() ? m_selstart : -1;
+}
+
+inline int QLineControl::selectionEnd() const
+{
+    return hasSelectedText() ? m_selend : -1;
+}
+
+inline int QLineControl::start() const
+{
+    return 0;
+}
+
+inline int QLineControl::end() const
+{
+    return m_text.length();
+}
+
+inline void QLineControl::removeSelection()
+{
+    int priorState = m_undoState;
+    removeSelectedText();
+    finishChange(priorState);
+}
+
+inline bool QLineControl::inSelection(int x) const
+{
+    if (m_selstart >= m_selend)
+        return false;
+    int pos = xToPos(x, QTextLine::CursorOnCharacter);
+    return pos >= m_selstart && pos < m_selend;
+}
+
+inline int QLineControl::cursor() const
+{
+    return m_cursor;
+}
+
+inline int QLineControl::preeditCursor() const
+{
+    return m_preeditCursor;
+}
+
+inline int QLineControl::cursorWidth() const
+{
+    return m_cursorWidth;
+}
+
+inline void QLineControl::setCursorWidth(int value)
+{
+    m_cursorWidth = value;
+}
+
+inline void QLineControl::cursorForward(bool mark, int steps)
+{
+    int c = m_cursor;
+    if (steps > 0) {
+        while (steps--)
+            c = m_textLayout.nextCursorPosition(c);
+    } else if (steps < 0) {
+        while (steps++)
+            c = m_textLayout.previousCursorPosition(c);
+    }
+    moveCursor(c, mark);
+}
+
+inline void QLineControl::cursorWordForward(bool mark)
+{
+    moveCursor(m_textLayout.nextCursorPosition(m_cursor, QTextLayout::SkipWords), mark);
+}
+
+inline void QLineControl::home(bool mark)
+{
+    moveCursor(0, mark);
+}
+
+inline void QLineControl::end(bool mark)
+{
+    moveCursor(text().length(), mark);
+}
+
+inline void QLineControl::cursorWordBackward(bool mark)
+{
+    moveCursor(m_textLayout.previousCursorPosition(m_cursor, QTextLayout::SkipWords), mark);
+}
+
+inline qreal QLineControl::cursorToX(int cursor) const
+{
+    return m_textLayout.lineAt(0).cursorToX(cursor);
+}
+
+inline qreal QLineControl::cursorToX() const
+{
+    return cursorToX(m_cursor);
+}
+
+inline bool QLineControl::isReadOnly() const
+{
+    return m_readOnly;
+}
+
+inline void QLineControl::setReadOnly(bool enable)
+{ 
+    m_readOnly = enable;
+}
+
+inline QString QLineControl::text() const
+{
+    QString res = m_maskData ? stripString(m_text) : m_text;
+    return (res.isNull() ? QString::fromLatin1("") : res);
+}
+
+inline void QLineControl::setText(const QString &txt)
+{
+    internalSetText(txt, -1, false);
+}
+
+inline QString QLineControl::displayText() const
+{
+    return m_textLayout.text();
+}
+
+inline void QLineControl::deselect()
+{
+    internalDeselect();
+    finishChange();
+}
+
+inline void QLineControl::selectAll()
+{
+    m_selstart = m_selend = m_cursor = 0;
+    moveCursor(m_text.length(), true);
+}
+
+inline void QLineControl::undo()
+{
+    internalUndo();
+    finishChange(-1, true);
+}
+
+inline void QLineControl::redo()
+{
+    internalRedo();
+    finishChange();
+}
+
+inline uint QLineControl::echoMode() const
+{
+    return m_echoMode;
+}
+
+inline void QLineControl::setEchoMode(uint mode)
+{
+    m_echoMode = mode;
+    m_passwordEchoEditing = false;
+    updateDisplayText();
+}
+
+inline void QLineControl::setMaxLength(int maxLength)
+{
+    if (m_maskData)
+        return;
+    m_maxLength = maxLength;
+    setText(m_text);
+}
+
+inline int QLineControl::maxLength() const
+{
+    return m_maxLength;
+}
+
+inline const QValidator *QLineControl::validator() const
+{
+    return m_validator;
+}
+
+inline void QLineControl::setValidator(const QValidator *v)
+{
+    m_validator = const_cast<QValidator*>(v);
+}
+
+#ifndef QT_NO_COMPLETER
+inline QCompleter *QLineControl::completer() const
+{
+    return m_completer;
+}
+
+/* Note that you must set the widget for the completer seperately */
+inline void QLineControl::setCompleter(const QCompleter* c)
+{
+    m_completer = const_cast<QCompleter*>(c);
+}
+#endif
+
+inline void QLineControl::setCursorPosition(int pos)
+{
+    if (pos < 0)
+        pos = 0;
+    if (pos < m_text.length())
+        moveCursor(pos);
+}
+
+inline int QLineControl::cursorPosition() const
+{
+    return m_cursor;
+}
+
+inline bool QLineControl::hasAcceptableInput() const
+{
+    return hasAcceptableInput(m_text);
+}
+
+inline QString QLineControl::inputMask() const
+{
+    return m_maskData ? m_inputMask + QLatin1Char(';') + m_blank : QString();
+}
+
+inline void QLineControl::setInputMask(const QString &mask)
+{
+    parseInputMask(mask);
+    if (m_maskData)
+        moveCursor(nextMaskBlank(0));
+}
+
+// input methods
+#ifndef QT_NO_IM
+inline bool QLineControl::composeMode() const
+{
+    return !m_textLayout.preeditAreaText().isEmpty();
+}
+
+inline void QLineControl::setPreeditArea(int cursor, const QString &text)
+{
+    m_textLayout.setPreeditArea(cursor, text);
+}
+#endif
+
+inline QString QLineControl::preeditAreaText() const
+{
+    return m_textLayout.preeditAreaText();
+}
+
+inline bool QLineControl::passwordEchoEditing() const
+{
+    return m_passwordEchoEditing;
+}
+
+inline QChar QLineControl::passwordCharacter() const
+{
+    return m_passwordCharacter;
+}
+
+inline void QLineControl::setPasswordCharacter(const QChar &character)
+{
+    m_passwordCharacter = character;
+    updateDisplayText();
+}
+
+inline Qt::LayoutDirection QLineControl::layoutDirection() const
+{
+    return m_layoutDirection;
+}
+
+inline void QLineControl::setLayoutDirection(Qt::LayoutDirection direction)
+{
+    if (direction != m_layoutDirection) {
+        m_layoutDirection = direction;
+        updateDisplayText();
+    }
+}
+
+inline void QLineControl::setFont(const QFont &font)
+{
+    m_textLayout.setFont(font);
+    updateDisplayText();
+}
+
+inline int QLineControl::cursorBlinkPeriod() const
+{
+    return m_blinkPeriod;
+}
+
+inline QString QLineControl::cancelText() const
+{
+    return m_cancelText;
+}
+
+inline void QLineControl::setCancelText(const QString &text)
+{
+    m_cancelText = text;
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_NO_LINEEDIT
+
+#endif // QLINECONTROL_P_H
diff --git a/src/gui/widgets/qlineedit.cpp b/src/gui/widgets/qlineedit.cpp
index 4d69a9f..01d4890 100644
--- a/src/gui/widgets/qlineedit.cpp
+++ b/src/gui/widgets/qlineedit.cpp
@@ -86,20 +86,12 @@
 
 #include <limits.h>
 
-#define verticalMargin 1
-#define horizontalMargin 2
-
 QT_BEGIN_NAMESPACE
 
 #ifdef Q_WS_MAC
 extern void qt_mac_secure_keyboard(bool); //qapplication_mac.cpp
 #endif
 
-static inline bool shouldEnableInputMethod(QLineEdit *lineedit)
-{
-    return !lineedit->isReadOnly();
-}
-
 /*!
     Initialize \a option with the values from this QLineEdit. This method
     is useful for subclasses when they need a QStyleOptionFrame or QStyleOptionFrameV2, but don't want
@@ -121,7 +113,7 @@ void QLineEdit::initStyleOption(QStyleOptionFrame *option) const
                                  : 0;
     option->midLineWidth = 0;
     option->state |= QStyle::State_Sunken;
-    if (d->readOnly)
+    if (d->control->isReadOnly())
         option->state |= QStyle::State_ReadOnly;
 #ifdef QT_KEYPAD_NAVIGATION
     if (hasEditFocus())
@@ -349,14 +341,9 @@ QLineEdit::QLineEdit(const QString& contents, const QString &inputMask, QWidget*
 {
     Q_D(QLineEdit);
     setObjectName(QString::fromAscii(name));
-    d->parseInputMask(inputMask);
-    if (d->maskData) {
-        QString ms = d->maskString(0, contents);
-        d->init(ms + d->clearString(ms.length(), d->maxLength - ms.length()));
-        d->cursor = d->nextMaskBlank(ms.length());
-    } else {
-        d->init(contents);
-    }
+    d->init(contents);
+    d->control->setInputMask(inputMask);
+    d->control->moveCursor(d->control->nextMaskBlank(contents.length()));
 }
 #endif
 
@@ -387,19 +374,13 @@ QLineEdit::~QLineEdit()
 QString QLineEdit::text() const
 {
     Q_D(const QLineEdit);
-    QString res = d->text;
-    if (d->maskData)
-        res = d->stripString(d->text);
-    return (res.isNull() ? QString::fromLatin1("") : res);
+    return d->control->text();
 }
 
 void QLineEdit::setText(const QString& text)
 {
     Q_D(QLineEdit);
-    d->setText(text, -1, false);
-#ifdef QT_KEYPAD_NAVIGATION
-    d->origText = d->text;
-#endif
+    d->control->setText(text);
 }
 
 
@@ -420,17 +401,7 @@ void QLineEdit::setText(const QString& text)
 QString QLineEdit::displayText() const
 {
     Q_D(const QLineEdit);
-    if (d->echoMode == NoEcho)
-        return QString::fromLatin1("");
-    QString res = d->text;
-
-    if (d->echoMode == Password || (d->echoMode == PasswordEchoOnEdit
-                                    && !d->passwordEchoEditing)) {
-        QStyleOptionFrameV2 opt;
-        initStyleOption(&opt);
-        res.fill(style()->styleHint(QStyle::SH_LineEdit_PasswordCharacter, &opt, this));
-    }
-    return (res.isNull() ? QString::fromLatin1("") : res);
+    return d->control->displayText();
 }
 
 
@@ -455,20 +426,15 @@ QString QLineEdit::displayText() const
 int QLineEdit::maxLength() const
 {
     Q_D(const QLineEdit);
-    return d->maxLength;
+    return d->control->maxLength();
 }
 
 void QLineEdit::setMaxLength(int maxLength)
 {
     Q_D(QLineEdit);
-    if (d->maskData)
-        return;
-    d->maxLength = maxLength;
-    setText(d->text);
+    d->control->setMaxLength(maxLength);
 }
 
-
-
 /*!
     \property QLineEdit::frame
     \brief whether the line edit draws itself with a frame
@@ -535,13 +501,13 @@ void QLineEdit::setFrame(bool enable)
 QLineEdit::EchoMode QLineEdit::echoMode() const
 {
     Q_D(const QLineEdit);
-    return (EchoMode) d->echoMode;
+    return (EchoMode) d->control->echoMode();
 }
 
 void QLineEdit::setEchoMode(EchoMode mode)
 {
     Q_D(QLineEdit);
-    if (mode == (EchoMode)d->echoMode)
+    if (mode == (EchoMode)d->control->echoMode())
         return;
     Qt::InputMethodHints imHints = inputMethodHints();
     if (mode == Password) {
@@ -550,13 +516,11 @@ void QLineEdit::setEchoMode(EchoMode mode)
         imHints &= ~Qt::ImhHiddenText;
     }
     setInputMethodHints(imHints);
-    d->echoMode = mode;
-    d->passwordEchoEditing = false;
-    d->updateTextLayout();
+    d->control->setEchoMode(mode);
     update();
 #ifdef Q_WS_MAC
     if (hasFocus())
-        qt_mac_secure_keyboard(d->echoMode == Password || d->echoMode == NoEcho);
+        qt_mac_secure_keyboard(mode == Password || mode == NoEcho);
 #endif
 }
 
@@ -572,7 +536,7 @@ void QLineEdit::setEchoMode(EchoMode mode)
 const QValidator * QLineEdit::validator() const
 {
     Q_D(const QLineEdit);
-    return d->validator;
+    return d->control->validator();
 }
 
 /*!
@@ -590,7 +554,7 @@ const QValidator * QLineEdit::validator() const
 void QLineEdit::setValidator(const QValidator *v)
 {
     Q_D(QLineEdit);
-    d->validator = const_cast<QValidator*>(v);
+    d->control->setValidator(v);
 }
 #endif // QT_NO_VALIDATOR
 
@@ -614,23 +578,23 @@ void QLineEdit::setValidator(const QValidator *v)
 void QLineEdit::setCompleter(QCompleter *c)
 {
     Q_D(QLineEdit);
-    if (c == d->completer)
+    if (c == d->control->completer())
         return;
-    if (d->completer) {
-        disconnect(d->completer, 0, this, 0);
-        d->completer->setWidget(0);
-        if (d->completer->parent() == this)
-            delete d->completer;
+    if (d->control->completer()) {
+        disconnect(d->control->completer(), 0, this, 0);
+        d->control->completer()->setWidget(0);
+        if (d->control->completer()->parent() == this)
+            delete d->control->completer();
     }
-    d->completer = c;
+    d->control->setCompleter(c);
     if (!c)
         return;
     if (c->widget() == 0)
         c->setWidget(this);
     if (hasFocus()) {
-        QObject::connect(d->completer, SIGNAL(activated(QString)),
+        QObject::connect(d->control->completer(), SIGNAL(activated(QString)),
                          this, SLOT(setText(QString)));
-        QObject::connect(d->completer, SIGNAL(highlighted(QString)),
+        QObject::connect(d->control->completer(), SIGNAL(highlighted(QString)),
                          this, SLOT(_q_completionHighlighted(QString)));
     }
 }
@@ -643,83 +607,9 @@ void QLineEdit::setCompleter(QCompleter *c)
 QCompleter *QLineEdit::completer() const
 {
     Q_D(const QLineEdit);
-    return d->completer;
-}
-
-// looks for an enabled item iterating forward(dir=1)/backward(dir=-1) from the
-// current row based. dir=0 indicates a new completion prefix was set.
-bool QLineEditPrivate::advanceToEnabledItem(int dir)
-{
-    int start = completer->currentRow();
-    if (start == -1)
-        return false;
-    int i = start + dir;
-    if (dir == 0) dir = 1;
-    do {
-        if (!completer->setCurrentRow(i)) {
-            if (!completer->wrapAround())
-                break;
-            i = i > 0 ? 0 : completer->completionCount() - 1;
-        } else {
-            QModelIndex currentIndex = completer->currentIndex();
-            if (completer->completionModel()->flags(currentIndex) & Qt::ItemIsEnabled)
-                return true;
-            i += dir;
-        }
-    } while (i != start);
-
-    completer->setCurrentRow(start); // restore
-    return false;
-}
-
-void QLineEditPrivate::complete(int key)
-{
-    if (!completer || readOnly || echoMode != QLineEdit::Normal)
-        return;
-
-    if (completer->completionMode() == QCompleter::InlineCompletion) {
-        if (key == Qt::Key_Backspace)
-            return;
-        int n = 0;
-        if (key == Qt::Key_Up || key == Qt::Key_Down) {
-            if (selend != 0 && selend != text.length())
-                return;
-            QString prefix = hasSelectedText() ? text.left(selstart) : text;
-            if (text.compare(completer->currentCompletion(), completer->caseSensitivity()) != 0
-                || prefix.compare(completer->completionPrefix(), completer->caseSensitivity()) != 0) {
-                completer->setCompletionPrefix(prefix);
-            } else {
-                n = (key == Qt::Key_Up) ? -1 : +1;
-            }
-        } else {
-            completer->setCompletionPrefix(text);
-        }
-        if (!advanceToEnabledItem(n))
-            return;
-    } else {
-#ifndef QT_KEYPAD_NAVIGATION
-        if (text.isEmpty()) {
-            completer->popup()->hide();
-            return;
-        }
-#endif
-        completer->setCompletionPrefix(text);
-    }
-
-    completer->complete();
+    return d->control->completer();
 }
 
-void QLineEditPrivate::_q_completionHighlighted(QString newText)
-{
-    Q_Q(QLineEdit);
-    if (completer->completionMode() != QCompleter::InlineCompletion)
-        q->setText(newText);
-    else {
-        int c = cursor;
-        q->setText(text.left(c) + newText.mid(c));
-        q->setSelection(text.length(), c - newText.length());
-    }
-}
 #endif // QT_NO_COMPLETER
 
 /*!
@@ -734,10 +624,10 @@ QSize QLineEdit::sizeHint() const
     Q_D(const QLineEdit);
     ensurePolished();
     QFontMetrics fm(font());
-    int h = qMax(fm.lineSpacing(), 14) + 2*verticalMargin
+    int h = qMax(fm.lineSpacing(), 14) + 2*d->verticalMargin
             + d->topTextMargin + d->bottomTextMargin
             + d->topmargin + d->bottommargin;
-    int w = fm.width(QLatin1Char('x')) * 17 + 2*horizontalMargin
+    int w = fm.width(QLatin1Char('x')) * 17 + 2*d->horizontalMargin
             + d->leftTextMargin + d->rightTextMargin
             + d->leftmargin + d->rightmargin; // "some"
     QStyleOptionFrameV2 opt;
@@ -758,7 +648,7 @@ QSize QLineEdit::minimumSizeHint() const
     Q_D(const QLineEdit);
     ensurePolished();
     QFontMetrics fm = fontMetrics();
-    int h = fm.height() + qMax(2*verticalMargin, fm.leading())
+    int h = fm.height() + qMax(2*d->verticalMargin, fm.leading())
             + d->topmargin + d->bottommargin;
     int w = fm.maxWidth() + d->leftmargin + d->rightmargin;
     QStyleOptionFrameV2 opt;
@@ -780,17 +670,13 @@ QSize QLineEdit::minimumSizeHint() const
 int QLineEdit::cursorPosition() const
 {
     Q_D(const QLineEdit);
-    return d->cursor;
+    return d->control->cursorPosition();
 }
 
 void QLineEdit::setCursorPosition(int pos)
 {
     Q_D(QLineEdit);
-    if (pos < 0)
-        pos = 0;
-
-    if (pos <= d->text.length())
-        d->moveCursor(pos);
+    d->control->setCursorPosition(pos);
 }
 
 /*!
@@ -812,22 +698,17 @@ int QLineEdit::cursorPositionAt(const QPoint &pos)
 bool QLineEdit::validateAndSet(const QString &newText, int newPos,
                                  int newMarkAnchor, int newMarkDrag)
 {
-    Q_D(QLineEdit);
-    int priorState = d->undoState;
-    d->selstart = 0;
-    d->selend = d->text.length();
-    d->removeSelectedText();
-    d->insert(newText);
-    d->finishChange(priorState);
-    if (d->undoState > priorState) {
-        d->cursor = newPos;
-        d->selstart = qMin(newMarkAnchor, newMarkDrag);
-        d->selend = qMax(newMarkAnchor, newMarkDrag);
-        update();
-        d->emitCursorPositionChanged();
-        return true;
+    // The suggested functions above in the docs don't seem to validate,
+    // below code tries to mimic previous behaviour.
+    QString oldText = text();
+    setText(newText);
+    if(!hasAcceptableInput()){
+        setText(oldText);
+        return false;
     }
-    return false;
+    setCursorPosition(newPos);
+    setSelection(qMin(newMarkAnchor, newMarkDrag), qAbs(newMarkAnchor - newMarkDrag));
+    return true;
 }
 #endif //QT3_SUPPORT
 
@@ -868,15 +749,7 @@ void QLineEdit::setAlignment(Qt::Alignment alignment)
 void QLineEdit::cursorForward(bool mark, int steps)
 {
     Q_D(QLineEdit);
-    int cursor = d->cursor;
-    if (steps > 0) {
-        while(steps--)
-            cursor = d->textLayout.nextCursorPosition(cursor);
-    } else if (steps < 0) {
-        while (steps++)
-            cursor = d->textLayout.previousCursorPosition(cursor);
-    }
-    d->moveCursor(cursor, mark);
+    d->control->cursorForward(mark, steps);
 }
 
 
@@ -901,7 +774,7 @@ void QLineEdit::cursorBackward(bool mark, int steps)
 void QLineEdit::cursorWordForward(bool mark)
 {
     Q_D(QLineEdit);
-    d->moveCursor(d->textLayout.nextCursorPosition(d->cursor, QTextLayout::SkipWords), mark);
+    d->control->cursorWordForward(mark);
 }
 
 /*!
@@ -914,7 +787,7 @@ void QLineEdit::cursorWordForward(bool mark)
 void QLineEdit::cursorWordBackward(bool mark)
 {
     Q_D(QLineEdit);
-    d->moveCursor(d->textLayout.previousCursorPosition(d->cursor, QTextLayout::SkipWords), mark);
+    d->control->cursorWordBackward(mark);
 }
 
 
@@ -929,26 +802,7 @@ void QLineEdit::cursorWordBackward(bool mark)
 void QLineEdit::backspace()
 {
     Q_D(QLineEdit);
-    int priorState = d->undoState;
-    if (d->hasSelectedText()) {
-        d->removeSelectedText();
-    } else if (d->cursor) {
-            --d->cursor;
-            if (d->maskData)
-                d->cursor = d->prevMaskBlank(d->cursor);
-            QChar uc = d->text.at(d->cursor);
-            if (d->cursor > 0 && uc.unicode() >= 0xdc00 && uc.unicode() < 0xe000) {
-                // second half of a surrogate, check if we have the first half as well,
-                // if yes delete both at once
-                uc = d->text.at(d->cursor - 1);
-                if (uc.unicode() >= 0xd800 && uc.unicode() < 0xdc00) {
-                    d->del(true);
-                    --d->cursor;
-                }
-            }
-            d->del(true);
-    }
-    d->finishChange(priorState);
+    d->control->backspace();
 }
 
 /*!
@@ -962,15 +816,7 @@ void QLineEdit::backspace()
 void QLineEdit::del()
 {
     Q_D(QLineEdit);
-    int priorState = d->undoState;
-    if (d->hasSelectedText()) {
-        d->removeSelectedText();
-    } else {
-        int n = d->textLayout.nextCursorPosition(d->cursor) - d->cursor;
-        while (n--)
-            d->del();
-    }
-    d->finishChange(priorState);
+    d->control->del();
 }
 
 /*!
@@ -985,7 +831,7 @@ void QLineEdit::del()
 void QLineEdit::home(bool mark)
 {
     Q_D(QLineEdit);
-    d->moveCursor(0, mark);
+    d->control->home(mark);
 }
 
 /*!
@@ -1000,7 +846,7 @@ void QLineEdit::home(bool mark)
 void QLineEdit::end(bool mark)
 {
     Q_D(QLineEdit);
-    d->moveCursor(d->text.length(), mark);
+    d->control->end(mark);
 }
 
 
@@ -1025,16 +871,13 @@ void QLineEdit::end(bool mark)
 bool QLineEdit::isModified() const
 {
     Q_D(const QLineEdit);
-    return d->modifiedState != d->undoState;
+    return d->control->isModified();
 }
 
 void QLineEdit::setModified(bool modified)
 {
     Q_D(QLineEdit);
-    if (modified)
-        d->modifiedState = -1;
-    else
-        d->modifiedState = d->undoState;
+    d->control->setModified(modified);
 }
 
 
@@ -1062,7 +905,7 @@ Use setModified(false) instead.
 bool QLineEdit::hasSelectedText() const
 {
     Q_D(const QLineEdit);
-    return d->hasSelectedText();
+    return d->control->hasSelectedText();
 }
 
 /*!
@@ -1080,9 +923,7 @@ bool QLineEdit::hasSelectedText() const
 QString QLineEdit::selectedText() const
 {
     Q_D(const QLineEdit);
-    if (d->hasSelectedText())
-        return d->text.mid(d->selstart, d->selend - d->selstart);
-    return QString();
+    return d->control->selectedText();
 }
 
 /*!
@@ -1095,7 +936,7 @@ QString QLineEdit::selectedText() const
 int QLineEdit::selectionStart() const
 {
     Q_D(const QLineEdit);
-    return d->hasSelectedText() ? d->selstart : -1;
+    return d->control->selectionStart();
 }
 
 
@@ -1125,9 +966,10 @@ void QLineEdit::setEdited(bool on) { setModified(on); }
 int QLineEdit::characterAt(int xpos, QChar *chr) const
 {
     Q_D(const QLineEdit);
-    int pos = d->xToPos(xpos + contentsRect().x() - d->hscroll + horizontalMargin);
-    if (chr && pos < (int) d->text.length())
-        *chr = d->text.at(pos);
+    int pos = d->xToPos(xpos + contentsRect().x() - d->hscroll + d->horizontalMargin);
+    QString txt = d->control->text();
+    if (chr && pos < (int) txt.length())
+        *chr = txt.at(pos);
     return pos;
 
 }
@@ -1138,9 +980,9 @@ int QLineEdit::characterAt(int xpos, QChar *chr) const
 bool QLineEdit::getSelection(int *start, int *end)
 {
     Q_D(QLineEdit);
-    if (d->hasSelectedText() && start && end) {
-        *start = d->selstart;
-        *end = d->selend;
+    if (d->control->hasSelectedText() && start && end) {
+        *start = selectionStart();
+        *end = *start + selectedText().length();
         return true;
     }
     return false;
@@ -1158,30 +1000,19 @@ bool QLineEdit::getSelection(int *start, int *end)
 void QLineEdit::setSelection(int start, int length)
 {
     Q_D(QLineEdit);
-    if (start < 0 || start > (int)d->text.length()) {
+    if (start < 0 || start > (int)d->control->text().length()) {
         qWarning("QLineEdit::setSelection: Invalid start position (%d)", start);
         return;
-    } else {
-        if (length > 0) {
-            d->selstart = start;
-            d->selend = qMin(start + length, (int)d->text.length());
-            d->cursor = d->selend;
-        } else {
-            d->selstart = qMax(start + length, 0);
-            d->selend = start;
-            d->cursor = d->selstart;
-        }
     }
 
-    if (d->hasSelectedText()){
+    d->control->setSelection(start, length);
+
+    if (d->control->hasSelectedText()){
         QStyleOptionFrameV2 opt;
         initStyleOption(&opt);
         if (!style()->styleHint(QStyle::SH_BlinkCursorWhenTextSelected, &opt, this))
             d->setCursorVisible(false);
     }
-
-    update();
-    d->emitCursorPositionChanged();
 }
 
 
@@ -1197,7 +1028,7 @@ void QLineEdit::setSelection(int start, int length)
 bool QLineEdit::isUndoAvailable() const
 {
     Q_D(const QLineEdit);
-    return d->isUndoAvailable();
+    return d->control->isUndoAvailable();
 }
 
 /*!
@@ -1213,7 +1044,7 @@ bool QLineEdit::isUndoAvailable() const
 bool QLineEdit::isRedoAvailable() const
 {
     Q_D(const QLineEdit);
-    return d->isRedoAvailable();
+    return d->control->isRedoAvailable();
 }
 
 /*!
@@ -1249,7 +1080,7 @@ void QLineEdit::setDragEnabled(bool b)
 bool QLineEdit::hasAcceptableInput() const
 {
     Q_D(const QLineEdit);
-    return d->hasAcceptableInput(d->text);
+    return d->control->hasAcceptableInput();
 }
 
 /*!
@@ -1355,15 +1186,13 @@ void QLineEdit::getTextMargins(int *left, int *top, int *right, int *bottom) con
 QString QLineEdit::inputMask() const
 {
     Q_D(const QLineEdit);
-    return (d->maskData ? d->inputMask + QLatin1Char(';') + d->blank : QString());
+    return d->control->inputMask();
 }
 
 void QLineEdit::setInputMask(const QString &inputMask)
 {
     Q_D(QLineEdit);
-    d->parseInputMask(inputMask);
-    if (d->maskData)
-        d->moveCursor(d->nextMaskBlank(0));
+    d->control->setInputMask(inputMask);
 }
 
 /*!
@@ -1378,8 +1207,7 @@ void QLineEdit::setInputMask(const QString &inputMask)
 void QLineEdit::selectAll()
 {
     Q_D(QLineEdit);
-    d->selstart = d->selend = d->cursor = 0;
-    d->moveCursor(d->text.length(), true);
+    d->control->selectAll();
 }
 
 /*!
@@ -1391,8 +1219,7 @@ void QLineEdit::selectAll()
 void QLineEdit::deselect()
 {
     Q_D(QLineEdit);
-    d->deselect();
-    d->finishChange();
+    d->control->deselect();
 }
 
 
@@ -1407,10 +1234,7 @@ void QLineEdit::insert(const QString &newText)
 {
 //     q->resetInputContext(); //#### FIX ME IN QT
     Q_D(QLineEdit);
-    int priorState = d->undoState;
-    d->removeSelectedText();
-    d->insert(newText);
-    d->finishChange(priorState);
+    d->control->insert(newText);
 }
 
 /*!
@@ -1421,13 +1245,8 @@ void QLineEdit::insert(const QString &newText)
 void QLineEdit::clear()
 {
     Q_D(QLineEdit);
-    int priorState = d->undoState;
     resetInputContext();
-    d->selstart = 0;
-    d->selend = d->text.length();
-    d->removeSelectedText();
-    d->separate();
-    d->finishChange(priorState, /*update*/false, /*edited*/false);
+    d->control->clear();
 }
 
 /*!
@@ -1440,8 +1259,7 @@ void QLineEdit::undo()
 {
     Q_D(QLineEdit);
     resetInputContext();
-    d->undo();
-    d->finishChange(-1, true);
+    d->control->undo();
 }
 
 /*!
@@ -1452,8 +1270,7 @@ void QLineEdit::redo()
 {
     Q_D(QLineEdit);
     resetInputContext();
-    d->redo();
-    d->finishChange();
+    d->control->redo();
 }
 
 
@@ -1475,16 +1292,16 @@ void QLineEdit::redo()
 bool QLineEdit::isReadOnly() const
 {
     Q_D(const QLineEdit);
-    return d->readOnly;
+    return d->control->isReadOnly();
 }
 
 void QLineEdit::setReadOnly(bool enable)
 {
     Q_D(QLineEdit);
-    if (d->readOnly != enable) {
-        d->readOnly = enable;
-        setAttribute(Qt::WA_MacShowFocusRect, !d->readOnly);
-        setAttribute(Qt::WA_InputMethodEnabled, shouldEnableInputMethod(this));
+    if (d->control->isReadOnly() != enable) {
+        d->control->setReadOnly(enable);
+        setAttribute(Qt::WA_MacShowFocusRect, !enable);
+        setAttribute(Qt::WA_InputMethodEnabled, d->shouldEnableInputMethod());
 #ifndef QT_NO_CURSOR
         setCursor(enable ? Qt::ArrowCursor : Qt::IBeamCursor);
 #endif
@@ -1523,7 +1340,7 @@ void QLineEdit::cut()
 void QLineEdit::copy() const
 {
     Q_D(const QLineEdit);
-    d->copy();
+    d->control->copy();
 }
 
 /*!
@@ -1540,23 +1357,7 @@ void QLineEdit::copy() const
 void QLineEdit::paste()
 {
     Q_D(QLineEdit);
-    if (echoMode() == PasswordEchoOnEdit && !d->passwordEchoEditing) {
-        // Clear the edit and reset to normal echo mode when pasting; the echo
-        // mode switches back when the edit loses focus.  ### changes a public
-        // property, resets current content
-        d->updatePasswordEchoEditing(true);
-        clear();
-    }
-    insert(QApplication::clipboard()->text(QClipboard::Clipboard));
-}
-
-void QLineEditPrivate::copy(bool clipboard) const
-{
-    Q_Q(const QLineEdit);
-    QString t = q->selectedText();
-    if (!t.isEmpty() && echoMode == QLineEdit::Normal) {
-        QApplication::clipboard()->setText(t, clipboard ? QClipboard::Clipboard : QClipboard::Selection);
-    }
+    d->control->paste();
 }
 
 #endif // !QT_NO_CLIPBOARD
@@ -1566,57 +1367,10 @@ void QLineEditPrivate::copy(bool clipboard) const
 bool QLineEdit::event(QEvent * e)
 {
     Q_D(QLineEdit);
-#ifndef QT_NO_SHORTCUT
-    if (e->type() == QEvent::ShortcutOverride && !d->readOnly) {
-        QKeyEvent* ke = (QKeyEvent*) e;
-        if (ke == QKeySequence::Copy
-            || ke == QKeySequence::Paste
-            || ke == QKeySequence::Cut
-            || ke == QKeySequence::Redo
-            || ke == QKeySequence::Undo
-            || ke == QKeySequence::MoveToNextWord
-            || ke == QKeySequence::MoveToPreviousWord
-            || ke == QKeySequence::MoveToStartOfDocument
-            || ke == QKeySequence::MoveToEndOfDocument
-            || ke == QKeySequence::SelectNextWord
-            || ke == QKeySequence::SelectPreviousWord
-            || ke == QKeySequence::SelectStartOfLine
-            || ke == QKeySequence::SelectEndOfLine
-            || ke == QKeySequence::SelectStartOfBlock
-            || ke == QKeySequence::SelectEndOfBlock
-            || ke == QKeySequence::SelectStartOfDocument
-            || ke == QKeySequence::SelectAll
-            || ke == QKeySequence::SelectEndOfDocument) {
-            ke->accept();
-        } else if (ke->modifiers() == Qt::NoModifier || ke->modifiers() == Qt::ShiftModifier
-                   || ke->modifiers() == Qt::KeypadModifier) {
-            if (ke->key() < Qt::Key_Escape) {
-                ke->accept();
-            } else {
-                switch (ke->key()) {
-                case Qt::Key_Delete:
-                case Qt::Key_Home:
-                case Qt::Key_End:
-                case Qt::Key_Backspace:
-                case Qt::Key_Left:
-                case Qt::Key_Right:
-                    ke->accept();
-                default:
-                    break;
-                }
-            }
-        }
-    } else
-#endif
-        if (e->type() == QEvent::Timer) {
+    if (e->type() == QEvent::Timer) {
         // should be timerEvent, is here for binary compatibility
         int timerId = ((QTimerEvent*)e)->timerId();
-        if (timerId == d->cursorTimer) {
-            QStyleOptionFrameV2 opt;
-            initStyleOption(&opt);
-            if(!hasSelectedText()
-               || style()->styleHint(QStyle::SH_BlinkCursorWhenTextSelected, &opt, this))
-                d->setCursorVisible(!d->cursorVisible);
+        if (false) {
 #ifndef QT_NO_DRAGANDDROP
         } else if (timerId == d->dndTimer.timerId()) {
             d->drag();
@@ -1624,60 +1378,31 @@ bool QLineEdit::event(QEvent * e)
         }
         else if (timerId == d->tripleClickTimer.timerId())
             d->tripleClickTimer.stop();
-#ifdef QT_KEYPAD_NAVIGATION
-        else if (timerId == d->deleteAllTimer.timerId()) {
-            d->deleteAllTimer.stop();
-            clear();
-        }
-#endif
     } else if (e->type() == QEvent::ContextMenu) {
 #ifndef QT_NO_IM
-        if (d->composeMode())
+        if (d->control->composeMode())
             return true;
 #endif
-        d->separate();
+        //d->separate();
     } else if (e->type() == QEvent::WindowActivate) {
         QTimer::singleShot(0, this, SLOT(_q_handleWindowActivate()));
+    }else if(e->type() == QEvent::ShortcutOverride){
+        d->control->processEvent(e);
     }
+
 #ifdef QT_KEYPAD_NAVIGATION
     if (QApplication::keypadNavigationEnabled()) {
-        if ((e->type() == QEvent::KeyPress) || (e->type() == QEvent::KeyRelease)) {
-            QKeyEvent *ke = (QKeyEvent *)e;
-            if (ke->key() == Qt::Key_Back) {
-                if (ke->isAutoRepeat()) {
-                    // Swallow it. We don't want back keys running amok.
-                    ke->accept();
-                    return true;
-                }
-                if ((e->type() == QEvent::KeyRelease)
-                    && !isReadOnly()
-                    && d->deleteAllTimer.isActive()) {
-                    d->deleteAllTimer.stop();
-                    backspace();
-                    ke->accept();
-                    return true;
-                }
-            }
-        } else if (e->type() == QEvent::EnterEditFocus) {
+        if (e->type() == QEvent::EnterEditFocus) {
             end(false);
-            if (!d->cursorTimer) {
-                int cft = QApplication::cursorFlashTime();
-                d->cursorTimer = cft ? startTimer(cft/2) : -1;
-            }
+            int cft = QApplication::cursorFlashTime();
+            d->control->setCursorBlinkPeriod(cft/2);
         } else if (e->type() == QEvent::LeaveEditFocus) {
             d->setCursorVisible(false);
-            if (d->cursorTimer > 0)
-                killTimer(d->cursorTimer);
-            d->cursorTimer = 0;
-
-            if (!d->emitingEditingFinished) {
-                if (hasAcceptableInput() || d->fixup()) {
-                    d->emitingEditingFinished = true;
-                    emit editingFinished();
-                    d->emitingEditingFinished = false;
-                }
-            }
+            d->control->setCursorBlinkPeriod(0);
+            if (d->control->hasAcceptableInput() || d->control->fixup())
+                emit editingFinished();
         }
+        return true;
     }
 #endif
     return QWidget::event(e);
@@ -1689,15 +1414,15 @@ void QLineEdit::mousePressEvent(QMouseEvent* e)
 {
     Q_D(QLineEdit);
     if (d->sendMouseEventToInputContext(e))
-	return;
+        return;
     if (e->button() == Qt::RightButton)
         return;
 #ifdef QT_KEYPAD_NAVIGATION
     if (QApplication::keypadNavigationEnabled() && !hasEditFocus()) {
         setEditFocus(true);
         // Get the completion list to pop up.
-        if (d->completer)
-            d->completer->complete();
+        if (d->control->completer())
+            d->control->completer()->complete();
     }
 #endif
     if (d->tripleClickTimer.isActive() && (e->pos() - d->tripleClick).manhattanLength() <
@@ -1708,18 +1433,16 @@ void QLineEdit::mousePressEvent(QMouseEvent* e)
     bool mark = e->modifiers() & Qt::ShiftModifier;
     int cursor = d->xToPos(e->pos().x());
 #ifndef QT_NO_DRAGANDDROP
-    if (!mark && d->dragEnabled && d->echoMode == Normal &&
-         e->button() == Qt::LeftButton && d->inSelection(e->pos().x())) {
-        d->cursor = cursor;
-        update();
+    if (!mark && d->dragEnabled && d->control->echoMode() == Normal &&
+         e->button() == Qt::LeftButton && d->control->inSelection(e->pos().x())) {
+        d->control->moveCursor(cursor);
         d->dndPos = e->pos();
         if (!d->dndTimer.isActive())
             d->dndTimer.start(QApplication::startDragTime(), this);
-        d->emitCursorPositionChanged();
     } else
 #endif
     {
-        d->moveCursor(cursor, mark);
+        d->control->moveCursor(cursor, mark);
     }
 }
 
@@ -1729,7 +1452,7 @@ void QLineEdit::mouseMoveEvent(QMouseEvent * e)
 {
     Q_D(QLineEdit);
     if (d->sendMouseEventToInputContext(e))
-	return;
+        return;
 
     if (e->buttons() & Qt::LeftButton) {
 #ifndef QT_NO_DRAGANDDROP
@@ -1739,7 +1462,7 @@ void QLineEdit::mouseMoveEvent(QMouseEvent * e)
         } else
 #endif
         {
-            d->moveCursor(d->xToPos(e->pos().x()), true);
+            d->control->moveCursor(d->xToPos(e->pos().x()), true);
         }
     }
 }
@@ -1750,7 +1473,7 @@ void QLineEdit::mouseReleaseEvent(QMouseEvent* e)
 {
     Q_D(QLineEdit);
     if (d->sendMouseEventToInputContext(e))
-	return;
+        return;
 #ifndef QT_NO_DRAGANDDROP
     if (e->button() == Qt::LeftButton) {
         if (d->dndTimer.isActive()) {
@@ -1763,9 +1486,9 @@ void QLineEdit::mouseReleaseEvent(QMouseEvent* e)
 #ifndef QT_NO_CLIPBOARD
     if (QApplication::clipboard()->supportsSelection()) {
         if (e->button() == Qt::LeftButton) {
-            d->copy(false);
-        } else if (!d->readOnly && e->button() == Qt::MidButton) {
-            d->deselect();
+            d->control->copy(QClipboard::Selection);
+        } else if (!d->control->isReadOnly() && e->button() == Qt::MidButton) {
+            deselect();
             insert(QApplication::clipboard()->text(QClipboard::Selection));
         }
     }
@@ -1785,16 +1508,9 @@ void QLineEdit::mouseDoubleClickEvent(QMouseEvent* e)
 {
     Q_D(QLineEdit);
     if (d->sendMouseEventToInputContext(e))
-	return;
+        return;
     if (e->button() == Qt::LeftButton) {
-        deselect();
-        d->cursor = d->xToPos(e->pos().x());
-        d->cursor = d->textLayout.previousCursorPosition(d->cursor, QTextLayout::SkipWords);
-        // ## text layout should support end of words.
-        int end = d->textLayout.nextCursorPosition(d->cursor, QTextLayout::SkipWords);
-        while (end > d->cursor && d->text[end-1].isSpace())
-            --end;
-        d->moveCursor(end, true);
+        d->control->selectWordAtPos(d->xToPos(e->pos().x()));
         d->tripleClickTimer.start(QApplication::doubleClickInterval(), this);
         d->tripleClick = e->pos();
     }
@@ -1834,65 +1550,15 @@ void QLineEdit::mouseDoubleClickEvent(QMouseEvent* e)
 void QLineEdit::keyPressEvent(QKeyEvent *event)
 {
     Q_D(QLineEdit);
-
-    bool inlineCompletionAccepted = false;
-
-#ifndef QT_NO_COMPLETER
-    if (d->completer) {
-        QCompleter::CompletionMode completionMode = d->completer->completionMode();
-        if ((completionMode == QCompleter::PopupCompletion
-             || completionMode == QCompleter::UnfilteredPopupCompletion)
-            &&d->completer->popup()
-            && d->completer->popup()->isVisible()) {
-            // The following keys are forwarded by the completer to the widget
-            // Ignoring the events lets the completer provide suitable default behavior
-            switch (event->key()) {
-            case Qt::Key_Escape:
-                event->ignore();
-                return;
-            case Qt::Key_Enter:
-            case Qt::Key_Return:
-            case Qt::Key_F4:
-#ifdef QT_KEYPAD_NAVIGATION
-            case Qt::Key_Select:
-                if (!QApplication::keypadNavigationEnabled())
-                    break;
-#endif
-                d->completer->popup()->hide(); // just hide. will end up propagating to parent
-            default:
-                break; // normal key processing
-            }
-        } else if (completionMode == QCompleter::InlineCompletion) {
-            switch (event->key()) {
-            case Qt::Key_Enter:
-            case Qt::Key_Return:
-            case Qt::Key_F4:
-#ifdef QT_KEYPAD_NAVIGATION
-            case Qt::Key_Select:
-                if (!QApplication::keypadNavigationEnabled())
-                    break;
-#endif
-                if (!d->completer->currentCompletion().isEmpty() && d->selend > d->selstart
-                    && d->selend == d->text.length()) {
-                    setText(d->completer->currentCompletion());
-                    inlineCompletionAccepted = true;
-                }
-            default:
-                break; // normal key processing
-            }
-        }
-    }
-#endif // QT_NO_COMPLETER
-
-#ifdef QT_KEYPAD_NAVIGATION
+    #ifdef QT_KEYPAD_NAVIGATION
     bool select = false;
     switch (event->key()) {
         case Qt::Key_Select:
             if (QApplication::keypadNavigationEnabled()) {
                 if (hasEditFocus()) {
                     setEditFocus(false);
-                    if (d->completer && d->completer->popup()->isVisible())
-                        d->completer->popup()->hide();
+                    if (d->control->completer() && d->control->completer()->popup()->isVisible())
+                        d->control->completer()->popup()->hide();
                     select = true;
                 }
             }
@@ -1928,273 +1594,7 @@ void QLineEdit::keyPressEvent(QKeyEvent *event)
             return; // Just start. No action.
     }
 #endif
-
-    if (echoMode() == PasswordEchoOnEdit
-        && !d->passwordEchoEditing
-        && !isReadOnly()
-        && !event->text().isEmpty()
-#ifdef QT_KEYPAD_NAVIGATION
-        && event->key() != Qt::Key_Select
-        && event->key() != Qt::Key_Up
-        && event->key() != Qt::Key_Down
-        && event->key() != Qt::Key_Back
-#endif
-        && !(event->modifiers() & Qt::ControlModifier)) {
-        // Clear the edit and reset to normal echo mode while editing; the
-        // echo mode switches back when the edit loses focus.  ### changes a
-        // public property, resets current content.  dubious code; you can
-        // navigate with keys up, down, back, and select(?), but if you press
-        // "left" or "right" it clears?
-        d->updatePasswordEchoEditing(true);
-        clear();
-    }
-
-    d->setCursorVisible(true);
-    if (event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return) {
-        if (hasAcceptableInput() || d->fixup()) {
-            emit returnPressed();
-            d->emitingEditingFinished = true;
-            emit editingFinished();
-            d->emitingEditingFinished = false;
-        }
-        if (inlineCompletionAccepted)
-            event->accept();
-        else
-            event->ignore();
-        return;
-    }
-    bool unknown = false;
-
-    if (false) {
-    }
-#ifndef QT_NO_SHORTCUT
-    else if (event == QKeySequence::Undo) {
-        if (!d->readOnly)
-            undo();
-    }
-    else if (event == QKeySequence::Redo) {
-        if (!d->readOnly)
-            redo();
-    }
-    else if (event == QKeySequence::SelectAll) {
-        selectAll();
-    }
-#ifndef QT_NO_CLIPBOARD
-    else if (event == QKeySequence::Copy) {
-        copy();
-    }
-    else if (event == QKeySequence::Paste) {
-        if (!d->readOnly)
-            paste();
-    }
-    else if (event == QKeySequence::Cut) {
-        if (!d->readOnly) {
-            cut();
-        }
-    }
-    else if (event == QKeySequence::DeleteEndOfLine) {
-        if (!d->readOnly) {
-            setSelection(d->cursor, d->text.size());
-            copy();
-            del();
-        }
-    }
-#endif //QT_NO_CLIPBOARD
-    else if (event == QKeySequence::MoveToStartOfLine) {
-        home(0);
-    }
-    else if (event == QKeySequence::MoveToEndOfLine) {
-        end(0);
-    }
-    else if (event == QKeySequence::SelectStartOfLine) {
-        home(1);
-    }
-    else if (event == QKeySequence::SelectEndOfLine) {
-        end(1);
-    }
-    else if (event == QKeySequence::MoveToNextChar) {
-#if !defined(Q_WS_WIN) || defined(QT_NO_COMPLETER)
-        if (d->hasSelectedText()) {
-#else
-        if (d->hasSelectedText() && d->completer
-            && d->completer->completionMode() == QCompleter::InlineCompletion) {
-#endif
-            d->moveCursor(d->selend, false);
-        } else {
-            cursorForward(0, layoutDirection() == Qt::LeftToRight ? 1 : -1);
-        }
-    }
-    else if (event == QKeySequence::SelectNextChar) {
-        cursorForward(1, layoutDirection() == Qt::LeftToRight ? 1 : -1);
-    }
-    else if (event == QKeySequence::MoveToPreviousChar) {
-#if !defined(Q_WS_WIN) || defined(QT_NO_COMPLETER)
-        if (d->hasSelectedText()) {
-#else
-        if (d->hasSelectedText() && d->completer
-            && d->completer->completionMode() == QCompleter::InlineCompletion) {
-#endif
-            d->moveCursor(d->selstart, false);
-        } else {
-            cursorBackward(0, layoutDirection() == Qt::LeftToRight ? 1 : -1);
-        }
-    }
-    else if (event == QKeySequence::SelectPreviousChar) {
-        cursorBackward(1, layoutDirection() == Qt::LeftToRight ? 1 : -1);
-    }
-    else if (event == QKeySequence::MoveToNextWord) {
-        if (echoMode() == Normal)
-            layoutDirection() == Qt::LeftToRight ? cursorWordForward(0) : cursorWordBackward(0);
-        else
-            layoutDirection() == Qt::LeftToRight ? end(0) : home(0);
-    }
-    else if (event == QKeySequence::MoveToPreviousWord) {
-        if (echoMode() == Normal)
-            layoutDirection() == Qt::LeftToRight ? cursorWordBackward(0) : cursorWordForward(0);
-        else if (!d->readOnly) {
-            layoutDirection() == Qt::LeftToRight ? home(0) : end(0);
-        }
-    }
-    else if (event == QKeySequence::SelectNextWord) {
-        if (echoMode() == Normal)
-            layoutDirection() == Qt::LeftToRight ? cursorWordForward(1) : cursorWordBackward(1);
-        else
-            layoutDirection() == Qt::LeftToRight ? end(1) : home(1);
-    }
-    else if (event == QKeySequence::SelectPreviousWord) {
-        if (echoMode() == Normal)
-            layoutDirection() == Qt::LeftToRight ? cursorWordBackward(1) : cursorWordForward(1);
-        else
-            layoutDirection() == Qt::LeftToRight ? home(1) : end(1);
-    }
-    else if (event == QKeySequence::Delete) {
-        if (!d->readOnly)
-            del();
-    }
-    else if (event == QKeySequence::DeleteEndOfWord) {
-        if (!d->readOnly) {
-            cursorWordForward(true);
-            del();
-        }
-    }
-    else if (event == QKeySequence::DeleteStartOfWord) {
-        if (!d->readOnly) {
-            cursorWordBackward(true);
-            del();
-        }
-    }
-#endif // QT_NO_SHORTCUT
-    else {
-#ifdef Q_WS_MAC
-        if (event->key() == Qt::Key_Up || event->key() == Qt::Key_Down) {
-            Qt::KeyboardModifiers myModifiers = (event->modifiers() & ~Qt::KeypadModifier);
-            if (myModifiers & Qt::ShiftModifier) {
-                if (myModifiers == (Qt::ControlModifier|Qt::ShiftModifier)
-                        || myModifiers == (Qt::AltModifier|Qt::ShiftModifier)
-                        || myModifiers == Qt::ShiftModifier) {
-
-                    event->key() == Qt::Key_Up ? home(1) : end(1);
-                }
-            } else {
-                if ((myModifiers == Qt::ControlModifier
-                     || myModifiers == Qt::AltModifier
-                     || myModifiers == Qt::NoModifier)) {
-                    event->key() == Qt::Key_Up ? home(0) : end(0);
-                }
-            }
-        }
-#endif
-        if (event->modifiers() & Qt::ControlModifier) {
-            switch (event->key()) {
-            case Qt::Key_Backspace:
-                if (!d->readOnly) {
-                    cursorWordBackward(true);
-                    del();
-                }
-                break;
-#ifndef QT_NO_COMPLETER
-            case Qt::Key_Up:
-            case Qt::Key_Down:
-                d->complete(event->key());
-                break;
-#endif
-#if defined(Q_WS_X11)
-            case Qt::Key_E:
-                end(0);
-                break;
-
-            case Qt::Key_U:
-                if (!d->readOnly) {
-                    setSelection(0, d->text.size());
-#ifndef QT_NO_CLIPBOARD
-                    copy();
-#endif
-                    del();
-                }
-            break;
-#endif
-            default:
-                unknown = true;
-            }
-        } else { // ### check for *no* modifier
-            switch (event->key()) {
-            case Qt::Key_Backspace:
-                if (!d->readOnly) {
-                    backspace();
-#ifndef QT_NO_COMPLETER
-                    d->complete(Qt::Key_Backspace);
-#endif
-                }
-                break;
-#ifdef QT_KEYPAD_NAVIGATION
-            case Qt::Key_Back:
-                if (QApplication::keypadNavigationEnabled() && !event->isAutoRepeat()
-                    && !isReadOnly()) {
-                    if (text().length() == 0) {
-                        setText(d->origText);
-
-                        if (d->passwordEchoEditing)
-                            d->updatePasswordEchoEditing(false);
-
-                        setEditFocus(false);
-                    } else if (!d->deleteAllTimer.isActive()) {
-                        d->deleteAllTimer.start(750, this);
-                    }
-                } else {
-                    unknown = true;
-                }
-                break;
-#endif
-
-            default:
-                unknown = true;
-            }
-        }
-    }
-
-    if (event->key() == Qt::Key_Direction_L || event->key() == Qt::Key_Direction_R) {
-        setLayoutDirection((event->key() == Qt::Key_Direction_L) ? Qt::LeftToRight : Qt::RightToLeft);
-        d->updateTextLayout();
-        update();
-        unknown = false;
-    }
-
-    if (unknown && !d->readOnly) {
-        QString t = event->text();
-        if (!t.isEmpty() && t.at(0).isPrint()) {
-            insert(t);
-#ifndef QT_NO_COMPLETER
-            d->complete(event->key());
-#endif
-            event->accept();
-            return;
-        }
-    }
-
-    if (unknown)
-        event->ignore();
-    else
-        event->accept();
+    d->control->processKeyEvent(event);
 }
 
 /*!
@@ -2208,50 +1608,17 @@ QRect QLineEdit::cursorRect() const
     return d->cursorRect();
 }
 
-/*!
-  This function is not intended as polymorphic usage. Just a shared code
-  fragment that calls QInputContext::mouseHandler for this
-  class.
-*/
-bool QLineEditPrivate::sendMouseEventToInputContext( QMouseEvent *e )
-{
-#if !defined QT_NO_IM
-    Q_Q(QLineEdit);
-    if ( composeMode() ) {
-	int tmp_cursor = xToPos(e->pos().x());
-	int mousePos = tmp_cursor - cursor;
-	if ( mousePos < 0 || mousePos > textLayout.preeditAreaText().length() ) {
-            mousePos = -1;
-	    // don't send move events outside the preedit area
-            if ( e->type() == QEvent::MouseMove )
-                return true;
-        }
-
-        QInputContext *qic = q->inputContext();
-        if ( qic )
-            // may be causing reset() in some input methods
-            qic->mouseHandler(mousePos, e);
-        if (!textLayout.preeditAreaText().isEmpty())
-            return true;
-    }
-#else
-    Q_UNUSED(e);
-#endif
-
-    return false;
-}
-
 /*! \reimp
  */
 void QLineEdit::inputMethodEvent(QInputMethodEvent *e)
 {
     Q_D(QLineEdit);
-    if (d->readOnly) {
+    if (d->control->isReadOnly()) {
         e->ignore();
         return;
     }
 
-    if (echoMode() == PasswordEchoOnEdit && !d->passwordEchoEditing) {
+    if (echoMode() == PasswordEchoOnEdit && !d->control->passwordEchoEditing()) {
         // Clear the edit and reset to normal echo mode while entering input
         // method data; the echo mode switches back when the edit loses focus.
         // ### changes a public property, resets current content.
@@ -2271,85 +1638,11 @@ void QLineEdit::inputMethodEvent(QInputMethodEvent *e)
     }
 #endif
 
-    int priorState = 0;
-    bool isGettingInput = !e->commitString().isEmpty() || !e->preeditString().isEmpty()
-            || e->replacementLength() > 0;
-    bool cursorPositionChanged = false;
-
-    if (isGettingInput) {
-        // If any text is being input, remove selected text.
-        priorState = d->undoState;
-        d->removeSelectedText();
-    }
-
-    int c = d->cursor; // cursor position after insertion of commit string
-    if (e->replacementStart() <= 0)
-        c += e->commitString().length() + qMin(-e->replacementStart(), e->replacementLength());
-
-    d->cursor += e->replacementStart();
-
-    // insert commit string
-    if (e->replacementLength()) {
-        d->selstart = d->cursor;
-        d->selend = d->selstart + e->replacementLength();
-        d->removeSelectedText();
-    }
-    if (!e->commitString().isEmpty()) {
-        d->insert(e->commitString());
-        cursorPositionChanged = true;
-    }
-
-    d->cursor = qMin(c, d->text.length());
-
-    for (int i = 0; i < e->attributes().size(); ++i) {
-        const QInputMethodEvent::Attribute &a = e->attributes().at(i);
-        if (a.type == QInputMethodEvent::Selection) {
-            d->cursor = qBound(0, a.start + a.length, d->text.length());
-            if (a.length) {
-                d->selstart = qMax(0, qMin(a.start, d->text.length()));
-                d->selend = d->cursor;
-                if (d->selend < d->selstart) {
-                    qSwap(d->selstart, d->selend);
-                }
-            } else {
-                d->selstart = d->selend = 0;
-            }
-            cursorPositionChanged = true;
-        }
-    }
-
-    d->textLayout.setPreeditArea(d->cursor, e->preeditString());
-    d->preeditCursor = e->preeditString().length();
-    d->hideCursor = false;
-    QList<QTextLayout::FormatRange> formats;
-    for (int i = 0; i < e->attributes().size(); ++i) {
-        const QInputMethodEvent::Attribute &a = e->attributes().at(i);
-        if (a.type == QInputMethodEvent::Cursor) {
-            d->preeditCursor = a.start;
-            d->hideCursor = !a.length;
-        } else if (a.type == QInputMethodEvent::TextFormat) {
-            QTextCharFormat f = qvariant_cast<QTextFormat>(a.value).toCharFormat();
-            if (f.isValid()) {
-                QTextLayout::FormatRange o;
-                o.start = a.start + d->cursor;
-                o.length = a.length;
-                o.format = f;
-                formats.append(o);
-            }
-        }
-    }
-    d->textLayout.setAdditionalFormats(formats);
-    d->updateTextLayout();
-    update();
-    if (cursorPositionChanged)
-        d->emitCursorPositionChanged();
-
-    if (isGettingInput)
-        d->finishChange(priorState);
+    d->control->processInputMethodEvent(e);
 
 #ifndef QT_NO_COMPLETER
     if (!e->commitString().isEmpty())
-        d->complete(Qt::Key_unknown);
+        d->control->complete(Qt::Key_unknown);
 #endif
 }
 
@@ -2364,9 +1657,9 @@ QVariant QLineEdit::inputMethodQuery(Qt::InputMethodQuery property) const
     case Qt::ImFont:
         return font();
     case Qt::ImCursorPosition:
-        return QVariant(d->cursor);
+        return QVariant(d->control->hasSelectedText() ? d->control->selectionEnd() : d->control->cursor());
     case Qt::ImSurroundingText:
-        return QVariant(d->text);
+        return QVariant(text());
     case Qt::ImCurrentSelection:
         return QVariant(selectedText());
     case Qt::ImMaximumTextLength:
@@ -2392,9 +1685,9 @@ void QLineEdit::focusInEvent(QFocusEvent *e)
     if (e->reason() == Qt::TabFocusReason ||
          e->reason() == Qt::BacktabFocusReason  ||
          e->reason() == Qt::ShortcutFocusReason) {
-        if (d->maskData)
-            d->moveCursor(d->nextMaskBlank(0));
-        else if (!d->hasSelectedText())
+        if (!d->control->inputMask().isEmpty())
+            d->control->moveCursor(d->control->nextMaskBlank(0));
+        else if (!d->control->hasSelectedText())
             selectAll();
     } else if (e->reason() == Qt::MouseFocusReason) {
         d->clickCausedFocus = 1;
@@ -2402,28 +1695,26 @@ void QLineEdit::focusInEvent(QFocusEvent *e)
 #ifdef QT_KEYPAD_NAVIGATION
     if (!QApplication::keypadNavigationEnabled() || (hasEditFocus() && e->reason() == Qt::PopupFocusReason))
 #endif
-    if (!d->cursorTimer) {
-        int cft = QApplication::cursorFlashTime();
-        d->cursorTimer = cft ? startTimer(cft/2) : -1;
-    }
+    int cft = QApplication::cursorFlashTime();
+    d->control->setCursorBlinkPeriod(cft/2);
     QStyleOptionFrameV2 opt;
     initStyleOption(&opt);
-    if((!hasSelectedText() && d->textLayout.preeditAreaText().isEmpty())
+    if((!hasSelectedText() && d->control->preeditAreaText().isEmpty())
        || style()->styleHint(QStyle::SH_BlinkCursorWhenTextSelected, &opt, this))
         d->setCursorVisible(true);
 #ifdef Q_WS_MAC
-    if (d->echoMode == Password || d->echoMode == NoEcho)
+    if (d->control->echoMode() == Password || d->control->echoMode() == NoEcho)
         qt_mac_secure_keyboard(true);
 #endif
 #ifdef QT_KEYPAD_NAVIGATION
-    d->origText = d->text;
+    d->control->setCancelText(d->text);
 #endif
 #ifndef QT_NO_COMPLETER
-    if (d->completer) {
-        d->completer->setWidget(this);
-        QObject::connect(d->completer, SIGNAL(activated(QString)),
+    if (d->control->completer()) {
+        d->control->completer()->setWidget(this);
+        QObject::connect(d->control->completer(), SIGNAL(activated(QString)),
                          this, SLOT(setText(QString)));
-        QObject::connect(d->completer, SIGNAL(highlighted(QString)),
+        QObject::connect(d->control->completer(), SIGNAL(highlighted(QString)),
                          this, SLOT(_q_completionHighlighted(QString)));
     }
 #endif
@@ -2436,7 +1727,7 @@ void QLineEdit::focusInEvent(QFocusEvent *e)
 void QLineEdit::focusOutEvent(QFocusEvent *e)
 {
     Q_D(QLineEdit);
-    if (d->passwordEchoEditing) {
+    if (d->control->passwordEchoEditing()) {
         // Reset the echomode back to PasswordEchoOnEdit when the widget loses
         // focus.
         d->updatePasswordEchoEditing(false);
@@ -2448,37 +1739,29 @@ void QLineEdit::focusOutEvent(QFocusEvent *e)
         deselect();
 
     d->setCursorVisible(false);
-    if (d->cursorTimer > 0)
-        killTimer(d->cursorTimer);
-    d->cursorTimer = 0;
-
+    d->control->setCursorBlinkPeriod(0);
 #ifdef QT_KEYPAD_NAVIGATION
     // editingFinished() is already emitted on LeaveEditFocus
     if (!QApplication::keypadNavigationEnabled())
 #endif
     if (reason != Qt::PopupFocusReason
         || !(QApplication::activePopupWidget() && QApplication::activePopupWidget()->parentWidget() == this)) {
-        if (!d->emitingEditingFinished) {
-            if (hasAcceptableInput() || d->fixup()) {
-                d->emitingEditingFinished = true;
+            if (hasAcceptableInput() || d->control->fixup())
                 emit editingFinished();
-                d->emitingEditingFinished = false;
-            }
-        }
 #ifdef QT3_SUPPORT
         emit lostFocus();
 #endif
     }
 #ifdef Q_WS_MAC
-    if (d->echoMode == Password || d->echoMode == NoEcho)
+    if (d->control->echoMode() == Password || d->control->echoMode() == NoEcho)
         qt_mac_secure_keyboard(false);
 #endif
 #ifdef QT_KEYPAD_NAVIGATION
-    d->origText = QString();
+    d->control->setCancelText(QString());
 #endif
 #ifndef QT_NO_COMPLETER
-    if (d->completer) {
-        QObject::disconnect(d->completer, 0, this, 0);
+    if (d->control->completer()) {
+        QObject::disconnect(d->control->completer(), 0, this, 0);
     }
 #endif
     update();
@@ -2508,24 +1791,19 @@ void QLineEdit::paintEvent(QPaintEvent *)
     Qt::Alignment va = QStyle::visualAlignment(layoutDirection(), QFlag(d->alignment));
     switch (va & Qt::AlignVertical_Mask) {
      case Qt::AlignBottom:
-         d->vscroll = r.y() + r.height() - fm.height() - verticalMargin;
+         d->vscroll = r.y() + r.height() - fm.height() - d->verticalMargin;
          break;
      case Qt::AlignTop:
-         d->vscroll = r.y() + verticalMargin;
+         d->vscroll = r.y() + d->verticalMargin;
          break;
      default:
          //center
          d->vscroll = r.y() + (r.height() - fm.height() + 1) / 2;
          break;
     }
-    QRect lineRect(r.x() + horizontalMargin, d->vscroll, r.width() - 2*horizontalMargin, fm.height());
-    QTextLine line = d->textLayout.lineAt(0);
+    QRect lineRect(r.x() + d->horizontalMargin, d->vscroll, r.width() - 2*d->horizontalMargin, fm.height());
 
-    int cursor = d->cursor;
-    if (d->preeditCursor != -1)
-        cursor += d->preeditCursor;
-    // locate cursor position
-    int cix = qRound(line.cursorToX(cursor));
+    int cix = qRound(d->control->cursorToX());
 
     // horizontal scrolling. d->hscroll is the left indent from the beginning
     // of the text line to the left edge of lineRect. we update this value
@@ -2535,7 +1813,7 @@ void QLineEdit::paintEvent(QPaintEvent *)
     // (cix).
     int minLB = qMax(0, -fm.minLeftBearing());
     int minRB = qMax(0, -fm.minRightBearing());
-    int widthUsed = qRound(line.naturalTextWidth()) + 1 + minRB;
+    int widthUsed = d->control->width() + minRB;
     if ((minLB + widthUsed) <=  lineRect.width()) {
         // text fits in lineRect; use hscroll for alignment
         switch (va & ~(Qt::AlignAbsolute|Qt::AlignVertical_Mask)) {
@@ -2563,7 +1841,7 @@ void QLineEdit::paintEvent(QPaintEvent *)
         d->hscroll = widthUsed - lineRect.width() + 1;
     }
     // the y offset is there to keep the baseline constant in case we have script changes in the text.
-    QPoint topLeft = lineRect.topLeft() - QPoint(d->hscroll, d->ascent - fm.ascent());
+    QPoint topLeft = lineRect.topLeft() - QPoint(d->hscroll, d->control->ascent() - fm.ascent());
 
     // draw text, selections and cursors
 #ifndef QT_NO_STYLE_STYLESHEET
@@ -2573,33 +1851,23 @@ void QLineEdit::paintEvent(QPaintEvent *)
 #endif
     p.setPen(pal.text().color());
 
-    QVector<QTextLayout::FormatRange> selections;
+    int flags = QLineControl::DrawText;
+
 #ifdef QT_KEYPAD_NAVIGATION
     if (!QApplication::keypadNavigationEnabled() || hasEditFocus())
 #endif
-    if (d->selstart < d->selend || (d->cursorVisible && d->maskData && !d->readOnly)) {
-        QTextLayout::FormatRange o;
-        if (d->selstart < d->selend) {
-            o.start = d->selstart;
-            o.length = d->selend - d->selstart;
-            o.format.setBackground(pal.brush(QPalette::Highlight));
-            o.format.setForeground(pal.brush(QPalette::HighlightedText));
-        } else {
-            // mask selection
-            o.start = d->cursor;
-            o.length = 1;
-            o.format.setBackground(pal.brush(QPalette::Text));
-            o.format.setForeground(pal.brush(QPalette::Window));
-        }
-        selections.append(o);
-    }
+    if (d->control->hasSelectedText() || (d->cursorVisible && !d->control->inputMask().isEmpty() && !d->control->isReadOnly()))
+        flags |= QLineControl::DrawSelections;
 
     // Asian users see an IM selection text as cursor on candidate
     // selection phase of input method, so the ordinary cursor should be
     // invisible if we have a preedit string.
-    d->textLayout.draw(&p, topLeft, selections, r);
-    if (d->cursorVisible && !d->readOnly && !d->hideCursor)
-        d->textLayout.drawCursor(&p, topLeft, cursor, style()->pixelMetric(QStyle::PM_TextCursorWidth));
+    if (d->cursorVisible && !d->control->isReadOnly())
+        flags |= QLineControl::DrawCursor;
+
+    d->control->setCursorWidth(style()->pixelMetric(QStyle::PM_TextCursorWidth));
+    d->control->draw(&p, topLeft, r, flags);
+
 }
 
 
@@ -2609,12 +1877,11 @@ void QLineEdit::paintEvent(QPaintEvent *)
 void QLineEdit::dragMoveEvent(QDragMoveEvent *e)
 {
     Q_D(QLineEdit);
-    if (!d->readOnly && e->mimeData()->hasFormat(QLatin1String("text/plain"))) {
+    if (!d->control->isReadOnly() && e->mimeData()->hasFormat(QLatin1String("text/plain"))) {
         e->acceptProposedAction();
-        d->cursor = d->xToPos(e->pos().x());
+        d->control->moveCursor(d->xToPos(e->pos().x()), false);
         d->cursorVisible = true;
         update();
-        d->emitCursorPositionChanged();
     }
 }
 
@@ -2640,13 +1907,14 @@ void QLineEdit::dropEvent(QDropEvent* e)
     Q_D(QLineEdit);
     QString str = e->mimeData()->text();
 
-    if (!str.isNull() && !d->readOnly) {
+    if (!str.isNull() && !d->control->isReadOnly()) {
         if (e->source() == this && e->dropAction() == Qt::CopyAction)
             deselect();
-        d->cursor =d->xToPos(e->pos().x());
-        int selStart = d->cursor;
-        int oldSelStart = d->selstart;
-        int oldSelEnd = d->selend;
+        int cursorPos = d->xToPos(e->pos().x());
+        int selStart = cursorPos;
+        int oldSelStart = d->control->selectionStart();
+        int oldSelEnd = d->control->selectionEnd();
+        d->control->moveCursor(cursorPos, false);
         d->cursorVisible = false;
         e->acceptProposedAction();
         insert(str);
@@ -2668,22 +1936,6 @@ void QLineEdit::dropEvent(QDropEvent* e)
     }
 }
 
-void QLineEditPrivate::drag()
-{
-    Q_Q(QLineEdit);
-    dndTimer.stop();
-    QMimeData *data = new QMimeData;
-    data->setText(q->selectedText());
-    QDrag *drag = new QDrag(q);
-    drag->setMimeData(data);
-    Qt::DropAction action = drag->start();
-    if (action == Qt::MoveAction && !readOnly && drag->target() != q) {
-        int priorState = undoState;
-        removeSelectedText();
-        finishChange(priorState);
-    }
-}
-
 #endif // QT_NO_DRAGANDDROP
 
 #ifndef QT_NO_CONTEXTMENU
@@ -2728,37 +1980,39 @@ QMenu *QLineEdit::createStandardContextMenu()
     popup->setObjectName(QLatin1String("qt_edit_menu"));
 
     QAction *action = popup->addAction(QLineEdit::tr("&Undo") + ACCEL_KEY(QKeySequence::Undo));
-    action->setEnabled(d->isUndoAvailable());
+    action->setEnabled(d->control->isUndoAvailable());
     connect(action, SIGNAL(triggered()), SLOT(undo()));
 
     action = popup->addAction(QLineEdit::tr("&Redo") + ACCEL_KEY(QKeySequence::Redo));
-    action->setEnabled(d->isRedoAvailable());
+    action->setEnabled(d->control->isRedoAvailable());
     connect(action, SIGNAL(triggered()), SLOT(redo()));
 
     popup->addSeparator();
 
 #ifndef QT_NO_CLIPBOARD
     action = popup->addAction(QLineEdit::tr("Cu&t") + ACCEL_KEY(QKeySequence::Cut));
-    action->setEnabled(!d->readOnly && d->hasSelectedText() && d->echoMode == QLineEdit::Normal);
+    action->setEnabled(!d->control->isReadOnly() && d->control->hasSelectedText()
+            && d->control->echoMode() == QLineEdit::Normal);
     connect(action, SIGNAL(triggered()), SLOT(cut()));
 
     action = popup->addAction(QLineEdit::tr("&Copy") + ACCEL_KEY(QKeySequence::Copy));
-    action->setEnabled(d->hasSelectedText() && d->echoMode == QLineEdit::Normal);
+    action->setEnabled(d->control->hasSelectedText()
+            && d->control->echoMode() == QLineEdit::Normal);
     connect(action, SIGNAL(triggered()), SLOT(copy()));
 
     action = popup->addAction(QLineEdit::tr("&Paste") + ACCEL_KEY(QKeySequence::Paste));
-    action->setEnabled(!d->readOnly && !QApplication::clipboard()->text().isEmpty());
+    action->setEnabled(!d->control->isReadOnly() && !QApplication::clipboard()->text().isEmpty());
     connect(action, SIGNAL(triggered()), SLOT(paste()));
 #endif
 
     action = popup->addAction(QLineEdit::tr("Delete"));
-    action->setEnabled(!d->readOnly && !d->text.isEmpty() && d->hasSelectedText());
+    action->setEnabled(!d->control->isReadOnly() && !d->control->text().isEmpty() && d->control->hasSelectedText());
     connect(action, SIGNAL(triggered()), SLOT(_q_deleteSelected()));
 
     popup->addSeparator();
 
     action = popup->addAction(QLineEdit::tr("Select All") + ACCEL_KEY(QKeySequence::SelectAll));
-    action->setEnabled(!d->text.isEmpty() && !d->allSelected());
+    action->setEnabled(!d->control->text().isEmpty() && !d->control->allSelected());
     d->selectAllAction = action;
     connect(action, SIGNAL(triggered()), SLOT(selectAll()));
 
@@ -2772,9 +2026,9 @@ QMenu *QLineEdit::createStandardContextMenu()
 #endif
 
 #if defined(Q_WS_WIN)
-    if (!d->readOnly && qt_use_rtl_extensions) {
+    if (!d->control->isReadOnly() && qt_use_rtl_extensions) {
 #else
-    if (!d->readOnly) {
+    if (!d->control->isReadOnly()) {
 #endif
         popup->addSeparator();
         QUnicodeControlCharacterMenu *ctrlCharacterMenu = new QUnicodeControlCharacterMenu(this, popup);
@@ -2788,807 +2042,26 @@ QMenu *QLineEdit::createStandardContextMenu()
 void QLineEdit::changeEvent(QEvent *ev)
 {
     Q_D(QLineEdit);
-    if(ev->type() == QEvent::ActivationChange) {
+    switch(ev->type())
+    {
+    case QEvent::ActivationChange:
         if (!palette().isEqual(QPalette::Active, QPalette::Inactive))
             update();
-    } else if (ev->type() == QEvent::FontChange
-               || ev->type() == QEvent::StyleChange
-               || ev->type() == QEvent::LayoutDirectionChange) {
-        d->updateTextLayout();
-    }
-    QWidget::changeEvent(ev);
-}
-
-void QLineEditPrivate::_q_handleWindowActivate()
-{
-    Q_Q(QLineEdit);
-    if (!q->hasFocus() && q->hasSelectedText())
-        q->deselect();
-}
-
-void QLineEditPrivate::_q_deleteSelected()
-{
-    Q_Q(QLineEdit);
-    if (!hasSelectedText())
-        return;
-
-    int priorState = undoState;
-    q->resetInputContext();
-    removeSelectedText();
-    separate();
-    finishChange(priorState);
-}
-
-void QLineEditPrivate::init(const QString& txt)
-{
-    Q_Q(QLineEdit);
-#ifndef QT_NO_CURSOR
-    q->setCursor(Qt::IBeamCursor);
-#endif
-    q->setFocusPolicy(Qt::StrongFocus);
-    q->setAttribute(Qt::WA_InputMethodEnabled);
-    //   Specifies that this widget can use more, but is able to survive on
-    //   less, horizontal space; and is fixed vertically.
-    q->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed, QSizePolicy::LineEdit));
-    q->setBackgroundRole(QPalette::Base);
-    q->setAttribute(Qt::WA_KeyCompression);
-    q->setMouseTracking(true);
-    q->setAcceptDrops(true);
-    text = txt;
-    updateTextLayout();
-    cursor = text.length();
-
-    q->setAttribute(Qt::WA_MacShowFocusRect);
-}
-
-void QLineEditPrivate::updatePasswordEchoEditing(bool editing)
-{
-    Q_Q(QLineEdit);
-    passwordEchoEditing = editing;
-    q->setAttribute(Qt::WA_InputMethodEnabled, shouldEnableInputMethod(q));
-    updateTextLayout();
-    q->update();
-}
-
-void QLineEditPrivate::updateTextLayout()
-{
-    // replace certain non-printable characters with spaces (to avoid
-    // drawing boxes when using fonts that don't have glyphs for such
-    // characters)
-    Q_Q(QLineEdit);
-    QString str = q->displayText();
-    QChar* uc = str.data();
-    for (int i = 0; i < (int)str.length(); ++i) {
-        if ((uc[i] < 0x20 && uc[i] != 0x09)
-            || uc[i] == QChar::LineSeparator
-            || uc[i] == QChar::ParagraphSeparator
-            || uc[i] == QChar::ObjectReplacementCharacter)
-            uc[i] = QChar(0x0020);
-    }
-    textLayout.setFont(q->font());
-    textLayout.setText(str);
-    QTextOption option;
-    option.setTextDirection(q->layoutDirection());
-    option.setFlags(QTextOption::IncludeTrailingSpaces);
-    textLayout.setTextOption(option);
-
-    textLayout.beginLayout();
-    QTextLine l = textLayout.createLine();
-    textLayout.endLayout();
-    ascent = qRound(l.ascent());
-}
-
-int QLineEditPrivate::xToPos(int x, QTextLine::CursorPosition betweenOrOn) const
-{
-    QRect cr = adjustedContentsRect();
-    x-= cr.x() - hscroll + horizontalMargin;
-    QTextLine l = textLayout.lineAt(0);
-    return l.xToCursor(x, betweenOrOn);
-}
-
-QRect QLineEditPrivate::cursorRect() const
-{
-    Q_Q(const QLineEdit);
-    QRect cr = adjustedContentsRect();
-    int cix = cr.x() - hscroll + horizontalMargin;
-    QTextLine l = textLayout.lineAt(0);
-    int c = cursor;
-    if (preeditCursor != -1)
-        c += preeditCursor;
-    cix += qRound(l.cursorToX(c));
-    int ch = qMin(cr.height(), q->fontMetrics().height() + 1);
-    int w = q->style()->pixelMetric(QStyle::PM_TextCursorWidth);
-    return QRect(cix-5, vscroll, w + 9, ch);
-}
-
-QRect QLineEditPrivate::adjustedContentsRect() const
-{
-    Q_Q(const QLineEdit);
-    QStyleOptionFrameV2 opt;
-    q->initStyleOption(&opt);
-    QRect r = q->style()->subElementRect(QStyle::SE_LineEditContents, &opt, q);
-    r.setX(r.x() + leftTextMargin);
-    r.setY(r.y() + topTextMargin);
-    r.setRight(r.right() - rightTextMargin);
-    r.setBottom(r.bottom() - bottomTextMargin);
-    return r;
-}
-
-bool QLineEditPrivate::fixup() // this function assumes that validate currently returns != Acceptable
-{
-#ifndef QT_NO_VALIDATOR
-    if (validator) {
-        QString textCopy = text;
-        int cursorCopy = cursor;
-        validator->fixup(textCopy);
-        if (validator->validate(textCopy, cursorCopy) == QValidator::Acceptable) {
-            if (textCopy != text || cursorCopy != cursor)
-                setText(textCopy, cursorCopy);
-            return true;
-        }
-    }
-#endif
-    return false;
-}
-
-void QLineEditPrivate::moveCursor(int pos, bool mark)
-{
-    Q_Q(QLineEdit);
-    if (pos != cursor) {
-        separate();
-        if (maskData)
-            pos = pos > cursor ? nextMaskBlank(pos) : prevMaskBlank(pos);
-    }
-    bool fullUpdate = mark || hasSelectedText();
-    if (mark) {
-        int anchor;
-        if (selend > selstart && cursor == selstart)
-            anchor = selend;
-        else if (selend > selstart && cursor == selend)
-            anchor = selstart;
-        else
-            anchor = cursor;
-        selstart = qMin(anchor, pos);
-        selend = qMax(anchor, pos);
-        updateTextLayout();
-    } else {
-        deselect();
-    }
-    if (fullUpdate) {
-        cursor = pos;
-        q->update();
-    } else {
-        setCursorVisible(false);
-        cursor = pos;
-        setCursorVisible(true);
-        if (!adjustedContentsRect().contains(cursorRect()))
-            q->update();
-    }
-    QStyleOptionFrameV2 opt;
-    q->initStyleOption(&opt);
-    if (mark && !q->style()->styleHint(QStyle::SH_BlinkCursorWhenTextSelected, &opt, q))
-        setCursorVisible(false);
-    if (mark || selDirty) {
-        selDirty = false;
-        emit q->selectionChanged();
-    }
-    q->updateMicroFocus();
-    emitCursorPositionChanged();
-}
-
-void QLineEditPrivate::finishChange(int validateFromState, bool update, bool edited)
-{
-    Q_Q(QLineEdit);
-    bool lineDirty = selDirty;
-    if (textDirty) {
-        // do validation
-        bool wasValidInput = validInput;
-        validInput = true;
-#ifndef QT_NO_VALIDATOR
-        if (validator) {
-            validInput = false;
-            QString textCopy = text;
-            int cursorCopy = cursor;
-            validInput = (validator->validate(textCopy, cursorCopy) != QValidator::Invalid);
-            if (validInput) {
-                if (text != textCopy) {
-                    setText(textCopy, cursorCopy);
-                    return;
-                }
-                cursor = cursorCopy;
-            }
-        }
-#endif
-        if (validateFromState >= 0 && wasValidInput && !validInput) {
-            undo(validateFromState);
-            history.resize(undoState);
-            if (modifiedState > undoState)
-                modifiedState = -1;
-            validInput = true;
-            textDirty = false;
-        }
-        updateTextLayout();
-        lineDirty |= textDirty;
-        if (textDirty) {
-            textDirty = false;
-            QString actualText = maskData ? stripString(text) : text;
-            if (edited)
-                emit q->textEdited(actualText);
-            q->updateMicroFocus();
-#ifndef QT_NO_COMPLETER
-            if (edited && completer && completer->completionMode() != QCompleter::InlineCompletion)
-                complete(-1); // update the popup on cut/paste/del
-#endif
-            emit q->textChanged(actualText);
-        }
-#ifndef QT_NO_ACCESSIBILITY
-        QAccessible::updateAccessibility(q, 0, QAccessible::ValueChanged);
-#endif
-    }
-    if (selDirty) {
-        selDirty = false;
-        emit q->selectionChanged();
-    }
-    if (lineDirty || update)
-        q->update();
-    emitCursorPositionChanged();
-}
-
-void QLineEditPrivate::emitCursorPositionChanged()
-{
-    Q_Q(QLineEdit);
-    if (cursor != lastCursorPos) {
-        const int oldLast = lastCursorPos;
-        lastCursorPos = cursor;
-        emit q->cursorPositionChanged(oldLast, cursor);
-    }
-}
-
-void QLineEditPrivate::setText(const QString& txt, int pos, bool edited)
-{
-    Q_Q(QLineEdit);
-    q->resetInputContext();
-    deselect();
-    QString oldText = text;
-    if (maskData) {
-        text = maskString(0, txt, true);
-        text += clearString(text.length(), maxLength - text.length());
-    } else {
-        text = txt.isEmpty() ? txt : txt.left(maxLength);
-    }
-    history.clear();
-    modifiedState =  undoState = 0;
-    cursor = (pos < 0 || pos > text.length()) ? text.length() : pos;
-    textDirty = (oldText != text);
-    finishChange(-1, true, edited);
-}
-
-
-void QLineEditPrivate::setCursorVisible(bool visible)
-{
-    Q_Q(QLineEdit);
-    if ((bool)cursorVisible == visible)
-        return;
-    if (cursorTimer)
-        cursorVisible = visible;
-    QRect r = cursorRect();
-    if (maskData)
-        q->update();
-    else
-        q->update(r);
-}
-
-void QLineEditPrivate::addCommand(const Command& cmd)
-{
-    if (separator && undoState && history[undoState-1].type != Separator) {
-        history.resize(undoState + 2);
-        history[undoState++] = Command(Separator, cursor, 0, selstart, selend);
-    } else {
-        history.resize(undoState + 1);
-    }
-    separator = false;
-    history[undoState++] = cmd;
-}
-
-void QLineEditPrivate::insert(const QString& s)
-{
-    if (hasSelectedText())
-        addCommand(Command(SetSelection, cursor, 0, selstart, selend));
-    if (maskData) {
-        QString ms = maskString(cursor, s);
-        for (int i = 0; i < (int) ms.length(); ++i) {
-            addCommand (Command(DeleteSelection, cursor+i, text.at(cursor+i), -1, -1));
-            addCommand(Command(Insert, cursor+i, ms.at(i), -1, -1));
-        }
-        text.replace(cursor, ms.length(), ms);
-        cursor += ms.length();
-        cursor = nextMaskBlank(cursor);
-        textDirty = true;
-    } else {
-        int remaining = maxLength - text.length();
-        if (remaining != 0) {
-            text.insert(cursor, s.left(remaining));
-            for (int i = 0; i < (int) s.left(remaining).length(); ++i)
-               addCommand(Command(Insert, cursor++, s.at(i), -1, -1));
-            textDirty = true;
-        }
-    }
-}
-
-void QLineEditPrivate::del(bool wasBackspace)
-{
-    if (cursor < (int) text.length()) {
-        if (hasSelectedText())
-            addCommand(Command(SetSelection, cursor, 0, selstart, selend));
-        addCommand (Command((CommandType)((maskData?2:0)+(wasBackspace?Remove:Delete)), cursor, text.at(cursor), -1, -1));
-        if (maskData) {
-            text.replace(cursor, 1, clearString(cursor, 1));
-            addCommand(Command(Insert, cursor, text.at(cursor), -1, -1));
-        } else {
-            text.remove(cursor, 1);
-        }
-        textDirty = true;
-    }
-}
-
-void QLineEditPrivate::removeSelectedText()
-{
-    if (selstart < selend && selend <= (int) text.length()) {
-        separate();
-        int i ;
-        addCommand(Command(SetSelection, cursor, 0, selstart, selend));
-        if (selstart <= cursor && cursor < selend) {
-            // cursor is within the selection. Split up the commands
-            // to be able to restore the correct cursor position
-            for (i = cursor; i >= selstart; --i)
-                addCommand (Command(DeleteSelection, i, text.at(i), -1, 1));
-            for (i = selend - 1; i > cursor; --i)
-                addCommand (Command(DeleteSelection, i - cursor + selstart - 1, text.at(i), -1, -1));
-        } else {
-            for (i = selend-1; i >= selstart; --i)
-                addCommand (Command(RemoveSelection, i, text.at(i), -1, -1));
-        }
-        if (maskData) {
-            text.replace(selstart, selend - selstart,  clearString(selstart, selend - selstart));
-            for (int i = 0; i < selend - selstart; ++i)
-                addCommand(Command(Insert, selstart + i, text.at(selstart + i), -1, -1));
-        } else {
-            text.remove(selstart, selend - selstart);
-        }
-        if (cursor > selstart)
-            cursor -= qMin(cursor, selend) - selstart;
-        deselect();
-        textDirty = true;
-
-        // adjust hscroll to avoid gap
-        const int minRB = qMax(0, -q_func()->fontMetrics().minRightBearing());
-        updateTextLayout();
-        const QTextLine line = textLayout.lineAt(0);
-        const int widthUsed = qRound(line.naturalTextWidth()) + 1 + minRB;
-        hscroll = qMin(hscroll, widthUsed);
-    }
-}
-
-void QLineEditPrivate::parseInputMask(const QString &maskFields)
-{
-    int delimiter = maskFields.indexOf(QLatin1Char(';'));
-    if (maskFields.isEmpty() || delimiter == 0) {
-        if (maskData) {
-            delete [] maskData;
-            maskData = 0;
-            maxLength = 32767;
-            setText(QString());
-        }
-        return;
-    }
-
-    if (delimiter == -1) {
-        blank = QLatin1Char(' ');
-        inputMask = maskFields;
-    } else {
-        inputMask = maskFields.left(delimiter);
-        blank = (delimiter + 1 < maskFields.length()) ? maskFields[delimiter + 1] : QLatin1Char(' ');
-    }
-
-    // calculate maxLength / maskData length
-    maxLength = 0;
-    QChar c = 0;
-    for (int i=0; i<inputMask.length(); i++) {
-        c = inputMask.at(i);
-        if (i > 0 && inputMask.at(i-1) == QLatin1Char('\\')) {
-            maxLength++;
-            continue;
-        }
-        if (c != QLatin1Char('\\') && c != QLatin1Char('!') &&
-             c != QLatin1Char('<') && c != QLatin1Char('>') &&
-             c != QLatin1Char('{') && c != QLatin1Char('}') &&
-             c != QLatin1Char('[') && c != QLatin1Char(']'))
-            maxLength++;
-    }
-
-    delete [] maskData;
-    maskData = new MaskInputData[maxLength];
-
-    MaskInputData::Casemode m = MaskInputData::NoCaseMode;
-    c = 0;
-    bool s;
-    bool escape = false;
-    int index = 0;
-    for (int i = 0; i < inputMask.length(); i++) {
-        c = inputMask.at(i);
-        if (escape) {
-            s = true;
-            maskData[index].maskChar = c;
-            maskData[index].separator = s;
-            maskData[index].caseMode = m;
-            index++;
-            escape = false;
-        } else if (c == QLatin1Char('<')) {
-                m = MaskInputData::Lower;
-        } else if (c == QLatin1Char('>')) {
-            m = MaskInputData::Upper;
-        } else if (c == QLatin1Char('!')) {
-            m = MaskInputData::NoCaseMode;
-        } else if (c != QLatin1Char('{') && c != QLatin1Char('}') && c != QLatin1Char('[') && c != QLatin1Char(']')) {
-            switch (c.unicode()) {
-            case 'A':
-            case 'a':
-            case 'N':
-            case 'n':
-            case 'X':
-            case 'x':
-            case '9':
-            case '0':
-            case 'D':
-            case 'd':
-            case '#':
-            case 'H':
-            case 'h':
-            case 'B':
-            case 'b':
-                s = false;
-                break;
-            case '\\':
-                escape = true;
-            default:
-                s = true;
-                break;
-            }
-
-            if (!escape) {
-                maskData[index].maskChar = c;
-                maskData[index].separator = s;
-                maskData[index].caseMode = m;
-                index++;
-            }
-        }
-    }
-    setText(text);
-}
-
-
-/* checks if the key is valid compared to the inputMask */
-bool QLineEditPrivate::isValidInput(QChar key, QChar mask) const
-{
-    switch (mask.unicode()) {
-    case 'A':
-        if (key.isLetter())
-            return true;
         break;
-    case 'a':
-        if (key.isLetter() || key == blank)
-            return true;
-        break;
-    case 'N':
-        if (key.isLetterOrNumber())
-            return true;
-        break;
-    case 'n':
-        if (key.isLetterOrNumber() || key == blank)
-            return true;
-        break;
-    case 'X':
-        if (key.isPrint())
-            return true;
-        break;
-    case 'x':
-        if (key.isPrint() || key == blank)
-            return true;
-        break;
-    case '9':
-        if (key.isNumber())
-            return true;
-        break;
-    case '0':
-        if (key.isNumber() || key == blank)
-            return true;
-        break;
-    case 'D':
-        if (key.isNumber() && key.digitValue() > 0)
-            return true;
+    case QEvent::FontChange:
+        d->control->setFont(font());
         break;
-    case 'd':
-        if ((key.isNumber() && key.digitValue() > 0) || key == blank)
-            return true;
-        break;
-    case '#':
-        if (key.isNumber() || key == QLatin1Char('+') || key == QLatin1Char('-') || key == blank)
-            return true;
-        break;
-    case 'B':
-        if (key == QLatin1Char('0') || key == QLatin1Char('1'))
-            return true;
-        break;
-    case 'b':
-        if (key == QLatin1Char('0') || key == QLatin1Char('1') || key == blank)
-            return true;
-        break;
-    case 'H':
-        if (key.isNumber() || (key >= QLatin1Char('a') && key <= QLatin1Char('f')) || (key >= QLatin1Char('A') && key <= QLatin1Char('F')))
-            return true;
+    case QEvent::StyleChange:
+        d->control->setPasswordCharacter(style()->styleHint(QStyle::SH_LineEdit_PasswordCharacter));
+        update();
         break;
-    case 'h':
-        if (key.isNumber() || (key >= QLatin1Char('a') && key <= QLatin1Char('f')) || (key >= QLatin1Char('A') && key <= QLatin1Char('F')) || key == blank)
-            return true;
+    case QEvent::LayoutDirectionChange:
+        d->control->setLayoutDirection(layoutDirection());
         break;
     default:
         break;
     }
-    return false;
-}
-
-bool QLineEditPrivate::hasAcceptableInput(const QString &str) const
-{
-#ifndef QT_NO_VALIDATOR
-    QString textCopy = str;
-    int cursorCopy = cursor;
-    if (validator && validator->validate(textCopy, cursorCopy)
-        != QValidator::Acceptable)
-        return false;
-#endif
-
-    if (!maskData)
-        return true;
-
-    if (str.length() != maxLength)
-        return false;
-
-    for (int i=0; i < maxLength; ++i) {
-        if (maskData[i].separator) {
-            if (str.at(i) != maskData[i].maskChar)
-                return false;
-        } else {
-            if (!isValidInput(str.at(i), maskData[i].maskChar))
-                return false;
-        }
-    }
-    return true;
-}
-
-/*
-  Applies the inputMask on \a str starting from position \a pos in the mask. \a clear
-  specifies from where characters should be gotten when a separator is met in \a str - true means
-  that blanks will be used, false that previous input is used.
-  Calling this when no inputMask is set is undefined.
-*/
-QString QLineEditPrivate::maskString(uint pos, const QString &str, bool clear) const
-{
-    if (pos >= (uint)maxLength)
-        return QString::fromLatin1("");
-
-    QString fill;
-    fill = clear ? clearString(0, maxLength) : text;
-
-    int strIndex = 0;
-    QString s = QString::fromLatin1("");
-    int i = pos;
-    while (i < maxLength) {
-        if (strIndex < str.length()) {
-            if (maskData[i].separator) {
-                s += maskData[i].maskChar;
-                if (str[(int)strIndex] == maskData[i].maskChar)
-                    strIndex++;
-                ++i;
-            } else {
-                if (isValidInput(str[(int)strIndex], maskData[i].maskChar)) {
-                    switch (maskData[i].caseMode) {
-                    case MaskInputData::Upper:
-                        s += str[(int)strIndex].toUpper();
-                        break;
-                    case MaskInputData::Lower:
-                        s += str[(int)strIndex].toLower();
-                        break;
-                    default:
-                        s += str[(int)strIndex];
-                    }
-                    ++i;
-                } else {
-                    // search for separator first
-                    int n = findInMask(i, true, true, str[(int)strIndex]);
-                    if (n != -1) {
-                        if (str.length() != 1 || i == 0 || (i > 0 && (!maskData[i-1].separator || maskData[i-1].maskChar != str[(int)strIndex]))) {
-                            s += fill.mid(i, n-i+1);
-                            i = n + 1; // update i to find + 1
-                        }
-                    } else {
-                        // search for valid blank if not
-                        n = findInMask(i, true, false, str[(int)strIndex]);
-                        if (n != -1) {
-                            s += fill.mid(i, n-i);
-                            switch (maskData[n].caseMode) {
-                            case MaskInputData::Upper:
-                                s += str[(int)strIndex].toUpper();
-                                break;
-                            case MaskInputData::Lower:
-                                s += str[(int)strIndex].toLower();
-                                break;
-                            default:
-                                s += str[(int)strIndex];
-                            }
-                            i = n + 1; // updates i to find + 1
-                        }
-                    }
-                }
-                strIndex++;
-            }
-        } else
-            break;
-    }
-
-    return s;
-}
-
-
-
-/*
-  Returns a "cleared" string with only separators and blank chars.
-  Calling this when no inputMask is set is undefined.
-*/
-QString QLineEditPrivate::clearString(uint pos, uint len) const
-{
-    if (pos >= (uint)maxLength)
-        return QString();
-
-    QString s;
-    int end = qMin((uint)maxLength, pos + len);
-    for (int i=pos; i<end; i++)
-        if (maskData[i].separator)
-            s += maskData[i].maskChar;
-        else
-            s += blank;
-
-    return s;
-}
-
-/*
-  Strips blank parts of the input in a QLineEdit when an inputMask is set,
-  separators are still included. Typically "127.0__.0__.1__" becomes "127.0.0.1".
-*/
-QString QLineEditPrivate::stripString(const QString &str) const
-{
-    if (!maskData)
-        return str;
-
-    QString s;
-    int end = qMin(maxLength, (int)str.length());
-    for (int i=0; i < end; i++)
-        if (maskData[i].separator)
-            s += maskData[i].maskChar;
-        else
-            if (str[i] != blank)
-                s += str[i];
-
-    return s;
-}
-
-/* searches forward/backward in maskData for either a separator or a blank */
-int QLineEditPrivate::findInMask(int pos, bool forward, bool findSeparator, QChar searchChar) const
-{
-    if (pos >= maxLength || pos < 0)
-        return -1;
-
-    int end = forward ? maxLength : -1;
-    int step = forward ? 1 : -1;
-    int i = pos;
-
-    while (i != end) {
-        if (findSeparator) {
-            if (maskData[i].separator && maskData[i].maskChar == searchChar)
-                return i;
-        } else {
-            if (!maskData[i].separator) {
-                if (searchChar.isNull())
-                    return i;
-                else if (isValidInput(searchChar, maskData[i].maskChar))
-                    return i;
-            }
-        }
-        i += step;
-    }
-    return -1;
-}
-
-void QLineEditPrivate::undo(int until)
-{
-    if (!isUndoAvailable())
-        return;
-    deselect();
-    while (undoState && undoState > until) {
-        Command& cmd = history[--undoState];
-        switch (cmd.type) {
-        case Insert:
-            text.remove(cmd.pos, 1);
-            cursor = cmd.pos;
-            break;
-        case SetSelection:
-            selstart = cmd.selStart;
-            selend = cmd.selEnd;
-            cursor = cmd.pos;
-            break;
-        case Remove:
-        case RemoveSelection:
-            text.insert(cmd.pos, cmd.uc);
-            cursor = cmd.pos + 1;
-            break;
-        case Delete:
-        case DeleteSelection:
-            text.insert(cmd.pos, cmd.uc);
-            cursor = cmd.pos;
-            break;
-        case Separator:
-            continue;
-        }
-        if (until < 0 && undoState) {
-            Command& next = history[undoState-1];
-            if (next.type != cmd.type && next.type < RemoveSelection
-                 && (cmd.type < RemoveSelection || next.type == Separator))
-                break;
-        }
-    }
-    textDirty = true;
-    emitCursorPositionChanged();
-}
-
-void QLineEditPrivate::redo() {
-    if (!isRedoAvailable())
-        return;
-    deselect();
-    while (undoState < (int)history.size()) {
-        Command& cmd = history[undoState++];
-        switch (cmd.type) {
-        case Insert:
-            text.insert(cmd.pos, cmd.uc);
-            cursor = cmd.pos + 1;
-            break;
-        case SetSelection:
-            selstart = cmd.selStart;
-            selend = cmd.selEnd;
-            cursor = cmd.pos;
-            break;
-        case Remove:
-        case Delete:
-        case RemoveSelection:
-        case DeleteSelection:
-            text.remove(cmd.pos, 1);
-            selstart = cmd.selStart;
-            selend = cmd.selEnd;
-            cursor = cmd.pos;
-            break;
-        case Separator:
-            selstart = cmd.selStart;
-            selend = cmd.selEnd;
-            cursor = cmd.pos;
-            break;
-        }
-        if (undoState < (int)history.size()) {
-            Command& next = history[undoState];
-            if (next.type != cmd.type && cmd.type < RemoveSelection && next.type != Separator
-                 && (next.type < RemoveSelection || cmd.type == Separator))
-                break;
-        }
-    }
-    textDirty = true;
-    emitCursorPositionChanged();
+    QWidget::changeEvent(ev);
 }
 
 /*!
diff --git a/src/gui/widgets/qlineedit.h b/src/gui/widgets/qlineedit.h
index a97dc9a..daac6a7 100644
--- a/src/gui/widgets/qlineedit.h
+++ b/src/gui/widgets/qlineedit.h
@@ -268,6 +268,8 @@ private:
     Q_DECLARE_PRIVATE(QLineEdit)
     Q_PRIVATE_SLOT(d_func(), void _q_handleWindowActivate())
     Q_PRIVATE_SLOT(d_func(), void _q_deleteSelected())
+    Q_PRIVATE_SLOT(d_func(), void _q_textEdited(const QString &))
+    Q_PRIVATE_SLOT(d_func(), void _q_cursorPositionChanged(int, int))
 #ifndef QT_NO_COMPLETER
     Q_PRIVATE_SLOT(d_func(), void _q_completionHighlighted(QString))
 #endif
diff --git a/src/gui/widgets/qlineedit_p.cpp b/src/gui/widgets/qlineedit_p.cpp
new file mode 100644
index 0000000..0e39304
--- /dev/null
+++ b/src/gui/widgets/qlineedit_p.cpp
@@ -0,0 +1,253 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qlineedit.h"
+#include "qlineedit_p.h"
+
+#ifndef QT_NO_LINEEDIT
+
+#include "qabstractitemview.h"
+#include "qclipboard.h"
+#ifndef QT_NO_ACCESSIBILITY
+#include "qaccessible.h"
+#endif
+#ifndef QT_NO_IM
+#include "qinputcontext.h"
+#include "qlist.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+const int QLineEditPrivate::verticalMargin(1);
+const int QLineEditPrivate::horizontalMargin(2);
+
+int QLineEditPrivate::xToPos(int x, QTextLine::CursorPosition betweenOrOn) const
+{
+    QRect cr = adjustedContentsRect();
+    x-= cr.x() - hscroll + horizontalMargin;
+    return control->xToPos(x, betweenOrOn);
+}
+
+QRect QLineEditPrivate::cursorRect() const
+{
+    QRect cr = adjustedContentsRect();
+    int cix = cr.x() - hscroll + horizontalMargin;
+    QRect crect = control->cursorRect();
+    crect.moveTo(crect.topLeft() + QPoint(cix, vscroll));
+    return crect;
+}
+
+#ifndef QT_NO_COMPLETER
+
+void QLineEditPrivate::_q_completionHighlighted(QString newText)
+{
+    Q_Q(QLineEdit);
+    if (control->completer()->completionMode() != QCompleter::InlineCompletion) {
+        q->setText(newText);
+    } else {
+        int c = control->cursor();
+        QString text = control->text();
+        q->setText(text.left(c) + newText.mid(c));
+        control->moveCursor(control->end(), false);
+        control->moveCursor(c, true);
+    }
+}
+
+#endif // QT_NO_COMPLETER
+
+void QLineEditPrivate::_q_clipboardChanged()
+{
+}
+
+void QLineEditPrivate::_q_handleWindowActivate()
+{
+    Q_Q(QLineEdit);
+    if (!q->hasFocus() && control->hasSelectedText())
+        control->deselect();
+}
+
+void QLineEditPrivate::_q_deleteSelected()
+{
+}
+
+void QLineEditPrivate::_q_textEdited(const QString &text)
+{
+    Q_Q(QLineEdit);
+#ifndef QT_NO_COMPLETER
+    if (control->completer() &&
+            control->completer()->completionMode() != QCompleter::InlineCompletion)
+        control->complete(-1); // update the popup on cut/paste/del
+#endif
+    emit q->textEdited(text);
+}
+
+void QLineEditPrivate::_q_cursorPositionChanged(int from, int to)
+{
+    Q_Q(QLineEdit);
+    q->update();
+    emit q->cursorPositionChanged(from, to);
+}
+
+void QLineEditPrivate::init(const QString& txt)
+{
+    Q_Q(QLineEdit);
+    control = new QLineControl(txt);
+    QObject::connect(control, SIGNAL(textChanged(const QString &)),
+            q, SIGNAL(textChanged(const QString &)));
+    QObject::connect(control, SIGNAL(textEdited(const QString &)),
+            q, SLOT(_q_textEdited(const QString &)));
+    QObject::connect(control, SIGNAL(cursorPositionChanged(int, int)),
+            q, SLOT(_q_cursorPositionChanged(int, int)));
+    QObject::connect(control, SIGNAL(selectionChanged()),
+            q, SIGNAL(selectionChanged()));
+    QObject::connect(control, SIGNAL(accepted()),
+            q, SIGNAL(returnPressed()));
+    QObject::connect(control, SIGNAL(editingFinished()),
+            q, SIGNAL(editingFinished()));
+
+    // for now, going completely overboard with updates.
+    QObject::connect(control, SIGNAL(selectionChanged()),
+            q, SLOT(update()));
+
+    QObject::connect(control, SIGNAL(displayTextChanged(const QString &)),
+            q, SLOT(update()));
+    control->setPasswordCharacter(q->style()->styleHint(QStyle::SH_LineEdit_PasswordCharacter));
+#ifndef QT_NO_CURSOR
+    q->setCursor(Qt::IBeamCursor);
+#endif
+    q->setFocusPolicy(Qt::StrongFocus);
+    q->setAttribute(Qt::WA_InputMethodEnabled);
+    //   Specifies that this widget can use more, but is able to survive on
+    //   less, horizontal space; and is fixed vertically.
+    q->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed, QSizePolicy::LineEdit));
+    q->setBackgroundRole(QPalette::Base);
+    q->setAttribute(Qt::WA_KeyCompression);
+    q->setMouseTracking(true);
+    q->setAcceptDrops(true);
+
+    q->setAttribute(Qt::WA_MacShowFocusRect);
+}
+
+QRect QLineEditPrivate::adjustedContentsRect() const
+{
+    Q_Q(const QLineEdit);
+    QStyleOptionFrameV2 opt;
+    q->initStyleOption(&opt);
+    QRect r = q->style()->subElementRect(QStyle::SE_LineEditContents, &opt, q);
+    r.setX(r.x() + leftTextMargin);
+    r.setY(r.y() + topTextMargin);
+    r.setRight(r.right() - rightTextMargin);
+    r.setBottom(r.bottom() - bottomTextMargin);
+    return r;
+}
+
+void QLineEditPrivate::setCursorVisible(bool visible)
+{
+    Q_Q(QLineEdit);
+    if ((bool)cursorVisible == visible)
+        return;
+    cursorVisible = visible;
+    QRect r = cursorRect();
+    if (control->inputMask().isEmpty())
+        q->update(r);
+    else
+        q->update();
+}
+
+void QLineEditPrivate::updatePasswordEchoEditing(bool editing)
+{
+    Q_Q(QLineEdit);
+    control->updatePasswordEchoEditing(editing);
+    q->setAttribute(Qt::WA_InputMethodEnabled, shouldEnableInputMethod());
+}
+
+/*!
+  This function is not intended as polymorphic usage. Just a shared code
+  fragment that calls QInputContext::mouseHandler for this
+  class.
+*/
+bool QLineEditPrivate::sendMouseEventToInputContext( QMouseEvent *e )
+{
+#if !defined QT_NO_IM
+    Q_Q(QLineEdit);
+    if ( control->composeMode() ) {
+	int tmp_cursor = xToPos(e->pos().x());
+	int mousePos = tmp_cursor - control->cursor();
+	if ( mousePos < 0 || mousePos > control->preeditAreaText().length() ) {
+            mousePos = -1;
+	    // don't send move events outside the preedit area
+            if ( e->type() == QEvent::MouseMove )
+                return true;
+        }
+
+        QInputContext *qic = q->inputContext();
+        if ( qic )
+            // may be causing reset() in some input methods
+            qic->mouseHandler(mousePos, e);
+        if (!control->preeditAreaText().isEmpty())
+            return true;
+    }
+#else
+    Q_UNUSED(e);
+#endif
+
+    return false;
+}
+
+#ifndef QT_NO_DRAGANDDROP
+void QLineEditPrivate::drag()
+{
+    Q_Q(QLineEdit);
+    dndTimer.stop();
+    QMimeData *data = new QMimeData;
+    data->setText(control->selectedText());
+    QDrag *drag = new QDrag(q);
+    drag->setMimeData(data);
+    Qt::DropAction action = drag->start();
+    if (action == Qt::MoveAction && !control->isReadOnly() && drag->target() != q)
+        control->removeSelection();
+}
+
+#endif // QT_NO_DRAGANDDROP
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/widgets/qlineedit_p.h b/src/gui/widgets/qlineedit_p.h
index 03029f9..230023d 100644
--- a/src/gui/widgets/qlineedit_p.h
+++ b/src/gui/widgets/qlineedit_p.h
@@ -65,6 +65,8 @@
 #include "QtCore/qpointer.h"
 #include "QtGui/qlineedit.h"
 
+#include "private/qlinecontrol_p.h"
+
 QT_BEGIN_NAMESPACE
 
 class QLineEditPrivate : public QWidgetPrivate
@@ -73,169 +75,64 @@ class QLineEditPrivate : public QWidgetPrivate
 public:
 
     QLineEditPrivate()
-        : cursor(0), preeditCursor(0), cursorTimer(0), frame(1),
-          cursorVisible(0), hideCursor(false), separator(0), readOnly(0),
-          dragEnabled(0), contextMenuEnabled(1), echoMode(0), textDirty(0),
-          selDirty(0), validInput(1), clickCausedFocus(0),
-          alignment(Qt::AlignLeading | Qt::AlignVCenter), ascent(0),
-          maxLength(32767), hscroll(0), vscroll(0), lastCursorPos(-1), maskData(0),
-          modifiedState(0), undoState(0), selstart(0), selend(0), userInput(false),
-          emitingEditingFinished(false), passwordEchoEditing(false)
-#ifndef QT_NO_COMPLETER
-        , completer(0)
-#endif
-        , leftTextMargin(0), topTextMargin(0), rightTextMargin(0), bottomTextMargin(0)
-        {
-        }
+        : control(0), frame(1), contextMenuEnabled(1), cursorVisible(0),
+        dragEnabled(0), hscroll(0), vscroll(0),
+        alignment(Qt::AlignLeading | Qt::AlignVCenter),
+        leftTextMargin(0), topTextMargin(0), rightTextMargin(0), bottomTextMargin(0)
+    {
+    }
 
     ~QLineEditPrivate()
     {
-        delete [] maskData;
     }
+
+    QLineControl *control;
+
+#ifndef QT_NO_CONTEXTMENU
+    QPointer<QAction> selectAllAction;
+#endif
     void init(const QString&);
 
-    QString text;
-    int cursor;
-    int preeditCursor;
-    int cursorTimer; // -1 for non blinking cursor.
+    int xToPos(int x, QTextLine::CursorPosition = QTextLine::CursorBetweenCharacters) const;
+    QRect cursorRect() const;
+    void setCursorVisible(bool visible);
+
+    void updatePasswordEchoEditing(bool);
+
+    inline bool shouldEnableInputMethod() const
+    {
+        return !control->isReadOnly() && (control->echoMode() == QLineEdit::Normal || control->echoMode() == QLineEdit::PasswordEchoOnEdit);
+    }
+
     QPoint tripleClick;
     QBasicTimer tripleClickTimer;
     uint frame : 1;
+    uint contextMenuEnabled : 1;
     uint cursorVisible : 1;
-    uint hideCursor : 1; // used to hide the cursor inside preedit areas
-    uint separator : 1;
-    uint readOnly : 1;
     uint dragEnabled : 1;
-    uint contextMenuEnabled : 1;
-    uint echoMode : 2;
-    uint textDirty : 1;
-    uint selDirty : 1;
-    uint validInput : 1;
-    uint clickCausedFocus : 1;
-    uint alignment;
-    int ascent;
-    int maxLength;
     int hscroll;
     int vscroll;
-    int lastCursorPos;
-
-#ifndef QT_NO_CONTEXTMENU
-    QPointer<QAction> selectAllAction;
-#endif
+    uint alignment;
+    static const int verticalMargin;
+    static const int horizontalMargin;
 
-    inline void emitCursorPositionChanged();
     bool sendMouseEventToInputContext(QMouseEvent *e);
 
-    void finishChange(int validateFromState = -1, bool update = false, bool edited = true);
-
-    QPointer<QValidator> validator;
-    struct MaskInputData {
-        enum Casemode { NoCaseMode, Upper, Lower };
-        QChar maskChar; // either the separator char or the inputmask
-        bool separator;
-        Casemode caseMode;
-    };
-    QString inputMask;
-    QChar blank;
-    MaskInputData *maskData;
-    inline int nextMaskBlank(int pos) {
-        int c = findInMask(pos, true, false);
-        separator |= (c != pos);
-        return (c != -1 ?  c : maxLength);
-    }
-    inline int prevMaskBlank(int pos) {
-        int c = findInMask(pos, false, false);
-        separator |= (c != pos);
-        return (c != -1 ? c : 0);
-    }
-
-    void setCursorVisible(bool visible);
-
-
-    // undo/redo handling
-    enum CommandType { Separator, Insert, Remove, Delete, RemoveSelection, DeleteSelection, SetSelection };
-    struct Command {
-        inline Command() {}
-        inline Command(CommandType t, int p, QChar c, int ss, int se) : type(t),uc(c),pos(p),selStart(ss),selEnd(se) {}
-        uint type : 4;
-        QChar uc;
-        int pos, selStart, selEnd;
-    };
-    int modifiedState;
-    int undoState;
-    QVector<Command> history;
-    void addCommand(const Command& cmd);
-    void insert(const QString& s);
-    void del(bool wasBackspace = false);
-    void remove(int pos);
-
-    inline void separate() { separator = true; }
-    void undo(int until = -1);
-    void redo();
-    inline bool isUndoAvailable() const { return !readOnly && undoState; }
-    inline bool isRedoAvailable() const { return !readOnly && undoState < (int)history.size(); }
-
-    // selection
-    int selstart, selend;
-    inline bool allSelected() const { return !text.isEmpty() && selstart == 0 && selend == (int)text.length(); }
-    inline bool hasSelectedText() const { return !text.isEmpty() && selend > selstart; }
-    inline void deselect() { selDirty |= (selend > selstart); selstart = selend = 0; }
-    void removeSelectedText();
-#ifndef QT_NO_CLIPBOARD
-    void copy(bool clipboard = true) const;
-#endif
-    inline bool inSelection(int x) const
-    { if (selstart >= selend) return false;
-    int pos = xToPos(x, QTextLine::CursorOnCharacter);  return pos >= selstart && pos < selend; }
-
-    // masking
-    void parseInputMask(const QString &maskFields);
-    bool isValidInput(QChar key, QChar mask) const;
-    bool hasAcceptableInput(const QString &text) const;
-    QString maskString(uint pos, const QString &str, bool clear = false) const;
-    QString clearString(uint pos, uint len) const;
-    QString stripString(const QString &str) const;
-    int findInMask(int pos, bool forward, bool findSeparator, QChar searchChar = QChar()) const;
-
-    // input methods
-    bool composeMode() const { return !textLayout.preeditAreaText().isEmpty(); }
-
-    // complex text layout
-    QTextLayout textLayout;
-    void updateTextLayout();
-    void moveCursor(int pos, bool mark = false);
-    void setText(const QString& txt, int pos = -1, bool edited = true);
-    int xToPos(int x, QTextLine::CursorPosition = QTextLine::CursorBetweenCharacters) const;
-    QRect cursorRect() const;
-    bool fixup();
-
     QRect adjustedContentsRect() const;
 
-#ifndef QT_NO_DRAGANDDROP
-    // drag and drop
-    QPoint dndPos;
-    QBasicTimer dndTimer;
-    void drag();
-#endif
-
+    void _q_clipboardChanged();
     void _q_handleWindowActivate();
     void _q_deleteSelected();
-    bool userInput;
-    bool emitingEditingFinished;
-
-#ifdef QT_KEYPAD_NAVIGATION
-    QBasicTimer deleteAllTimer; // keypad navigation
-    QString origText;
-#endif
-
-    bool passwordEchoEditing;
-    void updatePasswordEchoEditing(bool editing);
+    void _q_textEdited(const QString &);
+    void _q_cursorPositionChanged(int, int);
 
 #ifndef QT_NO_COMPLETER
-    QPointer<QCompleter> completer;
-    void complete(int key = -1);
     void _q_completionHighlighted(QString);
-    bool advanceToEnabledItem(int n);
+#endif
+#ifndef QT_NO_DRAGANDDROP
+    QPoint dndPos;
+    QBasicTimer dndTimer;
+    void drag();
 #endif
 
     int leftTextMargin;
diff --git a/src/gui/widgets/qmenu.cpp b/src/gui/widgets/qmenu.cpp
index 4a969db..d0620af 100644
--- a/src/gui/widgets/qmenu.cpp
+++ b/src/gui/widgets/qmenu.cpp
@@ -2748,7 +2748,7 @@ void QMenu::mouseMoveEvent(QMouseEvent *e)
 
     QAction *action = d->actionAt(e->pos());
     if (!action) {
-        if (d->hasHadMouse && !rect().contains(e->pos()))
+        if (d->hasHadMouse)
             d->setCurrentAction(0);
         return;
     } else if(e->buttons()) {
diff --git a/src/gui/widgets/qmenubar.cpp b/src/gui/widgets/qmenubar.cpp
index 6be30cd..eaf03b3 100644
--- a/src/gui/widgets/qmenubar.cpp
+++ b/src/gui/widgets/qmenubar.cpp
@@ -716,7 +716,7 @@ void QMenuBar::initStyleOption(QStyleOptionMenuItem *option, const QAction *acti
     application examples} also provide menus using these classes.
 
     \sa QMenu, QShortcut, QAction,
-        {http://developer.apple.com/documentation/UserExperience/Conceptual/OSXHIGuidelines/index.html}{Introduction to Apple Human Interface Guidelines},
+        {http://developer.apple.com/documentation/UserExperience/Conceptual/AppleHIGuidelines/XHIGIntro/XHIGIntro.html}{Introduction to Apple Human Interface Guidelines},
         {fowler}{GUI Design Handbook: Menu Bar}, {Menus Example}
 */
 
diff --git a/src/gui/widgets/qvalidator.h b/src/gui/widgets/qvalidator.h
index ce78959..5c27d1d 100644
--- a/src/gui/widgets/qvalidator.h
+++ b/src/gui/widgets/qvalidator.h
@@ -61,7 +61,7 @@ class Q_GUI_EXPORT QValidator : public QObject
 {
     Q_OBJECT
 public:
-    explicit QValidator(QObject * parent);
+    explicit QValidator(QObject * parent=0);
     ~QValidator();
 
     enum State {
@@ -100,7 +100,7 @@ class Q_GUI_EXPORT QIntValidator : public QValidator
     Q_PROPERTY(int top READ top WRITE setTop)
 
 public:
-    explicit QIntValidator(QObject * parent);
+    explicit QIntValidator(QObject * parent=0);
     QIntValidator(int bottom, int top, QObject * parent);
     ~QIntValidator();
 
diff --git a/src/gui/widgets/widgets.pri b/src/gui/widgets/widgets.pri
index cc03513..4567902 100644
--- a/src/gui/widgets/widgets.pri
+++ b/src/gui/widgets/widgets.pri
@@ -30,6 +30,7 @@ HEADERS += \
         widgets/qlcdnumber.h \
         widgets/qlineedit.h \
         widgets/qlineedit_p.h \
+        widgets/qlinecontrol_p.h \
         widgets/qmainwindow.h \
         widgets/qmainwindowlayout_p.h \
         widgets/qmdiarea.h \
@@ -101,7 +102,9 @@ SOURCES += \
         widgets/qgroupbox.cpp \
         widgets/qlabel.cpp \
         widgets/qlcdnumber.cpp \
+        widgets/qlineedit_p.cpp \
         widgets/qlineedit.cpp \
+        widgets/qlinecontrol.cpp \
         widgets/qmainwindow.cpp \
         widgets/qmainwindowlayout.cpp \
         widgets/qmdiarea.cpp \