Make QWindowSystemInterface part of QPA API

As discussed on mailing list and QtCS 2012.

Any file starting with qwindowsystem is now marked as
QPA API.

This change drops _qpa from the filenames and adds gui-private
where required for the code to compile. This change is backward
compatible otherwise and compat headers are created for
the old inclusion headers.

Change-Id: I72ea0f394dee74f46e614fcf11ab5500ac9fef2a
Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>

1 files changed, 341 insertions, 0 deletions

diff --git a/src/gui/kernel/qwindowsysteminterface_p.h b/src/gui/kernel/qwindowsysteminterface_p.h
new file mode 100644
index 0000000000..26f4cd68bb
--- /dev/null
+++ b/src/gui/kernel/qwindowsysteminterface_p.h
@@ -0,0 +1,341 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef QWINDOWSYSTEMINTERFACE_P_H
+#define QWINDOWSYSTEMINTERFACE_P_H
+
+#include "qwindowsysteminterface.h"
+
+#include <QElapsedTimer>
+#include <QPointer>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QWindowSystemInterfacePrivate {
+public:
+    enum EventType {
+        Close,
+        GeometryChange,
+        Enter,
+        Leave,
+        ActivatedWindow,
+        WindowStateChanged,
+        Mouse,
+        FrameStrutMouse,
+        Wheel,
+        Key,
+        Touch,
+        ScreenOrientation,
+        ScreenGeometry,
+        ScreenAvailableGeometry,
+        ScreenLogicalDotsPerInch,
+        ScreenRefreshRate,
+        ThemeChange,
+        Expose,
+        FileOpen,
+        Tablet,
+        TabletEnterProximity,
+        TabletLeaveProximity
+    };
+
+    class WindowSystemEvent {
+    public:
+        explicit WindowSystemEvent(EventType t)
+            : type(t), synthetic(false) { }
+        virtual ~WindowSystemEvent() { }
+        EventType type;
+        bool synthetic;
+    };
+
+    class CloseEvent : public WindowSystemEvent {
+    public:
+        explicit CloseEvent(QWindow *w)
+            : WindowSystemEvent(Close), window(w) { }
+        QPointer<QWindow> window;
+    };
+
+    class GeometryChangeEvent : public WindowSystemEvent {
+    public:
+        GeometryChangeEvent(QWindow *tlw, const QRect &newGeometry)
+            : WindowSystemEvent(GeometryChange), tlw(tlw), newGeometry(newGeometry)
+        { }
+        QPointer<QWindow> tlw;
+        QRect newGeometry;
+    };
+
+    class EnterEvent : public WindowSystemEvent {
+    public:
+        explicit EnterEvent(QWindow *enter)
+            : WindowSystemEvent(Enter), enter(enter)
+        { }
+        QPointer<QWindow> enter;
+    };
+
+    class LeaveEvent : public WindowSystemEvent {
+    public:
+        explicit LeaveEvent(QWindow *leave)
+            : WindowSystemEvent(Leave), leave(leave)
+        { }
+        QPointer<QWindow> leave;
+    };
+
+    class ActivatedWindowEvent : public WindowSystemEvent {
+    public:
+        explicit ActivatedWindowEvent(QWindow *activatedWindow)
+            : WindowSystemEvent(ActivatedWindow), activated(activatedWindow)
+        { }
+        QPointer<QWindow> activated;
+    };
+
+    class WindowStateChangedEvent : public WindowSystemEvent {
+    public:
+        WindowStateChangedEvent(QWindow *_window, Qt::WindowState _newState)
+            : WindowSystemEvent(WindowStateChanged), window(_window), newState(_newState)
+        { }
+
+        QPointer<QWindow> window;
+        Qt::WindowState newState;
+    };
+
+    class UserEvent : public WindowSystemEvent {
+    public:
+        UserEvent(QWindow * w, ulong time, EventType t)
+            : WindowSystemEvent(t), window(w), nullWindow(w == 0), timestamp(time) { }
+        QPointer<QWindow> window;
+        bool nullWindow;
+        unsigned long timestamp;
+    };
+
+    class InputEvent: public UserEvent {
+    public:
+        InputEvent(QWindow * w, ulong time, EventType t, Qt::KeyboardModifiers mods)
+            : UserEvent(w, time, t), modifiers(mods) {}
+        Qt::KeyboardModifiers modifiers;
+    };
+
+    class MouseEvent : public InputEvent {
+    public:
+        MouseEvent(QWindow * w, ulong time, const QPointF & local, const QPointF & global,
+                   Qt::MouseButtons b, Qt::KeyboardModifiers mods)
+            : InputEvent(w, time, Mouse, mods), localPos(local), globalPos(global), buttons(b) { }
+        MouseEvent(QWindow * w, ulong time, EventType t, const QPointF & local, const QPointF & global,
+                   Qt::MouseButtons b, Qt::KeyboardModifiers mods)
+            : InputEvent(w, time, t, mods), localPos(local), globalPos(global), buttons(b) { }
+        QPointF localPos;
+        QPointF globalPos;
+        Qt::MouseButtons buttons;
+    };
+
+    class WheelEvent : public InputEvent {
+    public:
+        WheelEvent(QWindow *w, ulong time, const QPointF & local, const QPointF & global, QPoint pixelD, QPoint angleD, int qt4D, Qt::Orientation qt4O,
+                   Qt::KeyboardModifiers mods)
+            : InputEvent(w, time, Wheel, mods), pixelDelta(pixelD), angleDelta(angleD), qt4Delta(qt4D), qt4Orientation(qt4O), localPos(local), globalPos(global) { }
+        QPoint pixelDelta;
+        QPoint angleDelta;
+        int qt4Delta;
+        Qt::Orientation qt4Orientation;
+        QPointF localPos;
+        QPointF globalPos;
+    };
+
+    class KeyEvent : public InputEvent {
+    public:
+        KeyEvent(QWindow *w, ulong time, QEvent::Type t, int k, Qt::KeyboardModifiers mods, const QString & text = QString(), bool autorep = false, ushort count = 1)
+            :InputEvent(w, time, Key, mods), key(k), unicode(text), repeat(autorep),
+             repeatCount(count), keyType(t),
+             nativeScanCode(0), nativeVirtualKey(0), nativeModifiers(0) { }
+        KeyEvent(QWindow *w, ulong time, QEvent::Type t, int k, Qt::KeyboardModifiers mods,
+                 quint32 nativeSC, quint32 nativeVK, quint32 nativeMods,
+                 const QString & text = QString(), bool autorep = false, ushort count = 1)
+            :InputEvent(w, time, Key, mods), key(k), unicode(text), repeat(autorep),
+             repeatCount(count), keyType(t),
+             nativeScanCode(nativeSC), nativeVirtualKey(nativeVK), nativeModifiers(nativeMods) { }
+        int key;
+        QString unicode;
+        bool repeat;
+        ushort repeatCount;
+        QEvent::Type keyType;
+        quint32 nativeScanCode;
+        quint32 nativeVirtualKey;
+        quint32 nativeModifiers;
+    };
+
+    class TouchEvent : public InputEvent {
+    public:
+        TouchEvent(QWindow *w, ulong time, QEvent::Type t, QTouchDevice *dev,
+                   const QList<QTouchEvent::TouchPoint> &p, Qt::KeyboardModifiers mods)
+            :InputEvent(w, time, Touch, mods), device(dev), points(p), touchType(t) { }
+        QTouchDevice *device;
+        QList<QTouchEvent::TouchPoint> points;
+        QEvent::Type touchType;
+    };
+
+    class ScreenOrientationEvent : public WindowSystemEvent {
+    public:
+        ScreenOrientationEvent(QScreen *s, Qt::ScreenOrientation o)
+            : WindowSystemEvent(ScreenOrientation), screen(s), orientation(o) { }
+        QPointer<QScreen> screen;
+        Qt::ScreenOrientation orientation;
+    };
+
+    class ScreenGeometryEvent : public WindowSystemEvent {
+    public:
+        ScreenGeometryEvent(QScreen *s, const QRect &g)
+            : WindowSystemEvent(ScreenGeometry), screen(s), geometry(g) { }
+        QPointer<QScreen> screen;
+        QRect geometry;
+    };
+
+    class ScreenAvailableGeometryEvent : public WindowSystemEvent {
+    public:
+        ScreenAvailableGeometryEvent(QScreen *s, const QRect &g)
+            : WindowSystemEvent(ScreenAvailableGeometry), screen(s), availableGeometry(g) { }
+        QPointer<QScreen> screen;
+        QRect availableGeometry;
+    };
+
+    class ScreenLogicalDotsPerInchEvent : public WindowSystemEvent {
+    public:
+        ScreenLogicalDotsPerInchEvent(QScreen *s, qreal dx, qreal dy)
+            : WindowSystemEvent(ScreenLogicalDotsPerInch), screen(s), dpiX(dx), dpiY(dy) { }
+        QPointer<QScreen> screen;
+        qreal dpiX;
+        qreal dpiY;
+    };
+
+    class ScreenRefreshRateEvent : public WindowSystemEvent {
+    public:
+        ScreenRefreshRateEvent(QScreen *s, qreal r)
+            : WindowSystemEvent(ScreenRefreshRate), screen(s), rate(r) { }
+        QPointer<QScreen> screen;
+        qreal rate;
+    };
+
+    class ThemeChangeEvent : public WindowSystemEvent {
+    public:
+        explicit ThemeChangeEvent(QWindow * w)
+            : WindowSystemEvent(ThemeChange), window(w) { }
+        QPointer<QWindow> window;
+    };
+
+    class ExposeEvent : public WindowSystemEvent {
+    public:
+        ExposeEvent(QWindow *exposed, const QRegion &region);
+        QPointer<QWindow> exposed;
+        bool isExposed;
+        QRegion region;
+    };
+
+    class FileOpenEvent : public WindowSystemEvent {
+    public:
+        FileOpenEvent(const QString& fileName)
+            : WindowSystemEvent(FileOpen), fileName(fileName)
+        { }
+        QString fileName;
+    };
+
+    class TabletEvent : public InputEvent {
+    public:
+        static void handleTabletEvent(QWindow *w, bool down, const QPointF &local, const QPointF &global,
+                                      int device, int pointerType, qreal pressure, int xTilt, int yTilt,
+                                      qreal tangentialPressure, qreal rotation, int z, qint64 uid,
+                                      Qt::KeyboardModifiers modifiers = Qt::NoModifier);
+
+        TabletEvent(QWindow *w, ulong time, bool down, const QPointF &local, const QPointF &global,
+                    int device, int pointerType, qreal pressure, int xTilt, int yTilt, qreal tpressure,
+                    qreal rotation, int z, qint64 uid, Qt::KeyboardModifiers mods)
+            : InputEvent(w, time, Tablet, Qt::NoModifier),
+              down(down), local(local), global(global), device(device), pointerType(pointerType),
+              pressure(pressure), xTilt(xTilt), yTilt(yTilt), tangentialPressure(tpressure),
+              rotation(rotation), z(z), uid(uid), mods(mods) { }
+        bool down;
+        QPointF local;
+        QPointF global;
+        int device;
+        int pointerType;
+        qreal pressure;
+        int xTilt;
+        int yTilt;
+        qreal tangentialPressure;
+        qreal rotation;
+        int z;
+        qint64 uid;
+        Qt::KeyboardModifiers mods;
+    };
+
+    class TabletEnterProximityEvent : public InputEvent {
+    public:
+        TabletEnterProximityEvent(ulong time, int device, int pointerType, qint64 uid)
+            : InputEvent(0, time, TabletEnterProximity, Qt::NoModifier),
+              device(device), pointerType(pointerType), uid(uid) { }
+        int device;
+        int pointerType;
+        qint64 uid;
+    };
+
+    class TabletLeaveProximityEvent : public InputEvent {
+    public:
+        TabletLeaveProximityEvent(ulong time, int device, int pointerType, qint64 uid)
+            : InputEvent(0, time, TabletLeaveProximity, Qt::NoModifier),
+              device(device), pointerType(pointerType), uid(uid) { }
+        int device;
+        int pointerType;
+        qint64 uid;
+    };
+
+    static QList<WindowSystemEvent *> windowSystemEventQueue;
+    static QMutex queueMutex;
+
+    static int windowSystemEventsQueued();
+    static WindowSystemEvent * getWindowSystemEvent();
+    static void queueWindowSystemEvent(WindowSystemEvent *ev);
+
+    static QElapsedTimer eventTime;
+
+    static QList<QTouchEvent::TouchPoint> convertTouchPoints(const QList<QWindowSystemInterface::TouchPoint> &points, QEvent::Type *type);
+};
+
+QT_END_HEADER
+QT_END_NAMESPACE
+
+#endif // QWINDOWSYSTEMINTERFACE_P_H