Merge branch 'master-upstream' into master-water

34 files changed, 1779 insertions, 1012 deletions

diff --git a/src/gui/dialogs/qfontdialog_mac.mm b/src/gui/dialogs/qfontdialog_mac.mm
index e2c2fc2..9a92b27 100644
--- a/src/gui/dialogs/qfontdialog_mac.mm
+++ b/src/gui/dialogs/qfontdialog_mac.mm
@@ -51,6 +51,7 @@
 #include <private/qt_mac_p.h>
 #include <qabstracteventdispatcher.h>
 #include <qdebug.h>
+#include <private/qfontengine_coretext_p.h>
 #import <AppKit/AppKit.h>
 #import <Foundation/Foundation.h>
 
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index 981fbbc..19b2cb8 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -4367,25 +4367,8 @@ static void _q_paintIntoCache(QPixmap *pix, QGraphicsItem *item, const QRegion &
 static inline bool transformIsSimple(const QTransform& transform)
 {
     QTransform::TransformationType type = transform.type();
-    if (type == QTransform::TxNone || type == QTransform::TxTranslate) {
+    if (type <= QTransform::TxScale) {
         return true;
-    } else if (type == QTransform::TxScale) {
-        // Check for 0 and 180 degree rotations.
-        // (0 might happen after 4 rotations of 90 degrees).
-        qreal m11 = transform.m11();
-        qreal m12 = transform.m12();
-        qreal m21 = transform.m21();
-        qreal m22 = transform.m22();
-        if (m12 == 0.0f && m21 == 0.0f) {
-            if (m11 == 1.0f && m22 == 1.0f)
-                return true; // 0 degrees
-            else if (m11 == -1.0f && m22 == -1.0f)
-                return true; // 180 degrees.
-            if(m11 == 1.0f && m22 == -1.0f)
-                return true; // 0 degrees inverted y.
-            else if(m11 == -1.0f && m22 == 1.0f)
-                return true; // 180 degrees inverted y.
-        }
     } else if (type == QTransform::TxRotate) {
         // Check for 90, and 270 degree rotations.
         qreal m11 = transform.m11();
diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index 747dd2f..bb94788c 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -3833,6 +3833,26 @@ void qInitImageConversions()
 #endif
 }
 
+void qGamma_correct_back_to_linear_cs(QImage *image)
+{
+    extern uchar qt_pow_rgb_gamma[256];
+
+    // gamma correct the pixels back to linear color space...
+    int h = image->height();
+    int w = image->width();
+
+    for (int y=0; y<h; ++y) {
+        uint *pixels = (uint *) image->scanLine(y);
+        for (int x=0; x<w; ++x) {
+            uint p = pixels[x];
+            uint r = qt_pow_rgb_gamma[qRed(p)];
+            uint g = qt_pow_rgb_gamma[qGreen(p)];
+            uint b = qt_pow_rgb_gamma[qBlue(p)];
+            pixels[x] = (r << 16) | (g << 8) | b | 0xff000000;
+        }
+    }
+}
+
 /*!
     Returns a copy of the image in the given \a format.
 
diff --git a/src/gui/image/qimage_p.h b/src/gui/image/qimage_p.h
index e054814..64af0a6 100644
--- a/src/gui/image/qimage_p.h
+++ b/src/gui/image/qimage_p.h
@@ -111,6 +111,7 @@ struct Q_GUI_EXPORT QImageData {        // internal image data
 };
 
 void qInitImageConversions();
+Q_GUI_EXPORT void qGamma_correct_back_to_linear_cs(QImage *image);
 
 inline int qt_depthForFormat(QImage::Format format)
 {
diff --git a/src/gui/kernel/qeventdispatcher_qpa.cpp b/src/gui/kernel/qeventdispatcher_qpa.cpp
index cb70141..519d2a6 100644
--- a/src/gui/kernel/qeventdispatcher_qpa.cpp
+++ b/src/gui/kernel/qeventdispatcher_qpa.cpp
@@ -51,6 +51,8 @@
 #include <QtCore/QAtomicInt>
 #include <QtCore/QSemaphore>
 
+#include <QtCore/QDebug>
+
 #include <errno.h>
 
 QT_BEGIN_NAMESPACE
@@ -122,7 +124,8 @@ public:
            selectWorkerNeedsSync(true),
            selectWorkerHasResult(false),
            m_integrationInitialised(false),
-           m_hasIntegration(false)
+           m_hasIntegration(false),
+           m_isEventLoopIntegrationRunning(false)
     {
 
     }
@@ -160,6 +163,20 @@ public:
         return m_hasIntegration;
     }
 
+    bool isEventLoopIntegrationRunning() const
+    {
+        return m_isEventLoopIntegrationRunning;
+    }
+
+    void runEventLoopIntegration()
+    {
+        if (qApp && (qApp->thread() == QThread::currentThread())) {
+            m_isEventLoopIntegrationRunning = true;
+            QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
+            eventLoopIntegration->startEventLoop();
+        }
+    }
+
     QPlatformEventLoopIntegration *eventLoopIntegration;
     Rendezvous *barrierBeforeBlocking;
     Rendezvous *barrierReturnValue;
@@ -172,6 +189,7 @@ public:
 private:
     bool m_integrationInitialised;
     bool m_hasIntegration;
+    bool m_isEventLoopIntegrationRunning;
 };
 
 QEventDispatcherQPA::QEventDispatcherQPA(QObject *parent)
@@ -184,6 +202,17 @@ QEventDispatcherQPA::~QEventDispatcherQPA()
 bool QEventDispatcherQPA::processEvents(QEventLoop::ProcessEventsFlags flags)
 {
     Q_D(QEventDispatcherQPA);
+
+    if (d->hasIntegration()) {
+        if (!d->isEventLoopIntegrationRunning()) {
+            d->runEventLoopIntegration();
+        }
+        if (d->threadData->quitNow) {
+            d->eventLoopIntegration->quitEventLoop();
+            return false;
+        }
+    }
+
     int nevents = 0;
 
     // handle gui and posted events
@@ -213,8 +242,10 @@ bool QEventDispatcherQPA::processEvents(QEventLoop::ProcessEventsFlags flags)
     }
 
     if (!d->interrupt) {
-        if (QEventDispatcherUNIX::processEvents(flags))
+        if (QEventDispatcherUNIX::processEvents(flags)) {
+            QEventDispatcherUNIX::processEvents(flags);
             return true;
+        }
     }
     return (nevents > 0);
 }
@@ -248,7 +279,6 @@ void QEventDispatcherQPA::flush()
         qApp->sendPostedEvents();
 }
 
-
 int QEventDispatcherQPA::select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
                                 timeval *timeout)
 {
@@ -266,6 +296,7 @@ int QEventDispatcherQPA::select(int nfds, fd_set *readfds, fd_set *writefds, fd_
 
                 d->selectReturnMutex->unlock();
                 d->barrierReturnValue->checkpoint();
+                d->eventLoopIntegration->setNextTimerEvent(0);
                 return retVal;
             } else {
                 d->selectWorkerNeedsSync = false;
@@ -274,7 +305,7 @@ int QEventDispatcherQPA::select(int nfds, fd_set *readfds, fd_set *writefds, fd_
             }
         }
         d->selectReturnMutex->unlock();
-        d->eventLoopIntegration->processEvents(timeoutmsec);
+        d->eventLoopIntegration->setNextTimerEvent(timeoutmsec);
         retVal = 0; //is 0 if select has not returned
     } else {
         retVal = QEventDispatcherUNIX::select(nfds, readfds, writefds, exceptfds, timeout);
@@ -282,14 +313,16 @@ int QEventDispatcherQPA::select(int nfds, fd_set *readfds, fd_set *writefds, fd_
     return retVal;
 }
 
+
 void SelectWorker::run()
 {
+
     while(true) {
         m_retVal = 0;
         m_edPrivate->barrierBeforeBlocking->checkpoint(); // wait for mainthread
         int tmpRet = qt_safe_select(m_nfds,m_readfds,m_writefds,m_exceptfds,0);
         m_edPrivate->selectReturnMutex->lock();
-        m_edPrivate->eventLoopIntegration->wakeup();
+        m_edPrivate->eventLoopIntegration->qtNeedsToProcessEvents();
 
         m_edPrivate->selectWorkerNeedsSync = true;
         m_edPrivate->selectWorkerHasResult = true;
diff --git a/src/gui/kernel/qplatformeventloopintegration_qpa.cpp b/src/gui/kernel/qplatformeventloopintegration_qpa.cpp
index 8bdba5e..fdb3852 100644
--- a/src/gui/kernel/qplatformeventloopintegration_qpa.cpp
+++ b/src/gui/kernel/qplatformeventloopintegration_qpa.cpp
@@ -39,3 +39,48 @@
 **
 ****************************************************************************/
 
+#include "qplatformeventloopintegration_qpa.h"
+
+#include <QtCore/QCoreApplication>
+
+#include <QtCore/QDebug>
+
+class QPlatformEventLoopIntegrationPrivate
+{
+public:
+    QPlatformEventLoopIntegrationPrivate();
+    qint64 nextTimerEvent;
+};
+
+QPlatformEventLoopIntegrationPrivate::QPlatformEventLoopIntegrationPrivate()
+    : nextTimerEvent(0)
+{
+}
+
+QPlatformEventLoopIntegration::QPlatformEventLoopIntegration()
+    : d_ptr(new QPlatformEventLoopIntegrationPrivate)
+
+{
+}
+
+QPlatformEventLoopIntegration::~QPlatformEventLoopIntegration()
+{
+}
+
+qint64 QPlatformEventLoopIntegration::nextTimerEvent() const
+{
+    Q_D(const QPlatformEventLoopIntegration);
+    return d->nextTimerEvent;
+}
+
+
+void QPlatformEventLoopIntegration::setNextTimerEvent(qint64 nextTimerEvent)
+{
+    Q_D(QPlatformEventLoopIntegration);
+    d->nextTimerEvent = nextTimerEvent;
+}
+
+void QPlatformEventLoopIntegration::processEvents()
+{
+    QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
+}
diff --git a/src/gui/kernel/qplatformeventloopintegration_qpa.h b/src/gui/kernel/qplatformeventloopintegration_qpa.h
index a06fecf..6e0f984 100644
--- a/src/gui/kernel/qplatformeventloopintegration_qpa.h
+++ b/src/gui/kernel/qplatformeventloopintegration_qpa.h
@@ -43,6 +43,7 @@
 #define QPLATFORMEVENTLOOPINTEGRATION_QPA_H
 
 #include <QtCore/qglobal.h>
+#include <QtCore/QScopedPointer>
 
 QT_BEGIN_HEADER
 
@@ -50,11 +51,28 @@ QT_BEGIN_NAMESPACE
 
 QT_MODULE(Gui)
 
-class QPlatformEventLoopIntegration
+class QPlatformEventLoopIntegrationPrivate;
+
+class Q_GUI_EXPORT QPlatformEventLoopIntegration
 {
+    Q_DECLARE_PRIVATE(QPlatformEventLoopIntegration);
 public:
-    virtual void processEvents( qint64 msec ) = 0;
-    virtual void wakeup() = 0;
+    QPlatformEventLoopIntegration();
+    virtual ~QPlatformEventLoopIntegration();
+
+    virtual void startEventLoop() = 0;
+    virtual void quitEventLoop() = 0;
+    virtual void qtNeedsToProcessEvents() = 0;
+
+    qint64 nextTimerEvent() const;
+    void setNextTimerEvent(qint64 nextTimerEvent);
+
+    static void processEvents();
+protected:
+    QScopedPointer<QPlatformEventLoopIntegrationPrivate> d_ptr;
+private:
+    Q_DISABLE_COPY(QPlatformEventLoopIntegration);
+    friend class QEventDispatcherQPA;
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qplatformglcontext_qpa.cpp b/src/gui/kernel/qplatformglcontext_qpa.cpp
index 36db2b0..14bd718 100644
--- a/src/gui/kernel/qplatformglcontext_qpa.cpp
+++ b/src/gui/kernel/qplatformglcontext_qpa.cpp
@@ -41,17 +41,187 @@
 
 #include "qplatformglcontext_qpa.h"
 
+#include <QtCore/QThreadStorage>
+#include <QtCore/QThread>
+
+#include <QDebug>
+
+class QPlatformGLThreadContext
+{
+public:
+    ~QPlatformGLThreadContext() {
+        if (context)
+            context->doneCurrent();
+    }
+    QPlatformGLContext *context;
+};
+
+static QThreadStorage<QPlatformGLThreadContext *> qplatformgl_context_storage;
+
+class QPlatformGLContextPrivate
+{
+public:
+    QPlatformGLContextPrivate()
+        :qGLContextHandle(0)
+    {
+    }
+
+    virtual ~QPlatformGLContextPrivate()
+    {
+        //do not delete the QGLContext handle here as it is deleted in
+        //QWidgetPrivate::deleteTLSysExtra()
+    }
+    void *qGLContextHandle;
+    void (*qGLContextDeleteFunction)(void *handle);
+    static QPlatformGLContext *staticSharedContext;
+
+    static void setCurrentContext(QPlatformGLContext *context);
+};
+
+QPlatformGLContext *QPlatformGLContextPrivate::staticSharedContext = 0;
+
+void QPlatformGLContextPrivate::setCurrentContext(QPlatformGLContext *context)
+{
+    QPlatformGLThreadContext *threadContext = qplatformgl_context_storage.localData();
+    if (!threadContext) {
+        if (!QThread::currentThread()) {
+            qWarning("No QTLS available. currentContext wont work");
+            return;
+        }
+        threadContext = new QPlatformGLThreadContext;
+        qplatformgl_context_storage.setLocalData(threadContext);
+    }
+    threadContext->context = context;
+}
+
+/*!
+  Returns the last context which called makeCurrent. This function is thread aware.
+*/
+const QPlatformGLContext* QPlatformGLContext::currentContext()
+{
+    QPlatformGLThreadContext *threadContext = qplatformgl_context_storage.localData();
+    if(threadContext) {
+        return threadContext->context;
+    }
+    return 0;
+}
+
+/*!
+    All subclasses needs to specify the platformWindow. It can be a null window.
+*/
+QPlatformGLContext::QPlatformGLContext()
+    :d_ptr(new QPlatformGLContextPrivate())
+{
+}
+
+/*!
+  If this is the current context for the thread, doneCurrent is called
+*/
 QPlatformGLContext::~QPlatformGLContext()
-{ }
+{
+    if (QPlatformGLContext::currentContext() == this) {
+        doneCurrent();
+    }
+
+}
 
-static QPlatformGLContext *staticSharedContext = 0;
 
+/*!
+    Makes it possible to set the context which can be the default for making new contexts.
+*/
 void QPlatformGLContext::setDefaultSharedContext(QPlatformGLContext *sharedContext)
 {
-    staticSharedContext = sharedContext;
+    QPlatformGLContextPrivate::staticSharedContext = sharedContext;
 }
 
-QPlatformGLContext *QPlatformGLContext::defaultSharedContext()
+/*!
+    Default shared context is intended to be a globally awailable pointer to a context which can
+    be used for sharing resources when creating new contexts. Its default value is 0;
+*/
+const QPlatformGLContext *QPlatformGLContext::defaultSharedContext()
 {
-    return staticSharedContext;
+    return QPlatformGLContextPrivate::staticSharedContext;
 }
+
+/*!
+    Reimplement in subclass to do makeCurrent on native GL context
+*/
+void QPlatformGLContext::makeCurrent()
+{
+    QPlatformGLContextPrivate::setCurrentContext(this);
+}
+
+/*!
+    Reimplement in subclass to release current context.
+    Typically this is calling makeCurrent with 0 "surface"
+*/
+void QPlatformGLContext::doneCurrent()
+{
+    QPlatformGLContextPrivate::setCurrentContext(0);
+}
+
+/*
+  internal: Needs to have a pointer to qGLContext. But since this is in QtGui we cant
+  have any type information.
+*/
+void *QPlatformGLContext::qGLContextHandle() const
+{
+    Q_D(const QPlatformGLContext);
+    return d->qGLContextHandle;
+}
+
+void QPlatformGLContext::setQGLContextHandle(void *handle,void (*qGLContextDeleteFunction)(void *))
+{
+    Q_D(QPlatformGLContext);
+    d->qGLContextHandle = handle;
+    d->qGLContextDeleteFunction = qGLContextDeleteFunction;
+}
+
+void QPlatformGLContext::deleteQGLContext()
+{
+    Q_D(QPlatformGLContext);
+    if (d->qGLContextDeleteFunction && d->qGLContextHandle) {
+        d->qGLContextDeleteFunction(d->qGLContextHandle);
+        d->qGLContextDeleteFunction = 0;
+        d->qGLContextHandle = 0;
+    }
+}
+
+/*!
+    \class QPlatformGLContext
+    \since 4.8
+    \internal
+    \preliminary
+    \ingroup qpa
+
+    \brief The QPlatformGLContext class provides an abstraction for native GL contexts.
+
+    In QPA the way to support OpenGL or OpenVG or other technologies that requires a native GL
+    context is through the QPlatformGLContext wrapper.
+
+    There is no factory function for QPlatformGLContexts, but rather only one accessor function.
+    The only place to retrieve a QPlatformGLContext from is through a QPlatformWindow.
+
+    The context which is current for a specific thread can be collected by the currentContext()
+    function. This is how QPlatformGLContext also makes it possible to use the QtOpenGL module
+    withhout using QGLWidget. When using QGLContext::currentContext(), it will ask
+    QPlatformGLContext for the currentContext. Then a corresponding QGLContext will be returned,
+    which maps to the QPlatformGLContext.
+*/
+
+/*! \fn void swapBuffers()
+    Reimplement in subclass to native swap buffers calls
+*/
+
+/*! getProcAddress(const QString& procName)
+    Reimplement in subclass to native getProcAddr calls.
+
+    Note: its convenient to use qPrintable(const QString &str) to get the const char * pointer
+*/
+
+/*! platformWindowFormat() const
+    QWidget has the function qplatformWindowFormat(). That function is for the application
+    programmer to request the format of the window and the context that he wants.
+
+    Reimplement this function in a subclass to indicate what format the glContext actually has.
+*/
diff --git a/src/gui/kernel/qplatformglcontext_qpa.h b/src/gui/kernel/qplatformglcontext_qpa.h
index ed41723..a70e046 100644
--- a/src/gui/kernel/qplatformglcontext_qpa.h
+++ b/src/gui/kernel/qplatformglcontext_qpa.h
@@ -51,24 +51,39 @@ QT_BEGIN_NAMESPACE
 
 QT_MODULE(Gui)
 
+class QPlatformGLContextPrivate;
+
 class Q_OPENGL_EXPORT QPlatformGLContext
 {
+Q_DECLARE_PRIVATE(QPlatformGLContext);
+
 public:
+    explicit QPlatformGLContext();
     virtual ~QPlatformGLContext();
 
-    virtual void makeCurrent() = 0;
-    virtual void doneCurrent() = 0;
+    virtual void makeCurrent();
+    virtual void doneCurrent();
     virtual void swapBuffers() = 0;
     virtual void* getProcAddress(const QString& procName) = 0;
 
     virtual QPlatformWindowFormat platformWindowFormat() const = 0;
 
-    static QPlatformGLContext *defaultSharedContext();
+    const static QPlatformGLContext *currentContext();
+    const static QPlatformGLContext *defaultSharedContext();
 
 protected:
 
     static void setDefaultSharedContext(QPlatformGLContext *sharedContext);
 
+    QScopedPointer<QPlatformGLContextPrivate> d_ptr;
+private:
+    //hack to make it work with QGLContext::CurrentContext
+    friend class QGLContext;
+    friend class QWidgetPrivate;
+    void *qGLContextHandle() const;
+    void setQGLContextHandle(void *handle,void (*qGLContextDeleteFunction)(void *));
+    void deleteQGLContext();
+    Q_DISABLE_COPY(QPlatformGLContext);
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qplatformintegration_qpa.cpp b/src/gui/kernel/qplatformintegration_qpa.cpp
index e2a493d..9b6e590 100644
--- a/src/gui/kernel/qplatformintegration_qpa.cpp
+++ b/src/gui/kernel/qplatformintegration_qpa.cpp
@@ -55,16 +55,35 @@ QPixmap QPlatformIntegration::grabWindow(WId window, int x, int y, int width, in
     return QPixmap();
 }
 
+/*!
+    Factory function for the eventloop integration interface.
+
+    Default implementation returns 0, which causes the eventloop to run in a single thread mode.
+
+    \sa QPlatformEventLoopIntegration
+*/
 QPlatformEventLoopIntegration *QPlatformIntegration::createEventLoopIntegration() const
 {
     return 0;
 }
 
+/*!
+    Returns whether the given platform integration supports OpenGL.
+
+    Default implementation returns false,
+*/
 bool QPlatformIntegration::hasOpenGL() const
 {
     return false;
 }
 
+/*!
+    Accessor for the platform integrations fontdatabase.
+
+    Default implementation returns a default QPlatformFontDatabase.
+
+    \sa QPlatformFontDatabase
+*/
 QPlatformFontDatabase *QPlatformIntegration::fontDatabase() const
 {
     static QPlatformFontDatabase *db = 0;
@@ -74,4 +93,104 @@ QPlatformFontDatabase *QPlatformIntegration::fontDatabase() const
     return db;
 }
 
+/*!
+    \class QPlatformIntegration
+    \since 4.8
+    \internal
+    \preliminary
+    \ingroup qpa
+    \brief The QPlatformIntegration class is the entry for WindowSystem specific functionality.
+
+    QPlatformIntegration is the single entry point for windowsystem specific functionality when
+    using the QPA platform. It has factory functions for creating platform specific pixmaps and
+    windows. The class also controls the font subsystem.
+
+    QPlatformIntegration is a singelton class which gets instansiated in the QApplication
+    constructor. The QPlatformIntegration instance do not have ownership of objects it creates in
+    functions where the name starts with create. However, functions which don't have a name
+    starting with create acts as assessors to member variables.
+
+    It is not trivial to create or build a platform plugin outside of the Qt source tree. Therefor
+    the recommended approach for making new platform plugin is to copy an existing plugin inside
+    the QTSRCTREE/src/plugins/platform and develop the plugin inside the source tree.
+
+    The minimal platformintegration is the smallest platform integration it is possible to make,
+    which makes it an ideal starting point for new plugins. For a slightly more advanced plugin,
+    consider reviewing the directfb plugin, or the testlite plugin.
+*/
+
+/*!
+    \fn QPixmapData *createPixmapData(QPixmapData::PixelType type) const
+
+    Factory function for QPixmapData. PixelType can be either PixmapType or BitmapType.
+    \sa QPixmapData
+*/
+
+/*!
+    \fn QPlatformWindow *createPlatformWindow(QWidget *widget, WId winId = 0) const
+
+    Factory function for QPlatformWindow. The widget parameter is a pointer to the top level
+    widget(tlw) which the QPlatformWindow is suppose to be created for. The WId handle is actually
+    never used, but there for future reference. Its purpose is if it is going to be possible to
+    create QPlatformWindows on existing WId.
+
+    All tlw has to have a QPlatformWindow, and it will be created when the QPlatformWindow is set
+    to be visible for the first time. If the tlw's window flags are changed, or if the tlw's
+    QPlatformWindowFormat is changed, then the tlw's QPlatformWindow is deleted and a new one is
+    created.
+
+    \sa QPlatformWindow, QPlatformWindowFormat
+    \sa createWindowSurface(QWidget *widget, WId winId) const
+*/
+
+/*!
+    \fn QWindowSurface *createWindowSurface(QWidget *widget, WId winId) const
+
+    Factory function for QWindowSurface. The QWidget parameter is a pointer to the
+    top level widget(tlw) the window surface is created for. A QPlatformWindow is always created
+    before the QWindowSurface for tlw where the widget also requires a WindowSurface. It is
+    possible to create top level QWidgets without a QWindowSurface by specifying
+    QPlatformWindowFormat::setWindowSurface(false) for the tlw QPlatformWindowFormat.
+
+    \sa QWindowSurface
+    \sa createPlatformWindow(QWidget *widget, WId winId = 0) const
+*/
+
+/*!
+    \fn void moveToScreen(QWidget *window, int screen)
+
+    This function is called when a QWidget is displayed on screen, or the QWidget is to be
+    displayed on a new screen. The QWidget parameter is a pointer to the top level widget and
+    the int parameter is the index to the screen in QList<QPlatformScreen *> screens() const.
+
+    Default implementation does nothing.
+
+    \sa screens() const
+*/
+
+/*!
+    \fn QList<QPlatformScreen *> screens() const
+
+    Accessor function to a list of all the screens on the current system. The screen with the
+    index == 0 is the default/main screen.
+*/
+
+/*!
+    \fn bool isVirtualDesktop()
+
+    Returns if the current windowing system configuration defines all the screens to be one
+    desktop(virtual desktop), or if each screen is a desktop of its own.
+
+    Default implementation returns false.
+*/
+
+/*!
+    \fn QPixmap grabWindow(WId window, int x, int y, int width, int height) const
+
+    This function is called when Qt needs to be able to grab the content of a window.
+
+    Returnes the content of the window specified with the WId handle within the boundaries of
+    QRect(x,y,width,height).
+*/
+
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qplatformintegration_qpa.h b/src/gui/kernel/qplatformintegration_qpa.h
index b1f4e5f..f01b4f4 100644
--- a/src/gui/kernel/qplatformintegration_qpa.h
+++ b/src/gui/kernel/qplatformintegration_qpa.h
@@ -69,10 +69,10 @@ public:
     virtual QPixmapData *createPixmapData(QPixmapData::PixelType type) const = 0;
     virtual QPlatformWindow *createPlatformWindow(QWidget *widget, WId winId = 0) const = 0;
     virtual QWindowSurface *createWindowSurface(QWidget *widget, WId winId) const = 0;
-    virtual void moveToScreen(QWidget *window, int screen) {Q_UNUSED(window); Q_UNUSED(screen);}
 
 // Window System functions
     virtual QList<QPlatformScreen *> screens() const = 0;
+    virtual void moveToScreen(QWidget *window, int screen) {Q_UNUSED(window); Q_UNUSED(screen);}
     virtual bool isVirtualDesktop() { return false; }
     virtual QPixmap grabWindow(WId window, int x, int y, int width, int height) const;
 
diff --git a/src/gui/kernel/qplatformscreen_qpa.cpp b/src/gui/kernel/qplatformscreen_qpa.cpp
index 478d2d6..5e80ba8 100644
--- a/src/gui/kernel/qplatformscreen_qpa.cpp
+++ b/src/gui/kernel/qplatformscreen_qpa.cpp
@@ -43,6 +43,12 @@
 #include <QtGui/qapplication.h>
 #include <QtGui/qdesktopwidget.h>
 
+/*!
+    Return the given top level widget for a given position.
+
+    Default implementation retrieves a list of all top level widgets and finds the first widget
+    which contains point \a pos
+*/
 QWidget *QPlatformScreen::topLevelAt(const QPoint & pos) const
 {
     QWidgetList list = QApplication::topLevelWidgets();
@@ -56,6 +62,13 @@ QWidget *QPlatformScreen::topLevelAt(const QPoint & pos) const
     return 0;
 }
 
+/*! \fn physicalSize() const
+    Reimplement in subclass to return the physical size of the screen. This function is used by
+    QFont to convert point sizes to pixel sizes.
+
+    Default implementation takes the pixel size of the screen, considers a dpi of 100 and returns
+    the calculated (and probably wrong) physical size
+*/
 QSize QPlatformScreen::physicalSize() const
 {
     static const int dpi = 100;
@@ -64,3 +77,38 @@ QSize QPlatformScreen::physicalSize() const
     return QSize(width,height);
 }
 
+/*!
+    \class QPlatformScreen
+    \since 4.8
+    \internal
+    \preliminary
+    \ingroup qpa
+
+    \brief The QPlatformScreen class provides an abstraction for visual displays.
+
+    Many window systems has support for retrieving information on the attached displays. To be able
+    to query the display QPA uses QPlatformScreen. Qt its self is most dependent on the
+    physicalSize() function, since this is the function it uses to calculate the dpi to use when
+    converting point sizes to pixels sizes. However, this is unfortunate on some systems, as the
+    native system fakes its dpi size.
+
+    QPlatformScreen is also used by the public api QDesktopWidget for information about the desktop.
+ */
+
+/*! \fn geometry() const
+    Reimplement in subclass to return the pixel geometry of the screen
+*/
+
+/*! \fn availableGeometry() const
+    Reimplement in subclass to return the pixel geometry of the available space
+    This normally is the desktop screen minus the task manager, global menubar etc.
+*/
+
+/*! \fn depth() const
+    Reimplement in subclass to return current depth of the screen
+*/
+
+/*! \fn format() const
+    Reimplement in subclass to return the image format which corresponds to the screen format
+*/
+
diff --git a/src/gui/kernel/qplatformscreen_qpa.h b/src/gui/kernel/qplatformscreen_qpa.h
index 1704f0f..9080489 100644
--- a/src/gui/kernel/qplatformscreen_qpa.h
+++ b/src/gui/kernel/qplatformscreen_qpa.h
@@ -70,6 +70,7 @@ public:
     virtual int depth() const = 0;
     virtual QImage::Format format() const = 0;
     virtual QSize physicalSize() const;
+    //jl: should setDirty be removed.
     virtual void setDirty(const QRect &) {}
     virtual QWidget *topLevelAt(const QPoint &point) const;
 };
diff --git a/src/gui/kernel/qplatformwindow_qpa.cpp b/src/gui/kernel/qplatformwindow_qpa.cpp
index 9d722d8..29eaa82 100644
--- a/src/gui/kernel/qplatformwindow_qpa.cpp
+++ b/src/gui/kernel/qplatformwindow_qpa.cpp
@@ -51,6 +51,10 @@ class QPlatformWindowPrivate
     friend class QPlatformWindow;
 };
 
+/*!
+    Constructs a platform window with the given top level widget.
+*/
+
 QPlatformWindow::QPlatformWindow(QWidget *tlw)
     : d_ptr(new QPlatformWindowPrivate)
 {
@@ -59,22 +63,37 @@ QPlatformWindow::QPlatformWindow(QWidget *tlw)
     tlw->setPlatformWindow(this);
 }
 
+/*!
+    Virtual destructor does not delete its top level widget.
+*/
 QPlatformWindow::~QPlatformWindow()
 {
 }
 
+/*!
+    Returnes the widget which belongs to the QPlatformWindow
+*/
 QWidget *QPlatformWindow::widget() const
 {
     Q_D(const QPlatformWindow);
     return d->tlw;
 }
 
+/*!
+    This function is called by Qt whenever a window is moved or the window is resized. The resize
+    can happen programatically(from ie. user application) or by the window manager. This means that
+    there is no need to call this function specifically from the window manager callback, instead
+    call QWindowSystemInterface::handleGeometryChange(QWidget *w, const QRect &newRect);
+*/
 void QPlatformWindow::setGeometry(const QRect &rect)
 {
     Q_D(QPlatformWindow);
     d->rect = rect;
 }
 
+/*!
+    Returnes the current geometry of a window
+*/
 QRect QPlatformWindow::geometry() const
 {
     Q_D(const QPlatformWindow);
@@ -82,14 +101,16 @@ QRect QPlatformWindow::geometry() const
 }
 
 /*!
-Reimplemented in subclasses to show the surface if \a visible is \c true, and hide it if \a visible is \c false.
+    Reimplemented in subclasses to show the surface
+    if \a visible is \c true, and hide it if \a visible is \c false.
 */
 void QPlatformWindow::setVisible(bool visible)
 {
     Q_UNUSED(visible);
 }
 /*!
-Requests setting the window flags of this surface to \a type. Returns the actual flags set.
+    Requests setting the window flags of this surface
+    to \a type. Returns the actual flags set.
 */
 Qt::WindowFlags QPlatformWindow::setWindowFlags(Qt::WindowFlags flags)
 {
@@ -107,23 +128,83 @@ Qt::WindowFlags QPlatformWindow::windowFlags() const
     return d->flags;
 }
 
+/*!
+  Reimplement in subclasses to return a handle to the native window
+*/
 WId QPlatformWindow::winId() const { return WId(0); }
 
-void QPlatformWindow::setParent(const QPlatformWindow *) { qWarning("This plugin does not support setParent!"); }
+/*!
+    This function is called to enable native child widgets in QPA. It is common not to support this
+    feature in Window systems, but can be faked. When this function is called all geometry of this
+    platform window will be relative to the parent.
+*/
+//jl: It would be useful to have a property on the platform window which indicated if the sub-class
+// supported the setParent. If not, then geometry would be in screen coordinates.
+void QPlatformWindow::setParent(const QPlatformWindow *parent)
+{
+    Q_UNUSED(parent);
+    qWarning("This plugin does not support setParent!");
+}
 
-void QPlatformWindow::setWindowTitle(const QString &) {}
+/*!
+  Reimplement to set the window title to \a title
+*/
+void QPlatformWindow::setWindowTitle(const QString &title) {}
 
+/*!
+  Reimplement to be able to let Qt rais windows to the top of the desktop
+*/
 void QPlatformWindow::raise() { qWarning("This plugin does not support raise()"); }
 
+/*!
+  Reimplement to be able to let Qt lower windows to the bottom of the desktop
+*/
 void QPlatformWindow::lower() { qWarning("This plugin does not support lower()"); }
 
+/*!
+  Reimplement to be able to let Qt set the opacity level of a window
+*/
 void QPlatformWindow::setOpacity(qreal level)
 {
     Q_UNUSED(level);
     qWarning("This plugin does not support setting window opacity");
 }
 
+/*!
+  Reimplement to return the glContext associated with the window.
+*/
 QPlatformGLContext *QPlatformWindow::glContext() const
 {
     return 0;
 }
+
+/*!
+    \class QPlatformWindow
+    \since 4.8
+    \internal
+    \preliminary
+    \ingroup qpa
+
+    \brief The QPlatformWindow class provides an abstraction for top-level windows.
+
+    The QPlatformWindow abstraction is used by QWidget for all its top level widgets. It is being
+    created by calling the createPlatformWindow function in the loaded QPlatformIntegration
+    instance.
+
+    QPlatformWindow is used to signal to the windowing system, how Qt persieves its frame.
+    However, it is not concerned with how Qt renders into the window it represents.
+
+    Top level QWidgets(tlw) will always have a QPlatformWindow. However, it is not necessary for
+    all tlw to have a QWindowSurface. This is the case for QGLWidget. And could be the case for
+    widgets where some  3.party renders into it.
+
+    The platform specific window handle can be retrieved by the winId function.
+
+    QPlatformWindow is also the way QPA defines how native child windows should be supported
+    through the setParent function.
+
+    The only way to retrieve a QPlatformGLContext in QPA is by calling the glContext() function
+    on QPlatformWindow.
+
+    \sa QWindowSurface, QWidget
+*/
diff --git a/src/gui/kernel/qplatformwindow_qpa.h b/src/gui/kernel/qplatformwindow_qpa.h
index 6dfba05..90bc1cb 100644
--- a/src/gui/kernel/qplatformwindow_qpa.h
+++ b/src/gui/kernel/qplatformwindow_qpa.h
@@ -75,7 +75,7 @@ public:
     virtual WId winId() const;
     virtual void setParent(const QPlatformWindow *window);
 
-    virtual void setWindowTitle(const QString &);
+    virtual void setWindowTitle(const QString &title);
     virtual void raise();
     virtual void lower();
 
diff --git a/src/gui/kernel/qplatformwindowformat_qpa.cpp b/src/gui/kernel/qplatformwindowformat_qpa.cpp
index d497e85..44b0698 100644
--- a/src/gui/kernel/qplatformwindowformat_qpa.cpp
+++ b/src/gui/kernel/qplatformwindowformat_qpa.cpp
@@ -53,7 +53,7 @@ public:
         , opts(QPlatformWindowFormat::DoubleBuffer | QPlatformWindowFormat::DepthBuffer
              | QPlatformWindowFormat::Rgba | QPlatformWindowFormat::DirectRendering
              | QPlatformWindowFormat::StencilBuffer | QPlatformWindowFormat::DeprecatedFunctions
-             | QPlatformWindowFormat::UseDefaultSharedContext)
+             | QPlatformWindowFormat::UseDefaultSharedContext | QPlatformWindowFormat::HasWindowSurface)
         , depthSize(-1)
         , accumSize(-1)
         , stencilSize(-1)
@@ -102,9 +102,15 @@ public:
 /*!
     \class QPlatformWindowFormat
     \brief The QPlatformWindowFormat class specifies the display format of an OpenGL
-    rendering context.
+    rendering context and if possible attributes of the corresponding QPlatformWindow.
 
-    \ingroup painting-3D
+    \ingroup painting
+
+    QWidget has a setter and getter function for QPlatformWindowFormat. These functions can be used
+    by the application programmer to signal what kind of format he wants to the window and glcontext
+    should have. However, it is not always possible to fulfill these requirements. The application
+    programmer should therefore check the resulting QPlatformWindowFormat from QPlatformGLContext
+    to see the format that was actually created.
 
     A display format has several characteristics:
     \list
@@ -162,7 +168,7 @@ public:
         United States and other countries.
     \endlegalese
 
-    \sa QGLContext, QGLWidget
+    \sa QPlatformContext, QWidget
 */
 
 /*!
@@ -616,31 +622,32 @@ QPlatformGLContext *QPlatformWindowFormat::sharedGLContext() const
     return d->sharedContext;
 }
 
-///*!
-//    \fn bool QPlatformWindowFormat::hasOverlay() const
+/*!
+    \fn bool QPlatformWindowFormat::hasWindowSurface() const
 
-//    Returns true if overlay plane is enabled; otherwise returns false.
+    Returns true if the corresponding widget has an instance of QWindowSurface.
 
-//    Overlay is disabled by default.
+    Otherwise returns false.
 
-//    \sa setOverlay()
-//*/
+    WindowSurface is enabled by default.
 
-///*!
-//    If \a enable is true enables an overlay plane; otherwise disables
-//    the overlay plane.
+    \sa setOverlay()
+*/
 
-//    Enabling the overlay plane will cause QGLWidget to create an
-//    additional context in an overlay plane. See the QGLWidget
-//    documentation for further information.
+/*!
+    If \a enable is true a top level QWidget will create a QWindowSurface at creation;
 
-//    \sa hasOverlay()
-//*/
+    otherwise the QWidget will only have a QPlatformWindow.
 
-//void QPlatformWindowFormat::setOverlay(bool enable)
-//{
-//    setOption(enable ? QPlatformWindowFormat::HasOverlay : QPlatformWindowFormat::NoOverlay);
-//}
+    This is useful for ie. QGLWidget where the QPlatformGLContext controls the surface.
+
+    \sa hasOverlay()
+*/
+
+void QPlatformWindowFormat::setWindowSurface(bool enable)
+{
+    setOption(enable ? QPlatformWindowFormat::HasWindowSurface : QPlatformWindowFormat::NoWindowSurface);
+}
 
 /*!
     Sets the format option to \a opt.
diff --git a/src/gui/kernel/qplatformwindowformat_qpa.h b/src/gui/kernel/qplatformwindowformat_qpa.h
index 63df76a..790385b 100644
--- a/src/gui/kernel/qplatformwindowformat_qpa.h
+++ b/src/gui/kernel/qplatformwindowformat_qpa.h
@@ -67,6 +67,7 @@ public:
         SampleBuffers           = 0x0200,
         DeprecatedFunctions     = 0x0400,
         UseDefaultSharedContext = 0x0800,
+        HasWindowSurface        = 0x1000,
         SingleBuffer            = DoubleBuffer    << 16,
         NoDepthBuffer           = DepthBuffer     << 16,
         ColorIndex              = Rgba            << 16,
@@ -78,7 +79,8 @@ public:
         NoOverlay               = HasOverlay      << 16,
         NoSampleBuffers         = SampleBuffers   << 16,
         NoDeprecatedFunctions   = DeprecatedFunctions << 16,
-        NoDefaultSharedContext  = UseDefaultSharedContext << 16
+        NoDefaultSharedContext  = UseDefaultSharedContext << 16,
+        NoWindowSurface         = HasWindowSurface << 16
 
     };
     Q_DECLARE_FLAGS(FormatOptions, FormatOption)
@@ -149,8 +151,8 @@ public:
     void setDirectRendering(bool enable);
     bool useDefaultSharedContext() const;
     void setUseDefaultSharedContext(bool enable);
-//    bool hasOverlay() const;
-//    void setOverlay(bool enable);
+    bool hasWindowSurface() const;
+    void setWindowSurface(bool enable);
 
     void setOption(QPlatformWindowFormat::FormatOptions opt);
     bool testOption(QPlatformWindowFormat::FormatOptions opt) const;
@@ -219,10 +221,10 @@ inline bool QPlatformWindowFormat::directRendering() const
     return testOption(QPlatformWindowFormat::DirectRendering);
 }
 
-//inline bool QPlatformWindowFormat::hasOverlay() const
-//{
-//    return testOption(QPlatformWindowFormat::HasOverlay);
-//}
+inline bool QPlatformWindowFormat::hasWindowSurface() const
+{
+    return testOption(QPlatformWindowFormat::HasWindowSurface);
+}
 
 inline bool QPlatformWindowFormat::sampleBuffers() const
 {
diff --git a/src/gui/kernel/qwidget_qpa.cpp b/src/gui/kernel/qwidget_qpa.cpp
index ac8b37d..617d984 100644
--- a/src/gui/kernel/qwidget_qpa.cpp
+++ b/src/gui/kernel/qwidget_qpa.cpp
@@ -48,6 +48,7 @@
 #include "QtGui/private/qapplication_p.h"
 #include "QtGui/qdesktopwidget.h"
 #include "QtGui/qplatformwindow_qpa.h"
+#include "QtGui/qplatformglcontext_qpa.h"
 
 #include <QtGui/QPlatformCursor>
 
@@ -97,8 +98,12 @@ void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyO
     }
     Q_ASSERT(platformWindow);
 
-    if (!surface) {
-        surface = QApplicationPrivate::platformIntegration()->createWindowSurface(q,platformWindow->winId());
+    if (!surface ) {
+        if (platformWindow && q->platformWindowFormat().hasWindowSurface()) {
+            surface = QApplicationPrivate::platformIntegration()->createWindowSurface(q,platformWindow->winId());
+        } else {
+            q->setAttribute(Qt::WA_PaintOnScreen,true);
+        }
     }
 
     data.window_flags = q->platformWindow()->setWindowFlags(data.window_flags);
@@ -392,25 +397,22 @@ void QWidgetPrivate::show_sys()
 
     QPlatformWindow *window = q->platformWindow();
     if (window) {
-         const QRect geomRect = q->geometry();
-         const QRect windowRect = window->geometry();
-         if (windowRect != geomRect) {
-             window->setGeometry(geomRect);
-         }
-         if (q->isWindow()) {
-             if (QWindowSurface *surface = q->windowSurface()) {
-                 if (windowRect.size() != geomRect.size()) {
-                     surface->resize(geomRect.size());
-                 }
-             }
-
-             if (window)
-                 window->setVisible(true);
-
-             if (q->windowType() != Qt::Popup && q->windowType() != Qt::ToolTip && !(q->windowFlags() & Qt::X11BypassWindowManagerHint))
-                 q->activateWindow(); //###
-         }
-     }
+        const QRect geomRect = q->geometry();
+        const QRect windowRect = window->geometry();
+        if (windowRect != geomRect) {
+            window->setGeometry(geomRect);
+        }
+        if (QWindowSurface *surface = q->windowSurface()) {
+            if (windowRect.size() != geomRect.size()) {
+                surface->resize(geomRect.size());
+            }
+        }
+        if (window)
+            window->setVisible(true);
+
+        if (q->isWindow() && q->windowType() != Qt::Popup && q->windowType() != Qt::ToolTip && !(q->windowFlags() & Qt::X11BypassWindowManagerHint))
+            q->activateWindow(); //### QWindowSystemInterface should have callback function for when WS actually activates window.
+    }
 }
 
 
@@ -787,6 +789,15 @@ void QWidgetPrivate::createTLSysExtra()
 void QWidgetPrivate::deleteTLSysExtra()
 {
     if (extra && extra->topextra) {
+        //the toplevel might have a context with a "qglcontext associated with it. We need to
+        //delete the qglcontext before we delete the qplatformglcontext.
+        //One unfortunate thing about this is that we potentially create a glContext just to
+        //delete it straight afterwards.
+        if (extra->topextra->platformWindow) {
+            if (QPlatformGLContext *context = extra->topextra->platformWindow->glContext()) {
+                context->deleteQGLContext();
+            }
+        }
         delete extra->topextra->platformWindow;
         extra->topextra->platformWindow = 0;
         extra->topextra->backingStore.destroy();
@@ -831,7 +842,10 @@ QPaintEngine *QWidget::paintEngine() const
 QWindowSurface *QWidgetPrivate::createDefaultWindowSurface_sys()
 {
     Q_Q(QWidget);
-    return QApplicationPrivate::platformIntegration()->createWindowSurface(q,0);
+    if (q->platformWindowFormat().hasWindowSurface())
+        return QApplicationPrivate::platformIntegration()->createWindowSurface(q,0);
+    else
+        return 0;
 }
 
 void QWidgetPrivate::setModal_sys()
diff --git a/src/gui/painting/qbackingstore.cpp b/src/gui/painting/qbackingstore.cpp
index df1210f..c051228 100644
--- a/src/gui/painting/qbackingstore.cpp
+++ b/src/gui/painting/qbackingstore.cpp
@@ -1620,7 +1620,11 @@ void QWidgetPrivate::repaint_sys(const QRegion &rgn)
         extra->staticContentsSize = data.crect.size();
     }
 
+#ifdef Q_WS_QPA //Dont even call q->p
+    QPaintEngine *engine = 0;
+#else
     QPaintEngine *engine = q->paintEngine();
+#endif
     // QGLWidget does not support partial updates if:
     // 1) The context is double buffered
     // 2) The context is single buffered and auto-fill background is enabled.
diff --git a/src/gui/painting/qpaintengine_mac.cpp b/src/gui/painting/qpaintengine_mac.cpp
index 601cf86..c14e558 100644
--- a/src/gui/painting/qpaintengine_mac.cpp
+++ b/src/gui/painting/qpaintengine_mac.cpp
@@ -57,6 +57,8 @@
 
 #include <private/qfont_p.h>
 #include <private/qfontengine_p.h>
+#include <private/qfontengine_coretext_p.h>
+#include <private/qfontengine_mac_p.h>
 #include <private/qnumeric_p.h>
 #include <private/qpainter_p.h>
 #include <private/qpainterpath_p.h>
diff --git a/src/gui/painting/qwindowsurface.cpp b/src/gui/painting/qwindowsurface.cpp
index e9eb9c5..3ee8281 100644
--- a/src/gui/painting/qwindowsurface.cpp
+++ b/src/gui/painting/qwindowsurface.cpp
@@ -74,7 +74,7 @@ public:
     \since 4.3
     \internal
     \preliminary
-    \ingroup qws
+    \ingroup qws qpa
 
     \brief The QWindowSurface class provides the drawing area for top-level
     windows.
@@ -179,11 +179,20 @@ QRect QWindowSurface::geometry() const
     return d_ptr->geometry;
 }
 #else
+
+/*!
+      Sets the size of the windowsurface to be \a size.
+
+      \sa size()
+*/
 void QWindowSurface::resize(const QSize &size)
 {
     d_ptr->size = size;
 }
 
+/*!
+    Returns the current size of the windowsurface.
+*/
 QSize QWindowSurface::size() const
 {
     return d_ptr->size;
diff --git a/src/gui/text/qfont_mac.cpp b/src/gui/text/qfont_mac.cpp
index 0bc8ca2..7380f03 100644
--- a/src/gui/text/qfont_mac.cpp
+++ b/src/gui/text/qfont_mac.cpp
@@ -42,6 +42,7 @@
 #include "qfont.h"
 #include "qfont_p.h"
 #include "qfontengine_p.h"
+#include "qfontengine_mac_p.h"
 #include "qfontinfo.h"
 #include "qfontmetrics.h"
 #include "qpaintdevice.h"
diff --git a/src/gui/text/qfontdatabase_mac.cpp b/src/gui/text/qfontdatabase_mac.cpp
index 712bdb4..93f9c84 100644
--- a/src/gui/text/qfontdatabase_mac.cpp
+++ b/src/gui/text/qfontdatabase_mac.cpp
@@ -45,6 +45,8 @@
 #include <qabstractfileengine.h>
 #include <stdlib.h>
 #include <qendian.h>
+#include <private/qfontengine_coretext_p.h>
+#include <private/qfontengine_mac_p.h>
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/gui/text/qfontdatabase_qpa.cpp b/src/gui/text/qfontdatabase_qpa.cpp
index 19ce1be..e54093c 100644
--- a/src/gui/text/qfontdatabase_qpa.cpp
+++ b/src/gui/text/qfontdatabase_qpa.cpp
@@ -156,14 +156,11 @@ QFontEngine *loadSingleEngine(int script,
     QFontEngine *engine = QFontCache::instance()->findEngine(key);
     if (!engine) {
         QPlatformFontDatabase *pfdb = QApplicationPrivate::platformIntegration()->fontDatabase();
-        if (size->handle) {
-            engine = pfdb->fontEngine(def,QUnicodeTables::Script(script),size->handle);
-            if (engine) {
-                QFontCache::Key key(def,script);
-                QFontCache::instance()->instance()->insertEngine(key,engine);
-            }
+        engine = pfdb->fontEngine(def,QUnicodeTables::Script(script),size->handle);
+        if (engine) {
+            QFontCache::Key key(def,script);
+            QFontCache::instance()->instance()->insertEngine(key,engine);
         }
-
     }
     return engine;
 }
diff --git a/src/gui/text/qfontengine_coretext.mm b/src/gui/text/qfontengine_coretext.mm
new file mode 100644
index 0000000..dcc8329
--- /dev/null
+++ b/src/gui/text/qfontengine_coretext.mm
@@ -0,0 +1,730 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** 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 Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qfontengine_coretext_p.h"
+
+#include <QtCore/qendian.h>
+#include <QtCore/qsettings.h>
+
+#include <private/qimage_p.h>
+
+#if !defined(Q_WS_MAC) || (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+
+QT_BEGIN_NAMESPACE
+
+QCoreTextFontEngineMulti::QCoreTextFontEngineMulti(const QCFString &name, const QFontDef &fontDef, bool kerning)
+    : QFontEngineMulti(0)
+{
+    this->fontDef = fontDef;
+    CTFontSymbolicTraits symbolicTraits = 0;
+    if (fontDef.weight >= QFont::Bold)
+        symbolicTraits |= kCTFontBoldTrait;
+    switch (fontDef.style) {
+    case QFont::StyleNormal:
+        break;
+    case QFont::StyleItalic:
+    case QFont::StyleOblique:
+        symbolicTraits |= kCTFontItalicTrait;
+        break;
+    }
+
+    transform = CGAffineTransformIdentity;
+    if (fontDef.stretch != 100) {
+        transform = CGAffineTransformMakeScale(float(fontDef.stretch) / float(100), 1);
+    }
+
+    QCFType<CTFontDescriptorRef> descriptor = CTFontDescriptorCreateWithNameAndSize(name, fontDef.pixelSize);
+    QCFType<CTFontRef> baseFont = CTFontCreateWithFontDescriptor(descriptor, fontDef.pixelSize, &transform);
+    ctfont = CTFontCreateCopyWithSymbolicTraits(baseFont, fontDef.pixelSize, &transform, symbolicTraits, symbolicTraits);
+
+    // CTFontCreateCopyWithSymbolicTraits returns NULL if we ask for a trait that does
+    // not exist for the given font. (for example italic)
+    if (ctfont == 0) {
+        ctfont = baseFont;
+        CFRetain(ctfont);
+    }
+
+    attributeDict = CFDictionaryCreateMutable(0, 2,
+                                       &kCFTypeDictionaryKeyCallBacks,
+                                       &kCFTypeDictionaryValueCallBacks);
+    CFDictionaryAddValue(attributeDict, NSFontAttributeName, ctfont);
+    if (!kerning) {
+        float zero = 0.0;
+        QCFType<CFNumberRef> noKern = CFNumberCreate(kCFAllocatorDefault, kCFNumberFloatType, &zero);
+        CFDictionaryAddValue(attributeDict, kCTKernAttributeName, noKern);
+    }
+
+    QCoreTextFontEngine *fe = new QCoreTextFontEngine(ctfont, fontDef, this);
+    fe->ref.ref();
+    engines.append(fe);
+
+}
+
+QCoreTextFontEngineMulti::~QCoreTextFontEngineMulti()
+{
+    CFRelease(ctfont);
+}
+
+uint QCoreTextFontEngineMulti::fontIndexForFont(CTFontRef id) const
+{
+    for (int i = 0; i < engines.count(); ++i) {
+        if (CFEqual(engineAt(i)->ctfont, id))
+            return i;
+    }
+
+    QCoreTextFontEngineMulti *that = const_cast<QCoreTextFontEngineMulti *>(this);
+    QCoreTextFontEngine *fe = new QCoreTextFontEngine(id, fontDef, that);
+    fe->ref.ref();
+    that->engines.append(fe);
+    return engines.count() - 1;
+}
+
+bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags,
+                  unsigned short *logClusters, const HB_CharAttributes *) const
+{
+    QCFType<CFStringRef> cfstring = CFStringCreateWithCharactersNoCopy(0,
+                                                               reinterpret_cast<const UniChar *>(str),
+                                                               len, kCFAllocatorNull);
+    QCFType<CFAttributedStringRef> attributedString = CFAttributedStringCreate(0, cfstring, attributeDict);
+    QCFType<CTTypesetterRef> typeSetter = CTTypesetterCreateWithAttributedString(attributedString);
+    CFRange range = {0, 0};
+    QCFType<CTLineRef> line = CTTypesetterCreateLine(typeSetter, range);
+    CFArrayRef array = CTLineGetGlyphRuns(line);
+    uint arraySize = CFArrayGetCount(array);
+    glyph_t *outGlyphs = glyphs->glyphs;
+    HB_GlyphAttributes *outAttributes = glyphs->attributes;
+    QFixed *outAdvances_x = glyphs->advances_x;
+    QFixed *outAdvances_y = glyphs->advances_y;
+    glyph_t *initialGlyph = outGlyphs;
+
+    if (arraySize == 0) {
+        // CoreText failed to shape the text we gave it, so we assume one glyph
+        // per character and build a list of invalid glyphs with zero advance
+        *nglyphs = len;
+        for (int i = 0; i < len; ++i) {
+            outGlyphs[i] = 0;
+            if (logClusters)
+                logClusters[i] = i;
+            outAdvances_x[i] = QFixed();
+            outAdvances_y[i] = QFixed();
+            outAttributes[i].clusterStart = true;
+        }
+        return true;
+    }
+
+    const bool rtl = (CTRunGetStatus(static_cast<CTRunRef>(CFArrayGetValueAtIndex(array, 0))) & kCTRunStatusRightToLeft);
+
+    bool outOBounds = false;
+    for (uint i = 0; i < arraySize; ++i) {
+        CTRunRef run = static_cast<CTRunRef>(CFArrayGetValueAtIndex(array, rtl ? (arraySize - 1 - i) : i));
+        CFIndex glyphCount = CTRunGetGlyphCount(run);
+        if (glyphCount == 0)
+            continue;
+
+        Q_ASSERT((CTRunGetStatus(run) & kCTRunStatusRightToLeft) == rtl);
+        CFRange stringRange = CTRunGetStringRange(run);
+        UniChar endGlyph = CFStringGetCharacterAtIndex(cfstring, stringRange.location + stringRange.length - 1);
+        bool endWithPDF = QChar::direction(endGlyph) == QChar::DirPDF;
+        if (endWithPDF)
+            glyphCount++;
+
+        if (!outOBounds && outGlyphs + glyphCount - initialGlyph > *nglyphs) {
+            outOBounds = true;
+        }
+        if (!outOBounds) {
+            CFDictionaryRef runAttribs = CTRunGetAttributes(run);
+            //NSLog(@"Dictionary %@", runAttribs);
+            if (!runAttribs)
+                runAttribs = attributeDict;
+            CTFontRef runFont = static_cast<CTFontRef>(CFDictionaryGetValue(runAttribs, NSFontAttributeName));
+            const uint fontIndex = (fontIndexForFont(runFont) << 24);
+            //NSLog(@"Run Font Name = %@", CTFontCopyFamilyName(runFont));
+            if (endWithPDF)
+                glyphCount--;
+
+            QVarLengthArray<CGGlyph, 512> cgglyphs(0);
+            const CGGlyph *tmpGlyphs = CTRunGetGlyphsPtr(run);
+            if (!tmpGlyphs) {
+                cgglyphs.resize(glyphCount);
+                CTRunGetGlyphs(run, range, cgglyphs.data());
+                tmpGlyphs = cgglyphs.constData();
+            }
+            QVarLengthArray<CGPoint, 512> cgpoints(0);
+            const CGPoint *tmpPoints = CTRunGetPositionsPtr(run);
+            if (!tmpPoints) {
+                cgpoints.resize(glyphCount);
+                CTRunGetPositions(run, range, cgpoints.data());
+                tmpPoints = cgpoints.constData();
+            }
+
+            const int rtlOffset = rtl ? (glyphCount - 1) : 0;
+            const int rtlSign = rtl ? -1 : 1;
+
+            if (logClusters) {
+                CFRange stringRange = CTRunGetStringRange(run);
+                QVarLengthArray<CFIndex, 512> stringIndices(0);
+                const CFIndex *tmpIndices = CTRunGetStringIndicesPtr(run);
+                if (!tmpIndices) {
+                    stringIndices.resize(glyphCount);
+                    CTRunGetStringIndices(run, range, stringIndices.data());
+                    tmpIndices = stringIndices.constData();
+                }
+
+                const int firstGlyphIndex = outGlyphs - initialGlyph;
+                outAttributes[0].clusterStart = true;
+
+                CFIndex k = 0;
+                CFIndex i = 0;
+                for (i = stringRange.location;
+                     (i < stringRange.location + stringRange.length) && (k < glyphCount); ++i) {
+                    if (tmpIndices[k * rtlSign + rtlOffset] == i || i == stringRange.location) {
+                        logClusters[i] = k + firstGlyphIndex;
+                        outAttributes[k].clusterStart = true;
+                        ++k;
+                    } else {
+                        logClusters[i] = k + firstGlyphIndex - 1;
+                    }
+                }
+                // in case of a ligature at the end, fill the remaining logcluster entries
+                for (;i < stringRange.location + stringRange.length; i++) {
+                    logClusters[i] = k + firstGlyphIndex - 1;
+                }
+            }
+            for (CFIndex i = 0; i < glyphCount - 1; ++i) {
+                int idx = rtlOffset + rtlSign * i;
+                outGlyphs[idx] = tmpGlyphs[i] | fontIndex;
+                outAdvances_x[idx] = QFixed::fromReal(tmpPoints[i + 1].x - tmpPoints[i].x);
+                outAdvances_y[idx] = QFixed::fromReal(tmpPoints[i + 1].y - tmpPoints[i].y);
+
+                if (fontDef.styleStrategy & QFont::ForceIntegerMetrics) {
+                    outAdvances_x[idx] = outAdvances_x[idx].round();
+                    outAdvances_y[idx] = outAdvances_y[idx].round();
+                }
+            }
+            CGSize lastGlyphAdvance;
+            CTFontGetAdvancesForGlyphs(runFont, kCTFontHorizontalOrientation, tmpGlyphs + glyphCount - 1, &lastGlyphAdvance, 1);
+
+            outGlyphs[rtl ? 0 : (glyphCount - 1)] = tmpGlyphs[glyphCount - 1] | fontIndex;
+            outAdvances_x[rtl ? 0 : (glyphCount - 1)] =
+                    (fontDef.styleStrategy & QFont::ForceIntegerMetrics)
+                    ? QFixed::fromReal(lastGlyphAdvance.width).round()
+                    : QFixed::fromReal(lastGlyphAdvance.width);
+
+            if (endWithPDF) {
+                logClusters[stringRange.location + stringRange.length - 1] = glyphCount;
+                outGlyphs[glyphCount] = 0xFFFF;
+                outAdvances_x[glyphCount] = 0;
+                outAdvances_y[glyphCount] = 0;
+                outAttributes[glyphCount].clusterStart = true;
+                outAttributes[glyphCount].dontPrint = true;
+                glyphCount++;
+            }
+        }
+        outGlyphs += glyphCount;
+        outAttributes += glyphCount;
+        outAdvances_x += glyphCount;
+        outAdvances_y += glyphCount;
+    }
+    *nglyphs = (outGlyphs - initialGlyph);
+    return !outOBounds;
+}
+
+bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs,
+                                            int *nglyphs, QTextEngine::ShaperFlags flags) const
+{
+    *nglyphs = len;
+    QCFType<CFStringRef> cfstring;
+
+    QVarLengthArray<CGGlyph> cgGlyphs(len);
+    CTFontGetGlyphsForCharacters(ctfont, (const UniChar*)str, cgGlyphs.data(), len);
+
+    for (int i = 0; i < len; ++i) {
+        if (cgGlyphs[i]) {
+            glyphs->glyphs[i] = cgGlyphs[i];
+        } else {
+            if (!cfstring)
+                cfstring = CFStringCreateWithCharactersNoCopy(0, reinterpret_cast<const UniChar *>(str), len, kCFAllocatorNull);
+            QCFType<CTFontRef> substituteFont = CTFontCreateForString(ctfont, cfstring, CFRangeMake(i, 1));
+            CGGlyph substituteGlyph = 0;
+            CTFontGetGlyphsForCharacters(substituteFont, (const UniChar*)str + i, &substituteGlyph, 1);
+            if (substituteGlyph) {
+                const uint fontIndex = (fontIndexForFont(substituteFont) << 24);
+                glyphs->glyphs[i] = substituteGlyph | fontIndex;
+                if (!(flags & QTextEngine::GlyphIndicesOnly)) {
+                    CGSize advance;
+                    CTFontGetAdvancesForGlyphs(substituteFont, kCTFontHorizontalOrientation, &substituteGlyph, &advance, 1);
+                    glyphs->advances_x[i] = QFixed::fromReal(advance.width);
+                    glyphs->advances_y[i] = QFixed::fromReal(advance.height);
+                }
+            }
+        }
+    }
+
+    if (flags & QTextEngine::GlyphIndicesOnly)
+        return true;
+
+    QVarLengthArray<CGSize> advances(len);
+    CTFontGetAdvancesForGlyphs(ctfont, kCTFontHorizontalOrientation, cgGlyphs.data(), advances.data(), len);
+
+    for (int i = 0; i < len; ++i) {
+        if (glyphs->glyphs[i] & 0xff000000)
+            continue;
+        glyphs->advances_x[i] = QFixed::fromReal(advances[i].width);
+        glyphs->advances_y[i] = QFixed::fromReal(advances[i].height);
+    }
+
+    if (fontDef.styleStrategy & QFont::ForceIntegerMetrics) {
+        for (int i = 0; i < len; ++i) {
+            glyphs->advances_x[i] = glyphs->advances_x[i].round();
+            glyphs->advances_y[i] = glyphs->advances_y[i].round();
+        }
+    }
+
+    return true;
+}
+
+void QCoreTextFontEngineMulti::recalcAdvances(int , QGlyphLayout *, QTextEngine::ShaperFlags) const
+{
+}
+void QCoreTextFontEngineMulti::doKerning(int , QGlyphLayout *, QTextEngine::ShaperFlags) const
+{
+}
+
+void QCoreTextFontEngineMulti::loadEngine(int)
+{
+    // Do nothing
+    Q_ASSERT(false);
+}
+
+
+
+QCoreTextFontEngine::QCoreTextFontEngine(CTFontRef font, const QFontDef &def,
+                                         QCoreTextFontEngineMulti *multiEngine)
+{
+    fontDef = def;
+    parentEngine = multiEngine;
+    synthesisFlags = 0;
+    ctfont = font;
+    CFRetain(ctfont);
+    cgFont = CTFontCopyGraphicsFont(ctfont, NULL);
+    CTFontSymbolicTraits traits = CTFontGetSymbolicTraits(ctfont);
+    if (fontDef.weight >= QFont::Bold && !(traits & kCTFontBoldTrait)) {
+         synthesisFlags |= SynthesizedBold;
+    }
+
+    if (fontDef.style != QFont::StyleNormal && !(traits & kCTFontItalicTrait)) {
+        synthesisFlags |= SynthesizedItalic;
+    }
+    transform = CGAffineTransformIdentity;
+    if (fontDef.stretch != 100) {
+        transform = CGAffineTransformMakeScale(float(fontDef.stretch) / float(100), 1);
+    }
+    QByteArray os2Table = getSfntTable(MAKE_TAG('O', 'S', '/', '2'));
+    if (os2Table.size() >= 10)
+        fsType = qFromBigEndian<quint16>(reinterpret_cast<const uchar *>(os2Table.constData() + 8));
+
+     QSettings appleSettings(QLatin1String("apple.com"));
+     QVariant appleValue = appleSettings.value(QLatin1String("AppleAntiAliasingThreshold"));
+     if (appleValue.isValid())
+         antialiasing_threshold = appleValue.toInt();
+     else
+         antialiasing_threshold = -1;
+}
+
+QCoreTextFontEngine::~QCoreTextFontEngine()
+{
+    CFRelease(cgFont);
+    CFRelease(ctfont);
+}
+
+bool QCoreTextFontEngine::stringToCMap(const QChar *, int, QGlyphLayout *, int *, QTextEngine::ShaperFlags) const
+{
+    return false;
+}
+
+glyph_metrics_t QCoreTextFontEngine::boundingBox(const QGlyphLayout &glyphs)
+{
+    QFixed w;
+    bool round = fontDef.styleStrategy & QFont::ForceIntegerMetrics;
+
+    for (int i = 0; i < glyphs.numGlyphs; ++i) {
+        w += round ? glyphs.effectiveAdvance(i).round()
+                   : glyphs.effectiveAdvance(i);
+    }
+    return glyph_metrics_t(0, -(ascent()), w - lastRightBearing(glyphs, round), ascent()+descent(), w, 0);
+}
+glyph_metrics_t QCoreTextFontEngine::boundingBox(glyph_t glyph)
+{
+    glyph_metrics_t ret;
+    CGGlyph g = glyph;
+    CGRect rect = CTFontGetBoundingRectsForGlyphs(ctfont, kCTFontHorizontalOrientation, &g, 0, 1);
+    ret.width = QFixed::fromReal(rect.size.width);
+    ret.height = QFixed::fromReal(rect.size.height);
+    ret.x = QFixed::fromReal(rect.origin.x);
+    ret.y = -QFixed::fromReal(rect.origin.y) - ret.height;
+    CGSize advances[1];
+    CTFontGetAdvancesForGlyphs(ctfont, kCTFontHorizontalOrientation, &g, advances, 1);
+    ret.xoff = QFixed::fromReal(advances[0].width);
+    ret.yoff = QFixed::fromReal(advances[0].height);
+
+    if (fontDef.styleStrategy & QFont::ForceIntegerMetrics) {
+        ret.xoff = ret.xoff.round();
+        ret.yoff = ret.yoff.round();
+    }
+
+    return ret;
+}
+
+QFixed QCoreTextFontEngine::ascent() const
+{
+    return (fontDef.styleStrategy & QFont::ForceIntegerMetrics)
+            ? QFixed::fromReal(CTFontGetAscent(ctfont)).round()
+            : QFixed::fromReal(CTFontGetAscent(ctfont));
+}
+QFixed QCoreTextFontEngine::descent() const
+{
+    QFixed d = QFixed::fromReal(CTFontGetDescent(ctfont));
+    if (fontDef.styleStrategy & QFont::ForceIntegerMetrics)
+        d = d.round();
+
+    // subtract a pixel to even out the historical +1 in QFontMetrics::height().
+    // Fix in Qt 5.
+    return d - 1;
+}
+QFixed QCoreTextFontEngine::leading() const
+{
+    return (fontDef.styleStrategy & QFont::ForceIntegerMetrics)
+            ? QFixed::fromReal(CTFontGetLeading(ctfont)).round()
+            : QFixed::fromReal(CTFontGetLeading(ctfont));
+}
+QFixed QCoreTextFontEngine::xHeight() const
+{
+    return (fontDef.styleStrategy & QFont::ForceIntegerMetrics)
+            ? QFixed::fromReal(CTFontGetXHeight(ctfont)).round()
+            : QFixed::fromReal(CTFontGetXHeight(ctfont));
+}
+QFixed QCoreTextFontEngine::averageCharWidth() const
+{
+    // ### Need to implement properly and get the information from the OS/2 Table.
+    return (fontDef.styleStrategy & QFont::ForceIntegerMetrics)
+            ? QFontEngine::averageCharWidth().round()
+            : QFontEngine::averageCharWidth();
+}
+
+qreal QCoreTextFontEngine::maxCharWidth() const
+{
+    // ### Max Help!
+    return 0;
+
+}
+qreal QCoreTextFontEngine::minLeftBearing() const
+{
+    // ### Min Help!
+    return 0;
+
+}
+qreal QCoreTextFontEngine::minRightBearing() const
+{
+    // ### Max Help! (even thought it's right)
+    return 0;
+
+}
+
+void QCoreTextFontEngine::draw(CGContextRef ctx, qreal x, qreal y, const QTextItemInt &ti, int paintDeviceHeight)
+{
+    QVarLengthArray<QFixedPoint> positions;
+    QVarLengthArray<glyph_t> glyphs;
+    QTransform matrix;
+    matrix.translate(x, y);
+    getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+    if (glyphs.size() == 0)
+        return;
+
+    CGContextSetFontSize(ctx, fontDef.pixelSize);
+
+    CGAffineTransform oldTextMatrix = CGContextGetTextMatrix(ctx);
+
+    CGAffineTransform cgMatrix = CGAffineTransformMake(1, 0, 0, -1, 0, -paintDeviceHeight);
+
+    CGAffineTransformConcat(cgMatrix, oldTextMatrix);
+
+    if (synthesisFlags & QFontEngine::SynthesizedItalic)
+        cgMatrix = CGAffineTransformConcat(cgMatrix, CGAffineTransformMake(1, 0, -tanf(14 * acosf(0) / 90), 1, 0, 0));
+
+    cgMatrix = CGAffineTransformConcat(cgMatrix, transform);
+
+    CGContextSetTextMatrix(ctx, cgMatrix);
+
+    CGContextSetTextDrawingMode(ctx, kCGTextFill);
+
+
+    QVarLengthArray<CGSize> advances(glyphs.size());
+    QVarLengthArray<CGGlyph> cgGlyphs(glyphs.size());
+
+    for (int i = 0; i < glyphs.size() - 1; ++i) {
+        advances[i].width = (positions[i + 1].x - positions[i].x).toReal();
+        advances[i].height = (positions[i + 1].y - positions[i].y).toReal();
+        cgGlyphs[i] = glyphs[i];
+    }
+    advances[glyphs.size() - 1].width = 0;
+    advances[glyphs.size() - 1].height = 0;
+    cgGlyphs[glyphs.size() - 1] = glyphs[glyphs.size() - 1];
+
+    CGContextSetFont(ctx, cgFont);
+    //NSLog(@"Font inDraw %@  ctfont %@", CGFontCopyFullName(cgFont), CTFontCopyFamilyName(ctfont));
+
+    CGContextSetTextPosition(ctx, positions[0].x.toReal(), positions[0].y.toReal());
+
+    CGContextShowGlyphsWithAdvances(ctx, cgGlyphs.data(), advances.data(), glyphs.size());
+
+    if (synthesisFlags & QFontEngine::SynthesizedBold) {
+        CGContextSetTextPosition(ctx, positions[0].x.toReal() + 0.5 * lineThickness().toReal(),
+                                 positions[0].y.toReal());
+
+        CGContextShowGlyphsWithAdvances(ctx, cgGlyphs.data(), advances.data(), glyphs.size());
+    }
+
+    CGContextSetTextMatrix(ctx, oldTextMatrix);
+}
+
+struct ConvertPathInfo
+{
+    ConvertPathInfo(QPainterPath *newPath, const QPointF &newPos) : path(newPath), pos(newPos) {}
+    QPainterPath *path;
+    QPointF pos;
+};
+
+static void convertCGPathToQPainterPath(void *info, const CGPathElement *element)
+{
+    ConvertPathInfo *myInfo = static_cast<ConvertPathInfo *>(info);
+    switch(element->type) {
+        case kCGPathElementMoveToPoint:
+            myInfo->path->moveTo(element->points[0].x + myInfo->pos.x(),
+                                 element->points[0].y + myInfo->pos.y());
+            break;
+        case kCGPathElementAddLineToPoint:
+            myInfo->path->lineTo(element->points[0].x + myInfo->pos.x(),
+                                 element->points[0].y + myInfo->pos.y());
+            break;
+        case kCGPathElementAddQuadCurveToPoint:
+            myInfo->path->quadTo(element->points[0].x + myInfo->pos.x(),
+                                 element->points[0].y + myInfo->pos.y(),
+                                 element->points[1].x + myInfo->pos.x(),
+                                 element->points[1].y + myInfo->pos.y());
+            break;
+        case kCGPathElementAddCurveToPoint:
+            myInfo->path->cubicTo(element->points[0].x + myInfo->pos.x(),
+                                  element->points[0].y + myInfo->pos.y(),
+                                  element->points[1].x + myInfo->pos.x(),
+                                  element->points[1].y + myInfo->pos.y(),
+                                  element->points[2].x + myInfo->pos.x(),
+                                  element->points[2].y + myInfo->pos.y());
+            break;
+        case kCGPathElementCloseSubpath:
+            myInfo->path->closeSubpath();
+            break;
+        default:
+            qDebug() << "Unhandled path transform type: " << element->type;
+    }
+
+}
+
+void QCoreTextFontEngine::addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nGlyphs,
+                                          QPainterPath *path, QTextItem::RenderFlags)
+{
+
+    CGAffineTransform cgMatrix = CGAffineTransformIdentity;
+    cgMatrix = CGAffineTransformScale(cgMatrix, 1, -1);
+
+    if (synthesisFlags & QFontEngine::SynthesizedItalic)
+        cgMatrix = CGAffineTransformConcat(cgMatrix, CGAffineTransformMake(1, 0, -tanf(14 * acosf(0) / 90), 1, 0, 0));
+
+
+    for (int i = 0; i < nGlyphs; ++i) {
+        QCFType<CGPathRef> cgpath = CTFontCreatePathForGlyph(ctfont, glyphs[i], &cgMatrix);
+        ConvertPathInfo info(path, positions[i].toPointF());
+        CGPathApply(cgpath, &info, convertCGPathToQPainterPath);
+    }
+}
+
+QFont QCoreTextFontEngine::createExplicitFont() const
+{
+    QString familyName = QCFString::toQString(CTFontCopyFamilyName(ctfont));
+    return createExplicitFontWithName(familyName);
+}
+
+QImage QCoreTextFontEngine::imageForGlyph(glyph_t glyph, QFixed subPixelPosition, int /*margin*/, bool aa)
+{
+    const glyph_metrics_t br = boundingBox(glyph);
+    QImage im(qRound(br.width)+2, qRound(br.height)+2, QImage::Format_RGB32);
+    im.fill(0);
+
+    CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
+    uint cgflags = kCGImageAlphaNoneSkipFirst;
+#ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version
+    cgflags |= kCGBitmapByteOrder32Host;
+#endif
+    CGContextRef ctx = CGBitmapContextCreate(im.bits(), im.width(), im.height(),
+                                             8, im.bytesPerLine(), colorspace,
+                                             cgflags);
+    CGContextSetFontSize(ctx, fontDef.pixelSize);
+    CGContextSetShouldAntialias(ctx, aa ||
+                                (fontDef.pointSize > antialiasing_threshold
+                                 && !(fontDef.styleStrategy & QFont::NoAntialias)));
+    CGContextSetShouldSmoothFonts(ctx, aa);
+    CGAffineTransform oldTextMatrix = CGContextGetTextMatrix(ctx);
+    CGAffineTransform cgMatrix = CGAffineTransformMake(1, 0, 0, 1, 0, 0);
+
+    CGAffineTransformConcat(cgMatrix, oldTextMatrix);
+
+    if (synthesisFlags & QFontEngine::SynthesizedItalic)
+        cgMatrix = CGAffineTransformConcat(cgMatrix, CGAffineTransformMake(1, 0, tanf(14 * acosf(0) / 90), 1, 0, 0));
+
+    cgMatrix = CGAffineTransformConcat(cgMatrix, transform);
+
+    CGContextSetTextMatrix(ctx, cgMatrix);
+    CGContextSetRGBFillColor(ctx, 1, 1, 1, 1);
+    CGContextSetTextDrawingMode(ctx, kCGTextFill);
+
+    CGContextSetFont(ctx, cgFont);
+
+    qreal pos_x = -br.x.toReal() + subPixelPosition.toReal();
+    qreal pos_y = im.height() + br.y.toReal() - 1;
+    CGContextSetTextPosition(ctx, pos_x, pos_y);
+
+    CGSize advance;
+    advance.width = 0;
+    advance.height = 0;
+    CGGlyph cgGlyph = glyph;
+    CGContextShowGlyphsWithAdvances(ctx, &cgGlyph, &advance, 1);
+
+    if (synthesisFlags & QFontEngine::SynthesizedBold) {
+        CGContextSetTextPosition(ctx, pos_x + 0.5 * lineThickness().toReal(), pos_y);
+        CGContextShowGlyphsWithAdvances(ctx, &cgGlyph, &advance, 1);
+    }
+
+    CGContextRelease(ctx);
+
+    return im;
+}
+
+QImage QCoreTextFontEngine::alphaMapForGlyph(glyph_t glyph, QFixed subPixelPosition)
+{
+    QImage im = imageForGlyph(glyph, subPixelPosition, 0, false);
+
+    QImage indexed(im.width(), im.height(), QImage::Format_Indexed8);
+    QVector<QRgb> colors(256);
+    for (int i=0; i<256; ++i)
+        colors[i] = qRgba(0, 0, 0, i);
+    indexed.setColorTable(colors);
+
+    for (int y=0; y<im.height(); ++y) {
+        uint *src = (uint*) im.scanLine(y);
+        uchar *dst = indexed.scanLine(y);
+        for (int x=0; x<im.width(); ++x) {
+            *dst = qGray(*src);
+            ++dst;
+            ++src;
+        }
+    }
+
+    return indexed;
+}
+
+QImage QCoreTextFontEngine::alphaRGBMapForGlyph(glyph_t glyph, QFixed subPixelPosition, int margin, const QTransform &x)
+{
+    if (x.type() >= QTransform::TxScale)
+        return QFontEngine::alphaRGBMapForGlyph(glyph, subPixelPosition, margin, x);
+
+    QImage im = imageForGlyph(glyph, subPixelPosition, margin, true);
+    qGamma_correct_back_to_linear_cs(&im);
+    return im;
+}
+
+void QCoreTextFontEngine::recalcAdvances(int numGlyphs, QGlyphLayout *glyphs, QTextEngine::ShaperFlags flags) const
+{
+    Q_ASSERT(false);
+    Q_UNUSED(numGlyphs);
+    Q_UNUSED(glyphs);
+    Q_UNUSED(flags);
+}
+
+QFontEngine::FaceId QCoreTextFontEngine::faceId() const
+{
+    return QFontEngine::FaceId();
+}
+
+bool QCoreTextFontEngine::canRender(const QChar *string, int len)
+{
+    QCFType<CTFontRef> retFont = CTFontCreateForString(ctfont,
+                  QCFType<CFStringRef>(CFStringCreateWithCharactersNoCopy(0,
+                                                              reinterpret_cast<const UniChar *>(string),
+                                                                          len, kCFAllocatorNull)),
+                          CFRangeMake(0, len));
+    return retFont != 0;
+    return false;
+}
+
+ bool QCoreTextFontEngine::getSfntTableData(uint tag, uchar *buffer, uint *length) const
+ {
+     QCFType<CFDataRef> table = CTFontCopyTable(ctfont, tag, 0);
+     if (!table || !length)
+         return false;
+     CFIndex tableLength = CFDataGetLength(table);
+     int availableLength = *length;
+     *length = tableLength;
+     if (buffer) {
+         if (tableLength > availableLength)
+             return false;
+         CFDataGetBytes(table, CFRangeMake(0, tableLength), buffer);
+     }
+     return true;
+ }
+
+void QCoreTextFontEngine::getUnscaledGlyph(glyph_t, QPainterPath *, glyph_metrics_t *)
+{
+    // ###
+}
+
+QT_END_NAMESPACE
+
+#endif// !defined(Q_WS_MAC) || (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+
diff --git a/src/gui/text/qfontengine_coretext_p.h b/src/gui/text/qfontengine_coretext_p.h
new file mode 100644
index 0000000..b4450fa
--- /dev/null
+++ b/src/gui/text/qfontengine_coretext_p.h
@@ -0,0 +1,136 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** 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 Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFONTENGINE_CORETEXT_P_H
+#define QFONTENGINE_CORETEXT_P_H
+
+#include <private/qfontengine_p.h>
+
+#if !defined(Q_WS_MAC) || (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+
+class QCoreTextFontEngineMulti;
+class QCoreTextFontEngine : public QFontEngine
+{
+public:
+    QCoreTextFontEngine(CTFontRef font, const QFontDef &def,
+                        QCoreTextFontEngineMulti *multiEngine = 0);
+    ~QCoreTextFontEngine();
+    virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const;
+    virtual void recalcAdvances(int , QGlyphLayout *, QTextEngine::ShaperFlags) const;
+
+    virtual glyph_metrics_t boundingBox(const QGlyphLayout &glyphs);
+    virtual glyph_metrics_t boundingBox(glyph_t glyph);
+
+    virtual QFixed ascent() const;
+    virtual QFixed descent() const;
+    virtual QFixed leading() const;
+    virtual QFixed xHeight() const;
+    virtual qreal maxCharWidth() const;
+    virtual QFixed averageCharWidth() const;
+
+    virtual void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int numGlyphs,
+                                 QPainterPath *path, QTextItem::RenderFlags);
+
+    virtual const char *name() const { return "QCoreTextFontEngine"; }
+
+    virtual bool canRender(const QChar *string, int len);
+
+    virtual int synthesized() const { return synthesisFlags; }
+    virtual bool supportsSubPixelPositions() const { return true; }
+
+    virtual Type type() const { return QFontEngine::Mac; }
+
+    void draw(CGContextRef ctx, qreal x, qreal y, const QTextItemInt &ti, int paintDeviceHeight);
+
+    virtual FaceId faceId() const;
+    virtual bool getSfntTableData(uint /*tag*/, uchar * /*buffer*/, uint * /*length*/) const;
+    virtual void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics);
+    virtual QImage alphaMapForGlyph(glyph_t, QFixed subPixelPosition);
+    virtual QImage alphaRGBMapForGlyph(glyph_t, QFixed subPixelPosition, int margin, const QTransform &t);
+    virtual qreal minRightBearing() const;
+    virtual qreal minLeftBearing() const;
+    virtual QFont createExplicitFont() const;
+
+private:
+    QImage imageForGlyph(glyph_t glyph, QFixed subPixelPosition, int margin, bool colorful);
+    CTFontRef ctfont;
+    CGFontRef cgFont;
+    QCoreTextFontEngineMulti *parentEngine;
+    int synthesisFlags;
+    CGAffineTransform transform;
+    friend class QCoreTextFontEngineMulti;
+    int antialiasing_threshold;
+};
+
+class QCoreTextFontEngineMulti : public QFontEngineMulti
+{
+public:
+    QCoreTextFontEngineMulti(const QCFString &name, const QFontDef &fontDef, bool kerning);
+    ~QCoreTextFontEngineMulti();
+
+    virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs,
+                              QTextEngine::ShaperFlags flags) const;
+    bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs,
+                      QTextEngine::ShaperFlags flags,
+                      unsigned short *logClusters, const HB_CharAttributes *charAttributes) const;
+
+
+    virtual void recalcAdvances(int , QGlyphLayout *, QTextEngine::ShaperFlags) const;
+    virtual void doKerning(int , QGlyphLayout *, QTextEngine::ShaperFlags) const;
+
+    virtual const char *name() const { return "CoreText"; }
+protected:
+    virtual void loadEngine(int at);
+
+private:
+    inline const QCoreTextFontEngine *engineAt(int i) const
+    { return static_cast<const QCoreTextFontEngine *>(engines.at(i)); }
+
+    uint fontIndexForFont(CTFontRef id) const;
+    CTFontRef ctfont;
+    mutable QCFType<CFMutableDictionaryRef> attributeDict;
+    CGAffineTransform transform;
+    friend class QFontDialogPrivate;
+};
+
+#endif// !defined(Q_WS_MAC) || (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+
+#endif // QFONTENGINE_CORETEXT_P_H
diff --git a/src/gui/text/qfontengine_mac.mm b/src/gui/text/qfontengine_mac.mm
index 3c6f3b2..98781ad 100644
--- a/src/gui/text/qfontengine_mac.mm
+++ b/src/gui/text/qfontengine_mac.mm
@@ -39,6 +39,8 @@
 **
 ****************************************************************************/
 
+#include "qfontengine_mac_p.h"
+
 #include <private/qapplication_p.h>
 #include <private/qfontengine_p.h>
 #include <private/qpainter_p.h>
@@ -53,6 +55,7 @@
 #include <qdebug.h>
 #include <qendian.h>
 #include <qmath.h>
+#include <private/qimage_p.h>
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <AppKit/AppKit.h>
@@ -119,698 +122,6 @@ OSStatus QMacFontPath::closePath(void *data)
 }
 
 
-
-void qmacfontengine_gamma_correct(QImage *image)
-{
-    extern uchar qt_pow_rgb_gamma[256];
-
-    // gamma correct the pixels back to linear color space...
-    int h = image->height();
-    int w = image->width();
-
-    for (int y=0; y<h; ++y) {
-        uint *pixels = (uint *) image->scanLine(y);
-        for (int x=0; x<w; ++x) {
-            uint p = pixels[x];
-            uint r = qt_pow_rgb_gamma[qRed(p)];
-            uint g = qt_pow_rgb_gamma[qGreen(p)];
-            uint b = qt_pow_rgb_gamma[qBlue(p)];
-            pixels[x] = (r << 16) | (g << 8) | b | 0xff000000;
-        }
-    }
-}
-
-
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
-QCoreTextFontEngineMulti::QCoreTextFontEngineMulti(const QCFString &name, const QFontDef &fontDef, bool kerning)
-    : QFontEngineMulti(0)
-{
-    this->fontDef = fontDef;
-    CTFontSymbolicTraits symbolicTraits = 0;
-    if (fontDef.weight >= QFont::Bold)
-        symbolicTraits |= kCTFontBoldTrait;
-    switch (fontDef.style) {
-    case QFont::StyleNormal:
-        break;
-    case QFont::StyleItalic:
-    case QFont::StyleOblique:
-        symbolicTraits |= kCTFontItalicTrait;
-        break;
-    }
-
-    transform = CGAffineTransformIdentity;
-    if (fontDef.stretch != 100) {
-        transform = CGAffineTransformMakeScale(float(fontDef.stretch) / float(100), 1);
-    }
-
-    QCFType<CTFontDescriptorRef> descriptor = CTFontDescriptorCreateWithNameAndSize(name, fontDef.pixelSize);
-    QCFType<CTFontRef> baseFont = CTFontCreateWithFontDescriptor(descriptor, fontDef.pixelSize, &transform);
-    ctfont = CTFontCreateCopyWithSymbolicTraits(baseFont, fontDef.pixelSize, &transform, symbolicTraits, symbolicTraits);
-
-    // CTFontCreateCopyWithSymbolicTraits returns NULL if we ask for a trait that does
-    // not exist for the given font. (for example italic)
-    if (ctfont == 0) {
-        ctfont = baseFont;
-        CFRetain(ctfont);
-    }
-
-    attributeDict = CFDictionaryCreateMutable(0, 2,
-                                       &kCFTypeDictionaryKeyCallBacks,
-                                       &kCFTypeDictionaryValueCallBacks);
-    CFDictionaryAddValue(attributeDict, NSFontAttributeName, ctfont);
-    if (!kerning) {
-        float zero = 0.0;
-        QCFType<CFNumberRef> noKern = CFNumberCreate(kCFAllocatorDefault, kCFNumberFloatType, &zero);
-        CFDictionaryAddValue(attributeDict, kCTKernAttributeName, noKern);
-    }
-
-    QCoreTextFontEngine *fe = new QCoreTextFontEngine(ctfont, fontDef, this);
-    fe->ref.ref();
-    engines.append(fe);
-
-}
-
-QCoreTextFontEngineMulti::~QCoreTextFontEngineMulti()
-{
-    CFRelease(ctfont);
-}
-
-uint QCoreTextFontEngineMulti::fontIndexForFont(CTFontRef id) const
-{
-    for (int i = 0; i < engines.count(); ++i) {
-        if (CFEqual(engineAt(i)->ctfont, id))
-            return i;
-    }
-
-    QCoreTextFontEngineMulti *that = const_cast<QCoreTextFontEngineMulti *>(this);
-    QCoreTextFontEngine *fe = new QCoreTextFontEngine(id, fontDef, that);
-    fe->ref.ref();
-    that->engines.append(fe);
-    return engines.count() - 1;
-}
-
-bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags,
-                  unsigned short *logClusters, const HB_CharAttributes *) const
-{
-    QCFType<CFStringRef> cfstring = CFStringCreateWithCharactersNoCopy(0,
-                                                               reinterpret_cast<const UniChar *>(str),
-                                                               len, kCFAllocatorNull);
-    QCFType<CFAttributedStringRef> attributedString = CFAttributedStringCreate(0, cfstring, attributeDict);
-    QCFType<CTTypesetterRef> typeSetter = CTTypesetterCreateWithAttributedString(attributedString);
-    CFRange range = {0, 0};
-    QCFType<CTLineRef> line = CTTypesetterCreateLine(typeSetter, range);
-    CFArrayRef array = CTLineGetGlyphRuns(line);
-    uint arraySize = CFArrayGetCount(array);
-    glyph_t *outGlyphs = glyphs->glyphs;
-    HB_GlyphAttributes *outAttributes = glyphs->attributes;
-    QFixed *outAdvances_x = glyphs->advances_x;
-    QFixed *outAdvances_y = glyphs->advances_y;
-    glyph_t *initialGlyph = outGlyphs;
-
-    if (arraySize == 0) {
-        // CoreText failed to shape the text we gave it, so we assume one glyph
-        // per character and build a list of invalid glyphs with zero advance
-        *nglyphs = len;
-        for (int i = 0; i < len; ++i) {
-            outGlyphs[i] = 0;
-            if (logClusters)
-                logClusters[i] = i;
-            outAdvances_x[i] = QFixed();
-            outAdvances_y[i] = QFixed();
-            outAttributes[i].clusterStart = true;
-        }
-        return true;
-    }
-
-    const bool rtl = (CTRunGetStatus(static_cast<CTRunRef>(CFArrayGetValueAtIndex(array, 0))) & kCTRunStatusRightToLeft);
-
-    bool outOBounds = false;
-    for (uint i = 0; i < arraySize; ++i) {
-        CTRunRef run = static_cast<CTRunRef>(CFArrayGetValueAtIndex(array, rtl ? (arraySize - 1 - i) : i));
-        CFIndex glyphCount = CTRunGetGlyphCount(run);
-        if (glyphCount == 0)
-            continue;
-
-        Q_ASSERT((CTRunGetStatus(run) & kCTRunStatusRightToLeft) == rtl);
-        CFRange stringRange = CTRunGetStringRange(run);
-        UniChar endGlyph = CFStringGetCharacterAtIndex(cfstring, stringRange.location + stringRange.length - 1);
-        bool endWithPDF = QChar::direction(endGlyph) == QChar::DirPDF;
-        if (endWithPDF)
-            glyphCount++;
-
-        if (!outOBounds && outGlyphs + glyphCount - initialGlyph > *nglyphs) {
-            outOBounds = true;
-        }
-        if (!outOBounds) {
-            CFDictionaryRef runAttribs = CTRunGetAttributes(run);
-            //NSLog(@"Dictionary %@", runAttribs);
-            if (!runAttribs)
-                runAttribs = attributeDict;
-            CTFontRef runFont = static_cast<CTFontRef>(CFDictionaryGetValue(runAttribs, NSFontAttributeName));
-            const uint fontIndex = (fontIndexForFont(runFont) << 24);
-            //NSLog(@"Run Font Name = %@", CTFontCopyFamilyName(runFont));
-            if (endWithPDF)
-                glyphCount--;
-
-            QVarLengthArray<CGGlyph, 512> cgglyphs(0);
-            const CGGlyph *tmpGlyphs = CTRunGetGlyphsPtr(run);
-            if (!tmpGlyphs) {
-                cgglyphs.resize(glyphCount);
-                CTRunGetGlyphs(run, range, cgglyphs.data());
-                tmpGlyphs = cgglyphs.constData();
-            }
-            QVarLengthArray<CGPoint, 512> cgpoints(0);
-            const CGPoint *tmpPoints = CTRunGetPositionsPtr(run);
-            if (!tmpPoints) {
-                cgpoints.resize(glyphCount);
-                CTRunGetPositions(run, range, cgpoints.data());
-                tmpPoints = cgpoints.constData();
-            }
-
-            const int rtlOffset = rtl ? (glyphCount - 1) : 0;
-            const int rtlSign = rtl ? -1 : 1;
-
-            if (logClusters) {
-                CFRange stringRange = CTRunGetStringRange(run);
-                QVarLengthArray<CFIndex, 512> stringIndices(0);
-                const CFIndex *tmpIndices = CTRunGetStringIndicesPtr(run);
-                if (!tmpIndices) {
-                    stringIndices.resize(glyphCount);
-                    CTRunGetStringIndices(run, range, stringIndices.data());
-                    tmpIndices = stringIndices.constData();
-                }
-
-                const int firstGlyphIndex = outGlyphs - initialGlyph;
-                outAttributes[0].clusterStart = true;
-
-                CFIndex k = 0;
-                CFIndex i = 0;
-                for (i = stringRange.location;
-                     (i < stringRange.location + stringRange.length) && (k < glyphCount); ++i) {
-                    if (tmpIndices[k * rtlSign + rtlOffset] == i || i == stringRange.location) {
-                        logClusters[i] = k + firstGlyphIndex;
-                        outAttributes[k].clusterStart = true;
-                        ++k;
-                    } else {
-                        logClusters[i] = k + firstGlyphIndex - 1;
-                    }
-                }
-                // in case of a ligature at the end, fill the remaining logcluster entries
-                for (;i < stringRange.location + stringRange.length; i++) {
-                    logClusters[i] = k + firstGlyphIndex - 1;
-                }
-            }
-            for (CFIndex i = 0; i < glyphCount - 1; ++i) {
-                int idx = rtlOffset + rtlSign * i;
-                outGlyphs[idx] = tmpGlyphs[i] | fontIndex;
-                outAdvances_x[idx] = QFixed::fromReal(tmpPoints[i + 1].x - tmpPoints[i].x);
-                outAdvances_y[idx] = QFixed::fromReal(tmpPoints[i + 1].y - tmpPoints[i].y);
-                
-                if (fontDef.styleStrategy & QFont::ForceIntegerMetrics) {
-                    outAdvances_x[idx] = outAdvances_x[idx].round();
-                    outAdvances_y[idx] = outAdvances_y[idx].round();
-                }
-            }
-            CGSize lastGlyphAdvance;
-            CTFontGetAdvancesForGlyphs(runFont, kCTFontHorizontalOrientation, tmpGlyphs + glyphCount - 1, &lastGlyphAdvance, 1);
-
-            outGlyphs[rtl ? 0 : (glyphCount - 1)] = tmpGlyphs[glyphCount - 1] | fontIndex;
-            outAdvances_x[rtl ? 0 : (glyphCount - 1)] =
-                    (fontDef.styleStrategy & QFont::ForceIntegerMetrics)
-                    ? QFixed::fromReal(lastGlyphAdvance.width).round()
-                    : QFixed::fromReal(lastGlyphAdvance.width);
-
-            if (endWithPDF) {
-                logClusters[stringRange.location + stringRange.length - 1] = glyphCount;
-                outGlyphs[glyphCount] = 0xFFFF;
-                outAdvances_x[glyphCount] = 0;
-                outAdvances_y[glyphCount] = 0;
-                outAttributes[glyphCount].clusterStart = true;
-                outAttributes[glyphCount].dontPrint = true;
-                glyphCount++;
-            }
-        }
-        outGlyphs += glyphCount;
-        outAttributes += glyphCount;
-        outAdvances_x += glyphCount;
-        outAdvances_y += glyphCount;
-    }
-    *nglyphs = (outGlyphs - initialGlyph);
-    return !outOBounds;
-}
-
-bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs,
-                                            int *nglyphs, QTextEngine::ShaperFlags flags) const
-{
-    *nglyphs = len;
-    QCFType<CFStringRef> cfstring;
-
-    QVarLengthArray<CGGlyph> cgGlyphs(len);
-    CTFontGetGlyphsForCharacters(ctfont, (const UniChar*)str, cgGlyphs.data(), len);
-
-    for (int i = 0; i < len; ++i) {
-        if (cgGlyphs[i]) {
-            glyphs->glyphs[i] = cgGlyphs[i];
-	} else {
-            if (!cfstring)
-                cfstring = CFStringCreateWithCharactersNoCopy(0, reinterpret_cast<const UniChar *>(str), len, kCFAllocatorNull);
-            QCFType<CTFontRef> substituteFont = CTFontCreateForString(ctfont, cfstring, CFRangeMake(i, 1));
-            CGGlyph substituteGlyph = 0;
-            CTFontGetGlyphsForCharacters(substituteFont, (const UniChar*)str + i, &substituteGlyph, 1);
-            if (substituteGlyph) {
-                const uint fontIndex = (fontIndexForFont(substituteFont) << 24);
-                glyphs->glyphs[i] = substituteGlyph | fontIndex;
-                if (!(flags & QTextEngine::GlyphIndicesOnly)) {
-                    CGSize advance;
-                    CTFontGetAdvancesForGlyphs(substituteFont, kCTFontHorizontalOrientation, &substituteGlyph, &advance, 1);
-                    glyphs->advances_x[i] = QFixed::fromReal(advance.width);
-                    glyphs->advances_y[i] = QFixed::fromReal(advance.height);
-                }
-            }
-        }
-    }
-
-    if (flags & QTextEngine::GlyphIndicesOnly)
-        return true;
-
-    QVarLengthArray<CGSize> advances(len);
-    CTFontGetAdvancesForGlyphs(ctfont, kCTFontHorizontalOrientation, cgGlyphs.data(), advances.data(), len);
-
-    for (int i = 0; i < len; ++i) {
-        if (glyphs->glyphs[i] & 0xff000000)
-            continue;
-        glyphs->advances_x[i] = QFixed::fromReal(advances[i].width);
-        glyphs->advances_y[i] = QFixed::fromReal(advances[i].height);
-    }
-
-    if (fontDef.styleStrategy & QFont::ForceIntegerMetrics) {
-        for (int i = 0; i < len; ++i) {
-            glyphs->advances_x[i] = glyphs->advances_x[i].round();
-            glyphs->advances_y[i] = glyphs->advances_y[i].round();
-        }
-    }
-
-    return true;
-}
-
-void QCoreTextFontEngineMulti::recalcAdvances(int , QGlyphLayout *, QTextEngine::ShaperFlags) const
-{
-}
-void QCoreTextFontEngineMulti::doKerning(int , QGlyphLayout *, QTextEngine::ShaperFlags) const
-{
-}
-
-void QCoreTextFontEngineMulti::loadEngine(int)
-{
-    // Do nothing
-    Q_ASSERT(false);
-}
-
-
-
-QCoreTextFontEngine::QCoreTextFontEngine(CTFontRef font, const QFontDef &def,
-                                         QCoreTextFontEngineMulti *multiEngine)
-{
-    fontDef = def;
-    parentEngine = multiEngine;
-    synthesisFlags = 0;
-    ctfont = font;
-    CFRetain(ctfont);
-    cgFont = CTFontCopyGraphicsFont(ctfont, NULL);
-    CTFontSymbolicTraits traits = CTFontGetSymbolicTraits(ctfont);
-    if (fontDef.weight >= QFont::Bold && !(traits & kCTFontBoldTrait)) {
-         synthesisFlags |= SynthesizedBold;
-    }
-
-    if (fontDef.style != QFont::StyleNormal && !(traits & kCTFontItalicTrait)) {
-        synthesisFlags |= SynthesizedItalic;
-    }
-    transform = CGAffineTransformIdentity;
-    if (fontDef.stretch != 100) {
-        transform = CGAffineTransformMakeScale(float(fontDef.stretch) / float(100), 1);
-    }
-    QByteArray os2Table = getSfntTable(MAKE_TAG('O', 'S', '/', '2'));
-    if (os2Table.size() >= 10)
-        fsType = qFromBigEndian<quint16>(reinterpret_cast<const uchar *>(os2Table.constData() + 8));
-}
-
-QCoreTextFontEngine::~QCoreTextFontEngine()
-{
-    CFRelease(cgFont);
-    CFRelease(ctfont);
-}
-
-bool QCoreTextFontEngine::stringToCMap(const QChar *, int, QGlyphLayout *, int *, QTextEngine::ShaperFlags) const
-{
-    return false;
-}
-
-glyph_metrics_t QCoreTextFontEngine::boundingBox(const QGlyphLayout &glyphs)
-{
-    QFixed w;
-    bool round = fontDef.styleStrategy & QFont::ForceIntegerMetrics;
-
-    for (int i = 0; i < glyphs.numGlyphs; ++i) {
-        w += round ? glyphs.effectiveAdvance(i).round()
-                   : glyphs.effectiveAdvance(i);
-    }
-    return glyph_metrics_t(0, -(ascent()), w - lastRightBearing(glyphs, round), ascent()+descent(), w, 0);
-}
-glyph_metrics_t QCoreTextFontEngine::boundingBox(glyph_t glyph)
-{
-    glyph_metrics_t ret;
-    CGGlyph g = glyph;
-    CGRect rect = CTFontGetBoundingRectsForGlyphs(ctfont, kCTFontHorizontalOrientation, &g, 0, 1);
-    ret.width = QFixed::fromReal(rect.size.width);
-    ret.height = QFixed::fromReal(rect.size.height);
-    ret.x = QFixed::fromReal(rect.origin.x);
-    ret.y = -QFixed::fromReal(rect.origin.y) - ret.height;
-    CGSize advances[1];
-    CTFontGetAdvancesForGlyphs(ctfont, kCTFontHorizontalOrientation, &g, advances, 1);
-    ret.xoff = QFixed::fromReal(advances[0].width);
-    ret.yoff = QFixed::fromReal(advances[0].height);
-
-    if (fontDef.styleStrategy & QFont::ForceIntegerMetrics) {
-        ret.xoff = ret.xoff.round();
-        ret.yoff = ret.yoff.round();
-    }
-
-    return ret;
-}
-
-QFixed QCoreTextFontEngine::ascent() const
-{
-    return (fontDef.styleStrategy & QFont::ForceIntegerMetrics)
-            ? QFixed::fromReal(CTFontGetAscent(ctfont)).round()
-            : QFixed::fromReal(CTFontGetAscent(ctfont));
-}
-QFixed QCoreTextFontEngine::descent() const
-{
-    QFixed d = QFixed::fromReal(CTFontGetDescent(ctfont));
-    if (fontDef.styleStrategy & QFont::ForceIntegerMetrics)
-        d = d.round();
-
-    // subtract a pixel to even out the historical +1 in QFontMetrics::height().
-    // Fix in Qt 5.
-    return d - 1;
-}
-QFixed QCoreTextFontEngine::leading() const
-{
-    return (fontDef.styleStrategy & QFont::ForceIntegerMetrics)
-            ? QFixed::fromReal(CTFontGetLeading(ctfont)).round()
-            : QFixed::fromReal(CTFontGetLeading(ctfont));
-}
-QFixed QCoreTextFontEngine::xHeight() const
-{
-    return (fontDef.styleStrategy & QFont::ForceIntegerMetrics)
-            ? QFixed::fromReal(CTFontGetXHeight(ctfont)).round()
-            : QFixed::fromReal(CTFontGetXHeight(ctfont));
-}
-QFixed QCoreTextFontEngine::averageCharWidth() const
-{
-    // ### Need to implement properly and get the information from the OS/2 Table.
-    return (fontDef.styleStrategy & QFont::ForceIntegerMetrics)
-            ? QFontEngine::averageCharWidth().round()
-            : QFontEngine::averageCharWidth();
-}
-
-qreal QCoreTextFontEngine::maxCharWidth() const
-{
-    // ### Max Help!
-    return 0;
-
-}
-qreal QCoreTextFontEngine::minLeftBearing() const
-{
-    // ### Min Help!
-    return 0;
-
-}
-qreal QCoreTextFontEngine::minRightBearing() const
-{
-    // ### Max Help! (even thought it's right)
-    return 0;
-
-}
-
-void QCoreTextFontEngine::draw(CGContextRef ctx, qreal x, qreal y, const QTextItemInt &ti, int paintDeviceHeight)
-{
-    QVarLengthArray<QFixedPoint> positions;
-    QVarLengthArray<glyph_t> glyphs;
-    QTransform matrix;
-    matrix.translate(x, y);
-    getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
-    if (glyphs.size() == 0)
-        return;
-
-    CGContextSetFontSize(ctx, fontDef.pixelSize);
-
-    CGAffineTransform oldTextMatrix = CGContextGetTextMatrix(ctx);
-
-    CGAffineTransform cgMatrix = CGAffineTransformMake(1, 0, 0, -1, 0, -paintDeviceHeight);
-
-    CGAffineTransformConcat(cgMatrix, oldTextMatrix);
-
-    if (synthesisFlags & QFontEngine::SynthesizedItalic)
-        cgMatrix = CGAffineTransformConcat(cgMatrix, CGAffineTransformMake(1, 0, -tanf(14 * acosf(0) / 90), 1, 0, 0));
-
-    cgMatrix = CGAffineTransformConcat(cgMatrix, transform);
-
-    CGContextSetTextMatrix(ctx, cgMatrix);
-
-    CGContextSetTextDrawingMode(ctx, kCGTextFill);
-
-
-    QVarLengthArray<CGSize> advances(glyphs.size());
-    QVarLengthArray<CGGlyph> cgGlyphs(glyphs.size());
-
-    for (int i = 0; i < glyphs.size() - 1; ++i) {
-        advances[i].width = (positions[i + 1].x - positions[i].x).toReal();
-        advances[i].height = (positions[i + 1].y - positions[i].y).toReal();
-        cgGlyphs[i] = glyphs[i];
-    }
-    advances[glyphs.size() - 1].width = 0;
-    advances[glyphs.size() - 1].height = 0;
-    cgGlyphs[glyphs.size() - 1] = glyphs[glyphs.size() - 1];
-
-    CGContextSetFont(ctx, cgFont);
-    //NSLog(@"Font inDraw %@  ctfont %@", CGFontCopyFullName(cgFont), CTFontCopyFamilyName(ctfont));
-
-    CGContextSetTextPosition(ctx, positions[0].x.toReal(), positions[0].y.toReal());
-
-    CGContextShowGlyphsWithAdvances(ctx, cgGlyphs.data(), advances.data(), glyphs.size());
-
-    if (synthesisFlags & QFontEngine::SynthesizedBold) {
-        CGContextSetTextPosition(ctx, positions[0].x.toReal() + 0.5 * lineThickness().toReal(),
-                                 positions[0].y.toReal());
-
-        CGContextShowGlyphsWithAdvances(ctx, cgGlyphs.data(), advances.data(), glyphs.size());
-    }
-
-    CGContextSetTextMatrix(ctx, oldTextMatrix);
-}
-
-struct ConvertPathInfo
-{
-    ConvertPathInfo(QPainterPath *newPath, const QPointF &newPos) : path(newPath), pos(newPos) {}
-    QPainterPath *path;
-    QPointF pos;
-};
-
-static void convertCGPathToQPainterPath(void *info, const CGPathElement *element)
-{
-    ConvertPathInfo *myInfo = static_cast<ConvertPathInfo *>(info);
-    switch(element->type) {
-        case kCGPathElementMoveToPoint:
-            myInfo->path->moveTo(element->points[0].x + myInfo->pos.x(),
-                                 element->points[0].y + myInfo->pos.y());
-            break;
-        case kCGPathElementAddLineToPoint:
-            myInfo->path->lineTo(element->points[0].x + myInfo->pos.x(),
-                                 element->points[0].y + myInfo->pos.y());
-            break;
-        case kCGPathElementAddQuadCurveToPoint:
-            myInfo->path->quadTo(element->points[0].x + myInfo->pos.x(),
-                                 element->points[0].y + myInfo->pos.y(),
-                                 element->points[1].x + myInfo->pos.x(),
-                                 element->points[1].y + myInfo->pos.y());
-            break;
-        case kCGPathElementAddCurveToPoint:
-            myInfo->path->cubicTo(element->points[0].x + myInfo->pos.x(),
-                                  element->points[0].y + myInfo->pos.y(),
-                                  element->points[1].x + myInfo->pos.x(),
-                                  element->points[1].y + myInfo->pos.y(),
-                                  element->points[2].x + myInfo->pos.x(),
-                                  element->points[2].y + myInfo->pos.y());
-            break;
-        case kCGPathElementCloseSubpath:
-            myInfo->path->closeSubpath();
-            break;
-        default:
-            qDebug() << "Unhandled path transform type: " << element->type;
-    }
-
-}
-
-void QCoreTextFontEngine::addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nGlyphs,
-                                          QPainterPath *path, QTextItem::RenderFlags)
-{
-
-    CGAffineTransform cgMatrix = CGAffineTransformIdentity;
-    cgMatrix = CGAffineTransformScale(cgMatrix, 1, -1);
-
-    if (synthesisFlags & QFontEngine::SynthesizedItalic)
-        cgMatrix = CGAffineTransformConcat(cgMatrix, CGAffineTransformMake(1, 0, -tanf(14 * acosf(0) / 90), 1, 0, 0));
-
-
-    for (int i = 0; i < nGlyphs; ++i) {
-        QCFType<CGPathRef> cgpath = CTFontCreatePathForGlyph(ctfont, glyphs[i], &cgMatrix);
-        ConvertPathInfo info(path, positions[i].toPointF());
-        CGPathApply(cgpath, &info, convertCGPathToQPainterPath);
-    }
-}
-
-QFont QCoreTextFontEngine::createExplicitFont() const
-{
-    QString familyName = QCFString::toQString(CTFontCopyFamilyName(ctfont));
-    return createExplicitFontWithName(familyName);
-}
-
-QImage QCoreTextFontEngine::imageForGlyph(glyph_t glyph, QFixed subPixelPosition, int /*margin*/, bool aa)
-{
-    const glyph_metrics_t br = boundingBox(glyph);
-    QImage im(qRound(br.width)+2, qRound(br.height)+2, QImage::Format_RGB32);
-    im.fill(0);
-
-    CGColorSpaceRef colorspace = QCoreGraphicsPaintEngine::macGenericColorSpace();
-    uint cgflags = kCGImageAlphaNoneSkipFirst;
-#ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version
-    cgflags |= kCGBitmapByteOrder32Host;
-#endif
-    CGContextRef ctx = CGBitmapContextCreate(im.bits(), im.width(), im.height(),
-                                             8, im.bytesPerLine(), colorspace,
-                                             cgflags);
-    CGContextSetFontSize(ctx, fontDef.pixelSize);
-    CGContextSetShouldAntialias(ctx, aa ||
-                                (fontDef.pointSize > qt_antialiasing_threshold
-                                 && !(fontDef.styleStrategy & QFont::NoAntialias)));
-    CGContextSetShouldSmoothFonts(ctx, aa);
-    CGAffineTransform oldTextMatrix = CGContextGetTextMatrix(ctx);
-    CGAffineTransform cgMatrix = CGAffineTransformMake(1, 0, 0, 1, 0, 0);
-
-    CGAffineTransformConcat(cgMatrix, oldTextMatrix);
-
-    if (synthesisFlags & QFontEngine::SynthesizedItalic)
-        cgMatrix = CGAffineTransformConcat(cgMatrix, CGAffineTransformMake(1, 0, tanf(14 * acosf(0) / 90), 1, 0, 0));
-
-    cgMatrix = CGAffineTransformConcat(cgMatrix, transform);
-
-    CGContextSetTextMatrix(ctx, cgMatrix);
-    CGContextSetRGBFillColor(ctx, 1, 1, 1, 1);
-    CGContextSetTextDrawingMode(ctx, kCGTextFill);
-
-    CGContextSetFont(ctx, cgFont);
-
-    qreal pos_x = -br.x.toReal() + subPixelPosition.toReal();
-    qreal pos_y = im.height() + br.y.toReal() - 1;
-    CGContextSetTextPosition(ctx, pos_x, pos_y);
-
-    CGSize advance;
-    advance.width = 0;
-    advance.height = 0;
-    CGGlyph cgGlyph = glyph;
-    CGContextShowGlyphsWithAdvances(ctx, &cgGlyph, &advance, 1);
-
-    if (synthesisFlags & QFontEngine::SynthesizedBold) {
-        CGContextSetTextPosition(ctx, pos_x + 0.5 * lineThickness().toReal(), pos_y);
-        CGContextShowGlyphsWithAdvances(ctx, &cgGlyph, &advance, 1);
-    }
-
-    CGContextRelease(ctx);
-
-    return im;
-}
-
-QImage QCoreTextFontEngine::alphaMapForGlyph(glyph_t glyph, QFixed subPixelPosition)
-{
-    QImage im = imageForGlyph(glyph, subPixelPosition, 0, false);
-
-    QImage indexed(im.width(), im.height(), QImage::Format_Indexed8);
-    QVector<QRgb> colors(256);
-    for (int i=0; i<256; ++i)
-        colors[i] = qRgba(0, 0, 0, i);
-    indexed.setColorTable(colors);
-
-    for (int y=0; y<im.height(); ++y) {
-        uint *src = (uint*) im.scanLine(y);
-        uchar *dst = indexed.scanLine(y);
-        for (int x=0; x<im.width(); ++x) {
-            *dst = qGray(*src);
-            ++dst;
-            ++src;
-        }
-    }
-
-    return indexed;
-}
-
-QImage QCoreTextFontEngine::alphaRGBMapForGlyph(glyph_t glyph, QFixed subPixelPosition, int margin, const QTransform &x)
-{
-    if (x.type() >= QTransform::TxScale)
-        return QFontEngine::alphaRGBMapForGlyph(glyph, subPixelPosition, margin, x);
-
-    QImage im = imageForGlyph(glyph, subPixelPosition, margin, true);
-    qmacfontengine_gamma_correct(&im);
-    return im;
-}
-
-void QCoreTextFontEngine::recalcAdvances(int numGlyphs, QGlyphLayout *glyphs, QTextEngine::ShaperFlags flags) const
-{
-    Q_ASSERT(false);
-    Q_UNUSED(numGlyphs);
-    Q_UNUSED(glyphs);
-    Q_UNUSED(flags);
-}
-
-QFontEngine::FaceId QCoreTextFontEngine::faceId() const
-{
-    return QFontEngine::FaceId();
-}
-
-bool QCoreTextFontEngine::canRender(const QChar *string, int len)
-{
-    QCFType<CTFontRef> retFont = CTFontCreateForString(ctfont,
-                  QCFType<CFStringRef>(CFStringCreateWithCharactersNoCopy(0,
-                                                              reinterpret_cast<const UniChar *>(string),
-                                                                          len, kCFAllocatorNull)),
-                          CFRangeMake(0, len));
-    return retFont != 0;
-    return false;
-}
-
- bool QCoreTextFontEngine::getSfntTableData(uint tag, uchar *buffer, uint *length) const
- {
-     QCFType<CFDataRef> table = CTFontCopyTable(ctfont, tag, 0);
-     if (!table || !length)
-         return false;
-     CFIndex tableLength = CFDataGetLength(table);
-     int availableLength = *length;
-     *length = tableLength;
-     if (buffer) {
-         if (tableLength > availableLength)
-             return false;
-         CFDataGetBytes(table, CFRangeMake(0, tableLength), buffer);
-     }
-     return true;
- }
-
-void QCoreTextFontEngine::getUnscaledGlyph(glyph_t, QPainterPath *, glyph_metrics_t *)
-{
-    // ###
-}
-
-#endif // MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
-
 #ifndef QT_MAC_USE_COCOA
 QFontEngineMacMulti::QFontEngineMacMulti(const ATSFontFamilyRef &atsFamily, const ATSFontRef &atsFontRef, const QFontDef &fontDef, bool kerning)
     : QFontEngineMulti(0)
@@ -1726,7 +1037,7 @@ QImage QFontEngineMac::alphaRGBMapForGlyph(glyph_t glyph, QFixed, int margin, co
         im = im.transformed(t);
     }
 
-    qmacfontengine_gamma_correct(&im);
+    qGamma_correct_back_to_linear_cs(&im);
 
     return im;
 }
diff --git a/src/gui/text/qfontengine_mac_p.h b/src/gui/text/qfontengine_mac_p.h
new file mode 100644
index 0000000..5577c76
--- /dev/null
+++ b/src/gui/text/qfontengine_mac_p.h
@@ -0,0 +1,167 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** 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 Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFONTENGINE_MAC_P_H
+#define QFONTENGINE_MAC_P_H
+
+#include <private/qfontengine_p.h>
+
+#ifndef QT_MAC_USE_COCOA
+class QFontEngineMacMulti;
+class QFontEngineMac : public QFontEngine
+{
+    friend class QFontEngineMacMulti;
+public:
+    QFontEngineMac(ATSUStyle baseStyle, ATSUFontID fontID, const QFontDef &def, QFontEngineMacMulti *multiEngine = 0);
+    virtual ~QFontEngineMac();
+
+    virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *numGlyphs, QTextEngine::ShaperFlags flags) const;
+    virtual void recalcAdvances(QGlyphLayout *, QTextEngine::ShaperFlags) const;
+
+    virtual glyph_metrics_t boundingBox(const QGlyphLayout &glyphs);
+    virtual glyph_metrics_t boundingBox(glyph_t glyph);
+
+    virtual QFixed ascent() const;
+    virtual QFixed descent() const;
+    virtual QFixed leading() const;
+    virtual QFixed xHeight() const;
+    virtual qreal maxCharWidth() const;
+    virtual QFixed averageCharWidth() const;
+
+    virtual QFont createExplicitFont() const;
+
+    virtual void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int numGlyphs,
+                                 QPainterPath *path, QTextItem::RenderFlags);
+
+    virtual const char *name() const { return "QFontEngineMac"; }
+
+    virtual bool canRender(const QChar *string, int len);
+
+    virtual int synthesized() const { return synthesisFlags; }
+
+    virtual Type type() const { return QFontEngine::Mac; }
+
+    void draw(CGContextRef ctx, qreal x, qreal y, const QTextItemInt &ti, int paintDeviceHeight);
+
+    virtual FaceId faceId() const;
+    virtual QByteArray getSfntTable(uint tag) const;
+    virtual Properties properties() const;
+    virtual void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics);
+    virtual QImage alphaMapForGlyph(glyph_t);
+    virtual QImage alphaRGBMapForGlyph(glyph_t, QFixed subPixelPosition, int margin, const QTransform &t);
+
+private:
+    QImage imageForGlyph(glyph_t glyph, int margin, bool colorful);
+
+    ATSUFontID fontID;
+    QCFType<CGFontRef> cgFont;
+    ATSUStyle style;
+    int synthesisFlags;
+    mutable QGlyphLayout kashidaGlyph;
+    QFontEngineMacMulti *multiEngine;
+    mutable const unsigned char *cmap;
+    mutable bool symbolCMap;
+    mutable QByteArray cmapTable;
+    CGAffineTransform transform;
+    QFixed m_ascent;
+    QFixed m_descent;
+    QFixed m_leading;
+    qreal m_maxCharWidth;
+    QFixed m_xHeight;
+    QFixed m_averageCharWidth;
+};
+
+class QFontEngineMacMulti : public QFontEngineMulti
+{
+    friend class QFontEngineMac;
+public:
+    // internal
+    struct ShaperItem
+    {
+        inline ShaperItem() : string(0), from(0), length(0),
+        log_clusters(0), charAttributes(0) {}
+
+        const QChar *string;
+        int from;
+        int length;
+        QGlyphLayout glyphs;
+        unsigned short *log_clusters;
+        const HB_CharAttributes *charAttributes;
+        QTextEngine::ShaperFlags flags;
+    };
+
+    QFontEngineMacMulti(const ATSFontFamilyRef &atsFamily, const ATSFontRef &atsFontRef, const QFontDef &fontDef, bool kerning);
+    virtual ~QFontEngineMacMulti();
+
+    virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const;
+    bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags,
+                      unsigned short *logClusters, const HB_CharAttributes *charAttributes) const;
+
+    virtual void recalcAdvances(QGlyphLayout *, QTextEngine::ShaperFlags) const;
+    virtual void doKerning(QGlyphLayout *, QTextEngine::ShaperFlags) const;
+
+    virtual const char *name() const { return "ATSUI"; }
+
+    virtual bool canRender(const QChar *string, int len);
+
+    inline ATSUFontID macFontID() const { return fontID; }
+
+protected:
+    virtual void loadEngine(int at);
+
+private:
+    inline const QFontEngineMac *engineAt(int i) const
+    { return static_cast<const QFontEngineMac *>(engines.at(i)); }
+
+    bool stringToCMapInternal(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags, ShaperItem *item) const;
+
+    int fontIndexForFontID(ATSUFontID id) const;
+
+    ATSUFontID fontID;
+    uint kerning : 1;
+
+    mutable ATSUTextLayout textLayout;
+    mutable ATSUStyle style;
+    CGAffineTransform transform;
+};
+#endif //!QT_MAC_USE_COCOA
+
+#endif // QFONTENGINE_MAC_P_H
diff --git a/src/gui/text/qfontengine_p.h b/src/gui/text/qfontengine_p.h
index be9f48d..d528c69 100644
--- a/src/gui/text/qfontengine_p.h
+++ b/src/gui/text/qfontengine_p.h
@@ -433,216 +433,6 @@ protected:
     QVector<QFontEngine *> engines;
 };
 
-#if defined(Q_WS_MAC)
-
-struct QCharAttributes;
-class QFontEngineMacMulti;
-#  if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
-class QCoreTextFontEngineMulti;
-class QCoreTextFontEngine : public QFontEngine
-{
-public:
-    QCoreTextFontEngine(CTFontRef font, const QFontDef &def,
-                        QCoreTextFontEngineMulti *multiEngine = 0);
-    ~QCoreTextFontEngine();
-    virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const;
-    virtual void recalcAdvances(int , QGlyphLayout *, QTextEngine::ShaperFlags) const;
-
-    virtual glyph_metrics_t boundingBox(const QGlyphLayout &glyphs);
-    virtual glyph_metrics_t boundingBox(glyph_t glyph);
-
-    virtual QFixed ascent() const;
-    virtual QFixed descent() const;
-    virtual QFixed leading() const;
-    virtual QFixed xHeight() const;
-    virtual qreal maxCharWidth() const;
-    virtual QFixed averageCharWidth() const;
-
-    virtual void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int numGlyphs,
-                                 QPainterPath *path, QTextItem::RenderFlags);
-
-    virtual const char *name() const { return "QCoreTextFontEngine"; }
-
-    virtual bool canRender(const QChar *string, int len);
-
-    virtual int synthesized() const { return synthesisFlags; }
-    virtual bool supportsSubPixelPositions() const { return true; }
-
-    virtual Type type() const { return QFontEngine::Mac; }
-
-    void draw(CGContextRef ctx, qreal x, qreal y, const QTextItemInt &ti, int paintDeviceHeight);
-
-    virtual FaceId faceId() const;
-    virtual bool getSfntTableData(uint /*tag*/, uchar * /*buffer*/, uint * /*length*/) const;
-    virtual void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics);
-    virtual QImage alphaMapForGlyph(glyph_t, QFixed subPixelPosition);
-    virtual QImage alphaRGBMapForGlyph(glyph_t, QFixed subPixelPosition, int margin, const QTransform &t);
-    virtual qreal minRightBearing() const;
-    virtual qreal minLeftBearing() const;
-    virtual QFont createExplicitFont() const;
-
-private:
-    QImage imageForGlyph(glyph_t glyph, QFixed subPixelPosition, int margin, bool colorful);
-    CTFontRef ctfont;
-    CGFontRef cgFont;
-    QCoreTextFontEngineMulti *parentEngine;
-    int synthesisFlags;
-    CGAffineTransform transform;
-    friend class QCoreTextFontEngineMulti;
-};
-
-class QCoreTextFontEngineMulti : public QFontEngineMulti
-{
-public:
-    QCoreTextFontEngineMulti(const QCFString &name, const QFontDef &fontDef, bool kerning);
-    ~QCoreTextFontEngineMulti();
-
-    virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs,
-                              QTextEngine::ShaperFlags flags) const;
-    bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs,
-                      QTextEngine::ShaperFlags flags,
-                      unsigned short *logClusters, const HB_CharAttributes *charAttributes) const;
-
-
-    virtual void recalcAdvances(int , QGlyphLayout *, QTextEngine::ShaperFlags) const;
-    virtual void doKerning(int , QGlyphLayout *, QTextEngine::ShaperFlags) const;
-
-    virtual const char *name() const { return "CoreText"; }
-protected:
-    virtual void loadEngine(int at);
-
-private:
-    inline const QCoreTextFontEngine *engineAt(int i) const
-    { return static_cast<const QCoreTextFontEngine *>(engines.at(i)); }
-
-    uint fontIndexForFont(CTFontRef id) const;
-    CTFontRef ctfont;
-    mutable QCFType<CFMutableDictionaryRef> attributeDict;
-    CGAffineTransform transform;
-    friend class QFontDialogPrivate;
-};
-#  endif //MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
-
-#ifndef QT_MAC_USE_COCOA
-class QFontEngineMac : public QFontEngine
-{
-    friend class QFontEngineMacMulti;
-public:
-    QFontEngineMac(ATSUStyle baseStyle, ATSUFontID fontID, const QFontDef &def, QFontEngineMacMulti *multiEngine = 0);
-    virtual ~QFontEngineMac();
-
-    virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *numGlyphs, QTextEngine::ShaperFlags flags) const;
-    virtual void recalcAdvances(QGlyphLayout *, QTextEngine::ShaperFlags) const;
-
-    virtual glyph_metrics_t boundingBox(const QGlyphLayout &glyphs);
-    virtual glyph_metrics_t boundingBox(glyph_t glyph);
-
-    virtual QFixed ascent() const;
-    virtual QFixed descent() const;
-    virtual QFixed leading() const;
-    virtual QFixed xHeight() const;
-    virtual qreal maxCharWidth() const;
-    virtual QFixed averageCharWidth() const;
-
-    virtual QFont createExplicitFont() const;
-
-    virtual void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int numGlyphs,
-                                 QPainterPath *path, QTextItem::RenderFlags);
-
-    virtual const char *name() const { return "QFontEngineMac"; }
-
-    virtual bool canRender(const QChar *string, int len);
-
-    virtual int synthesized() const { return synthesisFlags; }
-
-    virtual Type type() const { return QFontEngine::Mac; }
-
-    void draw(CGContextRef ctx, qreal x, qreal y, const QTextItemInt &ti, int paintDeviceHeight);
-
-    virtual FaceId faceId() const;
-    virtual QByteArray getSfntTable(uint tag) const;
-    virtual Properties properties() const;
-    virtual void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics);
-    virtual QImage alphaMapForGlyph(glyph_t);
-    virtual QImage alphaRGBMapForGlyph(glyph_t, QFixed subPixelPosition, int margin, const QTransform &t);
-
-private:
-    QImage imageForGlyph(glyph_t glyph, int margin, bool colorful);
-
-    ATSUFontID fontID;
-    QCFType<CGFontRef> cgFont;
-    ATSUStyle style;
-    int synthesisFlags;
-    mutable QGlyphLayout kashidaGlyph;
-    QFontEngineMacMulti *multiEngine;
-    mutable const unsigned char *cmap;
-    mutable bool symbolCMap;
-    mutable QByteArray cmapTable;
-    CGAffineTransform transform;
-    QFixed m_ascent;
-    QFixed m_descent;
-    QFixed m_leading;
-    qreal m_maxCharWidth;
-    QFixed m_xHeight;
-    QFixed m_averageCharWidth;
-};
-
-class QFontEngineMacMulti : public QFontEngineMulti
-{
-    friend class QFontEngineMac;
-public:
-    // internal
-    struct ShaperItem
-    {
-        inline ShaperItem() : string(0), from(0), length(0),
-        log_clusters(0), charAttributes(0) {}
-
-        const QChar *string;
-        int from;
-        int length;
-        QGlyphLayout glyphs;
-        unsigned short *log_clusters;
-        const HB_CharAttributes *charAttributes;
-        QTextEngine::ShaperFlags flags;
-    };
-
-    QFontEngineMacMulti(const ATSFontFamilyRef &atsFamily, const ATSFontRef &atsFontRef, const QFontDef &fontDef, bool kerning);
-    virtual ~QFontEngineMacMulti();
-
-    virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const;
-    bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags,
-                      unsigned short *logClusters, const HB_CharAttributes *charAttributes) const;
-
-    virtual void recalcAdvances(QGlyphLayout *, QTextEngine::ShaperFlags) const;
-    virtual void doKerning(QGlyphLayout *, QTextEngine::ShaperFlags) const;
-
-    virtual const char *name() const { return "ATSUI"; }
-
-    virtual bool canRender(const QChar *string, int len);
-
-    inline ATSUFontID macFontID() const { return fontID; }
-
-protected:
-    virtual void loadEngine(int at);
-
-private:
-    inline const QFontEngineMac *engineAt(int i) const
-    { return static_cast<const QFontEngineMac *>(engines.at(i)); }
-
-    bool stringToCMapInternal(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags, ShaperItem *item) const;
-
-    int fontIndexForFontID(ATSUFontID id) const;
-
-    ATSUFontID fontID;
-    uint kerning : 1;
-
-    mutable ATSUTextLayout textLayout;
-    mutable ATSUStyle style;
-    CGAffineTransform transform;
-};
-#endif //!QT_MAC_USE_COCOA
-#endif
-
 class QTestFontEngine : public QFontEngineBox
 {
 public:
diff --git a/src/gui/text/qplatformfontdatabase_qpa.cpp b/src/gui/text/qplatformfontdatabase_qpa.cpp
index 370c921..d6dff41 100644
--- a/src/gui/text/qplatformfontdatabase_qpa.cpp
+++ b/src/gui/text/qplatformfontdatabase_qpa.cpp
@@ -65,9 +65,9 @@ void QPlatformFontDatabase::registerQPF2Font(const QByteArray &dataArray, void *
         QByteArray writingSystemBits = QFontEngineQPA::extractHeaderField(data, QFontEngineQPA::Tag_WritingSystems).toByteArray();
 
         if (!fontName.isEmpty() && pixelSize) {
-            int fontWeight = 50;
+            QFont::Weight fontWeight = QFont::Normal;
             if (weight.type() == QVariant::Int || weight.type() == QVariant::UInt)
-                fontWeight = weight.toInt();
+                fontWeight = QFont::Weight(weight.toInt());
 
             QFont::Style fontStyle = static_cast<QFont::Style>(style.toInt());
 
@@ -80,16 +80,16 @@ void QPlatformFontDatabase::registerQPF2Font(const QByteArray &dataArray, void *
                     currentByte >>= 1;
                 }
             }
-
-            registerFont(fontName,QString(),fontWeight,fontStyle,100,true,false,pixelSize,writingSystems,handle);
+            QFont::Stretch stretch = QFont::Unstretched;
+            registerFont(fontName,QString(),fontWeight,fontStyle,stretch,true,false,pixelSize,writingSystems,handle);
         }
     } else {
         qDebug() << "header verification of QPF2 font failed. maybe it is corrupt?";
     }
 }
 
-void QPlatformFontDatabase::registerFont(const QString &familyname, const QString &foundryname, int weight,
-                                         QFont::Style style, int stretch, bool antialiased, bool scalable, int pixelSize,
+void QPlatformFontDatabase::registerFont(const QString &familyname, const QString &foundryname, QFont::Weight weight,
+                                         QFont::Style style, QFont::Stretch stretch, bool antialiased, bool scalable, int pixelSize,
                                          const QSupportedWritingSystems &writingSystems, void *usrPtr)
 {
     if (scalable)
@@ -165,6 +165,23 @@ bool QSupportedWritingSystems::supported(QFontDatabase::WritingSystem writingSys
     return d->vector.at(writingSystem);
 }
 
+/*!
+    \class QSupportedWritingSystems
+    \brief The QSupportedWritingSystems class is used when registering fonts with the internal Qt
+    fontdatabase
+    \ingroup painting
+
+    Its to provide an easy to use interface for indicating what writing systems a specific font
+    supports.
+
+*/
+
+/*!
+  This function is called once at startup by Qts internal fontdatabase. Reimplement this function
+  in a subclass for a convenient place to initialise the internal fontdatabase.
+
+  The default implementation looks in the fontDir() location and registers all qpf2 fonts.
+*/
 void QPlatformFontDatabase::populateFontDatabase()
 {
     QString fontpath = fontDir();
@@ -188,6 +205,9 @@ void QPlatformFontDatabase::populateFontDatabase()
     }
 }
 
+/*!
+
+*/
 QFontEngine *QPlatformFontDatabase::fontEngine(const QFontDef &fontDef, QUnicodeTables::Script script, void *handle)
 {
     Q_UNUSED(script);
@@ -198,6 +218,9 @@ QFontEngine *QPlatformFontDatabase::fontEngine(const QFontDef &fontDef, QUnicode
     return engine;
 }
 
+/*!
+
+*/
 QStringList QPlatformFontDatabase::fallbacksForFamily(const QString family, const QFont::Style &style, const QUnicodeTables::Script &script) const
 {
     Q_UNUSED(family);
@@ -219,12 +242,18 @@ QStringList QPlatformFontDatabase::addApplicationFont(const QByteArray &fontData
     return QStringList();
 }
 
+/*!
+
+*/
 void QPlatformFontDatabase::releaseHandle(void *handle)
 {
     QByteArray *fileDataPtr = static_cast<QByteArray *>(handle);
     delete fileDataPtr;
 }
 
+/*!
+
+*/
 QString QPlatformFontDatabase::fontDir() const
 {
     QString fontpath = QString::fromLocal8Bit(qgetenv("QT_QPA_FONTDIR"));
@@ -238,4 +267,24 @@ QString QPlatformFontDatabase::fontDir() const
     return fontpath;
 }
 
+/*!
+    \class QPlatformFontDatabase
+    \brief The QPlatformFontDatabase makes it possible to customize how fonts are picked up, and
+    and how they are rendered
+
+    \ingroup painting
+
+    QPlatformFontDatabase is the superclass which is intended to let platform implementations use
+    native font handling.
+
+    Qt has its internal fontdatabase which it uses to pick up available fonts. To be able
+    to populate this database subclass this class, and reimplement populateFontDatabase().
+
+    Use the function registerFont to populate the internal fontdatabase.
+
+    Sometimes a specified font does not have the required glyphs, then the fallbackForFamily
+    function is called.
+
+    \sa QSupportedWritingSystems
+*/
 QT_END_NAMESPACE
diff --git a/src/gui/text/qplatformfontdatabase_qpa.h b/src/gui/text/qplatformfontdatabase_qpa.h
index 75b0a18..aa465ab 100644
--- a/src/gui/text/qplatformfontdatabase_qpa.h
+++ b/src/gui/text/qplatformfontdatabase_qpa.h
@@ -96,8 +96,8 @@ public:
 
     //callback
     static void registerQPF2Font(const QByteArray &dataArray, void *handle);
-    static void registerFont(const QString &familyname, const QString &foundryname, int weight,
-                             QFont::Style style, int stetch, bool antialiased, bool scalable, int pixelSize,
+    static void registerFont(const QString &familyname, const QString &foundryname, QFont::Weight weight,
+                             QFont::Style style, QFont::Stretch stretch, bool antialiased, bool scalable, int pixelSize,
                              const QSupportedWritingSystems &writingSystems, void *handle);
 };
 
diff --git a/src/gui/text/qtextengine_mac.cpp b/src/gui/text/qtextengine_mac.cpp
index 342fb5e..7002851 100644
--- a/src/gui/text/qtextengine_mac.cpp
+++ b/src/gui/text/qtextengine_mac.cpp
@@ -41,6 +41,9 @@
 
 #include "qtextengine_p.h"
 
+#include <private/qfontengine_coretext_p.h>
+#include <private/qfontengine_mac_p.h>
+
 QT_BEGIN_NAMESPACE
 
 // set the glyph attributes heuristically. Assumes a 1 to 1 relationship between chars and glyphs
diff --git a/src/gui/text/text.pri b/src/gui/text/text.pri
index 0040b54..daafdd9 100644
--- a/src/gui/text/text.pri
+++ b/src/gui/text/text.pri
@@ -93,9 +93,15 @@ unix:x11 {
 }
 
 !embedded:!qpa:!x11:mac {
+        HEADERS += \
+                text/qfontengine_mac_p.h
+        OBJECTIVE_HEADERS += \
+                text/qfontengine_coretext_p.h
 	SOURCES += \
-		text/qfont_mac.cpp
-        OBJECTIVE_SOURCES += text/qfontengine_mac.mm
+                text/qfont_mac.cpp
+        OBJECTIVE_SOURCES += \
+                text/qfontengine_coretext.mm \
+                text/qfontengine_mac.mm
 }
 
 embedded {
diff --git a/src/gui/util/qdesktopservices_mac.cpp b/src/gui/util/qdesktopservices_mac.cpp
index 6c5ff18..05a1789 100644
--- a/src/gui/util/qdesktopservices_mac.cpp
+++ b/src/gui/util/qdesktopservices_mac.cpp
@@ -49,6 +49,8 @@
 #include <private/qcore_mac_p.h>
 #include <qcoreapplication.h>
 
+#include <ApplicationServices/ApplicationServices.h>
+
 QT_BEGIN_NAMESPACE
 
 /*