import cut out qxtgui/global-shortcuts :( sorry guys!

8 files changed, 1198 insertions, 0 deletions

diff --git a/qxt-mini/QxtGlobalShortcut b/qxt-mini/QxtGlobalShortcut
new file mode 100644
index 00000000..d673035b
--- /dev/null
+++ b/qxt-mini/QxtGlobalShortcut
@@ -0,0 +1,2 @@
+#include "qxtglobalshortcut.h"
+
diff --git a/qxt-mini/plat/qxtglobalshortcut_mac.cpp b/qxt-mini/plat/qxtglobalshortcut_mac.cpp
new file mode 100644
index 00000000..58b9a904
--- /dev/null
+++ b/qxt-mini/plat/qxtglobalshortcut_mac.cpp
@@ -0,0 +1,258 @@
+#include <Carbon/Carbon.h>

+/****************************************************************************
+** Copyright (c) 2006 - 2011, the LibQxt project.
+** See the Qxt AUTHORS file for a list of authors and copyright holders.
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are met:
+**     * Redistributions of source code must retain the above copyright
+**       notice, this list of conditions and the following disclaimer.
+**     * Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution.
+**     * Neither the name of the LibQxt project nor the
+**       names of its contributors may be used to endorse or promote products
+**       derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+** DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**
+** <http://libqxt.org>  <foundation@libqxt.org>
+*****************************************************************************/
+
+#include "qxtglobalshortcut_p.h"

+#include <QMap>

+#include <QHash>

+#include <QtDebug>

+#include <QApplication>

+

+typedef QPair<uint, uint> Identifier;

+static QMap<quint32, EventHotKeyRef> keyRefs;

+static QHash<Identifier, quint32> keyIDs;

+static quint32 hotKeySerial = 0;

+static bool qxt_mac_handler_installed = false;

+

+OSStatus qxt_mac_handle_hot_key(EventHandlerCallRef nextHandler, EventRef event, void* data)

+{

+    Q_UNUSED(nextHandler);

+    Q_UNUSED(data);

+    if (GetEventClass(event) == kEventClassKeyboard && GetEventKind(event) == kEventHotKeyPressed)

+    {

+        EventHotKeyID keyID;

+        GetEventParameter(event, kEventParamDirectObject, typeEventHotKeyID, NULL, sizeof(keyID), NULL, &keyID);

+        Identifier id = keyIDs.key(keyID.id);

+        QxtGlobalShortcutPrivate::activateShortcut(id.second, id.first);

+    }

+    return noErr;

+}

+

+quint32 QxtGlobalShortcutPrivate::nativeModifiers(Qt::KeyboardModifiers modifiers)

+{

+    quint32 native = 0;

+    if (modifiers & Qt::ShiftModifier)

+        native |= shiftKey;

+    if (modifiers & Qt::ControlModifier)

+        native |= cmdKey;

+    if (modifiers & Qt::AltModifier)

+        native |= optionKey;

+    if (modifiers & Qt::MetaModifier)

+        native |= controlKey;

+    if (modifiers & Qt::KeypadModifier)

+        native |= kEventKeyModifierNumLockMask;

+    return native;

+}

+

+quint32 QxtGlobalShortcutPrivate::nativeKeycode(Qt::Key key)

+{

+    UTF16Char ch;

+    // Constants found in NSEvent.h from AppKit.framework

+    switch (key)

+    {

+    case Qt::Key_Return:

+        return kVK_Return;

+    case Qt::Key_Enter:

+        return kVK_ANSI_KeypadEnter;

+    case Qt::Key_Tab:

+        return kVK_Tab;

+    case Qt::Key_Space:

+        return kVK_Space;

+    case Qt::Key_Backspace:

+        return kVK_Delete;

+    case Qt::Key_Control:

+        return kVK_Command;

+    case Qt::Key_Shift:

+        return kVK_Shift;

+    case Qt::Key_CapsLock:

+        return kVK_CapsLock;

+    case Qt::Key_Option:

+        return kVK_Option;

+    case Qt::Key_Meta:

+        return kVK_Control;

+    case Qt::Key_F17:

+        return kVK_F17;

+    case Qt::Key_VolumeUp:

+        return kVK_VolumeUp;

+    case Qt::Key_VolumeDown:

+        return kVK_VolumeDown;

+    case Qt::Key_F18:

+        return kVK_F18;

+    case Qt::Key_F19:

+        return kVK_F19;

+    case Qt::Key_F20:

+        return kVK_F20;

+    case Qt::Key_F5:

+        return kVK_F5;

+    case Qt::Key_F6:

+        return kVK_F6;

+    case Qt::Key_F7:

+        return kVK_F7;

+    case Qt::Key_F3:

+        return kVK_F3;

+    case Qt::Key_F8:

+        return kVK_F8;

+    case Qt::Key_F9:

+        return kVK_F9;

+    case Qt::Key_F11:

+        return kVK_F11;

+    case Qt::Key_F13:

+        return kVK_F13;

+    case Qt::Key_F16:

+        return kVK_F16;

+    case Qt::Key_F14:

+        return kVK_F14;

+    case Qt::Key_F10:

+        return kVK_F10;

+    case Qt::Key_F12:

+        return kVK_F12;

+    case Qt::Key_F15:

+        return kVK_F15;

+    case Qt::Key_Help:

+        return kVK_Help;

+    case Qt::Key_Home:

+        return kVK_Home;

+    case Qt::Key_PageUp:

+        return kVK_PageUp;

+    case Qt::Key_Delete:

+        return kVK_ForwardDelete;

+    case Qt::Key_F4:

+        return kVK_F4;

+    case Qt::Key_End:

+        return kVK_End;

+    case Qt::Key_F2:

+        return kVK_F2;

+    case Qt::Key_PageDown:

+        return kVK_PageDown;

+    case Qt::Key_F1:

+        return kVK_F1;

+    case Qt::Key_Left:

+        return kVK_LeftArrow;

+    case Qt::Key_Right:

+        return kVK_RightArrow;

+    case Qt::Key_Down:

+        return kVK_DownArrow;

+    case Qt::Key_Up:

+        return kVK_UpArrow;

+    default:

+        ;

+    }

+

+    if (key == Qt::Key_Escape)	ch = 27;

+    else if (key == Qt::Key_Return) ch = 13;

+    else if (key == Qt::Key_Enter) ch = 3;

+    else if (key == Qt::Key_Tab) ch = 9;

+    else ch = key;

+

+    CFDataRef currentLayoutData;

+    TISInputSourceRef currentKeyboard = TISCopyCurrentKeyboardInputSource();

+

+    if (currentKeyboard == NULL)

+        return 0;

+

+    currentLayoutData = (CFDataRef)TISGetInputSourceProperty(currentKeyboard, kTISPropertyUnicodeKeyLayoutData);

+    CFRelease(currentKeyboard);

+    if (currentLayoutData == NULL)

+        return 0;

+

+    UCKeyboardLayout* header = (UCKeyboardLayout*)CFDataGetBytePtr(currentLayoutData);

+    UCKeyboardTypeHeader* table = header->keyboardTypeList;

+

+    uint8_t *data = (uint8_t*)header;

+    // God, would a little documentation for this shit kill you...

+    for (quint32 i=0; i < header->keyboardTypeCount; i++)

+    {

+        UCKeyStateRecordsIndex* stateRec = 0;

+        if (table[i].keyStateRecordsIndexOffset != 0)

+        {

+            stateRec = reinterpret_cast<UCKeyStateRecordsIndex*>(data + table[i].keyStateRecordsIndexOffset);

+            if (stateRec->keyStateRecordsIndexFormat != kUCKeyStateRecordsIndexFormat) stateRec = 0;

+        }

+

+        UCKeyToCharTableIndex* charTable = reinterpret_cast<UCKeyToCharTableIndex*>(data + table[i].keyToCharTableIndexOffset);

+        if (charTable->keyToCharTableIndexFormat != kUCKeyToCharTableIndexFormat) continue;

+

+        for (quint32 j=0; j < charTable->keyToCharTableCount; j++)

+        {

+            UCKeyOutput* keyToChar = reinterpret_cast<UCKeyOutput*>(data + charTable->keyToCharTableOffsets[j]);

+            for (quint32 k=0; k < charTable->keyToCharTableSize; k++)

+            {

+                if (keyToChar[k] & kUCKeyOutputTestForIndexMask)

+                {

+                    long idx = keyToChar[k] & kUCKeyOutputGetIndexMask;

+                    if (stateRec && idx < stateRec->keyStateRecordCount)

+                    {

+                        UCKeyStateRecord* rec = reinterpret_cast<UCKeyStateRecord*>(data + stateRec->keyStateRecordOffsets[idx]);

+                        if (rec->stateZeroCharData == ch) return k;

+                    }

+                }

+                else if (!(keyToChar[k] & kUCKeyOutputSequenceIndexMask) && keyToChar[k] < 0xFFFE)

+                {

+                    if (keyToChar[k] == ch) return k;

+                }

+            } // for k

+        } // for j

+    } // for i

+    return 0;

+}

+

+bool QxtGlobalShortcutPrivate::registerShortcut(quint32 nativeKey, quint32 nativeMods)

+{

+    if (!qxt_mac_handler_installed)

+    {

+        EventTypeSpec t;

+        t.eventClass = kEventClassKeyboard;

+        t.eventKind = kEventHotKeyPressed;

+        InstallApplicationEventHandler(&qxt_mac_handle_hot_key, 1, &t, NULL, NULL);

+    }

+

+    EventHotKeyID keyID;

+    keyID.signature = 'cute';

+    keyID.id = ++hotKeySerial;

+

+    EventHotKeyRef ref = 0;

+    bool rv = !RegisterEventHotKey(nativeKey, nativeMods, keyID, GetApplicationEventTarget(), 0, &ref);

+    if (rv)

+    {

+        keyIDs.insert(Identifier(nativeMods, nativeKey), keyID.id);

+        keyRefs.insert(keyID.id, ref);

+    }

+    return rv;

+}

+

+bool QxtGlobalShortcutPrivate::unregisterShortcut(quint32 nativeKey, quint32 nativeMods)

+{

+    Identifier id(nativeMods, nativeKey);

+    if (!keyIDs.contains(id)) return false;

+

+    EventHotKeyRef ref = keyRefs.take(keyIDs[id]);

+    keyIDs.remove(id);

+    return !UnregisterEventHotKey(ref);

+}

diff --git a/qxt-mini/plat/qxtglobalshortcut_x11.cpp b/qxt-mini/plat/qxtglobalshortcut_x11.cpp
new file mode 100644
index 00000000..0c203dd8
--- /dev/null
+++ b/qxt-mini/plat/qxtglobalshortcut_x11.cpp
@@ -0,0 +1,235 @@
+#include "../qxtglobalshortcut_p.h"

+/****************************************************************************

+** Copyright (c) 2006 - 2011, the LibQxt project.

+** See the Qxt AUTHORS file for a list of authors and copyright holders.

+** All rights reserved.

+**

+** Redistribution and use in source and binary forms, with or without

+** modification, are permitted provided that the following conditions are met:

+**     * Redistributions of source code must retain the above copyright

+**       notice, this list of conditions and the following disclaimer.

+**     * Redistributions in binary form must reproduce the above copyright

+**       notice, this list of conditions and the following disclaimer in the

+**       documentation and/or other materials provided with the distribution.

+**     * Neither the name of the LibQxt project nor the

+**       names of its contributors may be used to endorse or promote products

+**       derived from this software without specific prior written permission.

+**

+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+** DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY

+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

+** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+**

+** <http://libqxt.org>  <foundation@libqxt.org>

+*****************************************************************************/

+

+#include <QVector>

+#include <QApplication>

+// include private header for great justice -sh 20131015

+#include <X11/Xlib.h>

+#include <xcb/xcb.h>

+#include "qplatformnativeinterface.h"

+

+namespace {

+

+const QVector<quint32> maskModifiers = QVector<quint32>()

+    << 0 << Mod2Mask << LockMask << (Mod2Mask | LockMask);

+

+typedef int (*X11ErrorHandler)(Display *display, XErrorEvent *event);

+

+class QxtX11ErrorHandler {

+public:

+    static bool error;

+

+    static int qxtX11ErrorHandler(Display *display, XErrorEvent *event)

+    {

+        Q_UNUSED(display);

+        switch (event->error_code)

+        {

+            case BadAccess:

+            case BadValue:

+            case BadWindow:

+                if (event->request_code == 33 /* X_GrabKey */ ||

+                        event->request_code == 34 /* X_UngrabKey */)

+                {

+                    error = true;

+                    //TODO:

+                    //char errstr[256];

+                    //XGetErrorText(dpy, err->error_code, errstr, 256);

+                }

+        }

+        return 0;

+    }

+

+    QxtX11ErrorHandler()

+    {

+        error = false;

+        m_previousErrorHandler = XSetErrorHandler(qxtX11ErrorHandler);

+    }

+

+    ~QxtX11ErrorHandler()

+    {

+        XSetErrorHandler(m_previousErrorHandler);

+    }

+

+private:

+    X11ErrorHandler m_previousErrorHandler;

+};

+

+bool QxtX11ErrorHandler::error = false;

+

+class QxtX11Data {

+public:

+    QxtX11Data()

+    {

+#if QT_VERSION < QT_VERSION_CHECK(5,0,0)

+        m_display = QX11Info::display();

+#else

+        QPlatformNativeInterface *native = qApp->platformNativeInterface();

+        void *display = native->nativeResourceForScreen(QByteArray("display"),

+                                                        QGuiApplication::primaryScreen());

+        m_display = reinterpret_cast<Display *>(display);

+#endif

+    }

+

+    bool isValid()

+    {

+        return m_display != 0;

+    }

+

+    Display *display()

+    {

+        Q_ASSERT(isValid());

+        return m_display;

+    }

+

+    Window rootWindow()

+    {

+        return DefaultRootWindow(display());

+    }

+

+    bool grabKey(quint32 keycode, quint32 modifiers, Window window)

+    {

+        QxtX11ErrorHandler errorHandler;

+

+        for (int i = 0; !errorHandler.error && i < maskModifiers.size(); ++i) {

+            XGrabKey(display(), keycode, modifiers | maskModifiers[i], window, True,

+                     GrabModeAsync, GrabModeAsync);

+        }

+

+        if (errorHandler.error) {

+            ungrabKey(keycode, modifiers, window);

+            return false;

+        }

+

+        return true;

+    }

+

+    bool ungrabKey(quint32 keycode, quint32 modifiers, Window window)

+    {

+        QxtX11ErrorHandler errorHandler;

+

+        foreach (quint32 maskMods, maskModifiers) {

+            XUngrabKey(display(), keycode, modifiers | maskMods, window);

+        }

+

+        return !errorHandler.error;

+    }

+

+private:

+    Display *m_display;

+};

+

+} // namespace

+

+#if QT_VERSION < QT_VERSION_CHECK(5,0,0)

+bool QxtGlobalShortcutPrivate::eventFilter(void *message)

+{

+    XEvent *event = static_cast<XEvent *>(message);

+    if (event->type == KeyPress)

+    {

+        XKeyEvent *key = reinterpret_cast<XKeyEvent *>(event);

+        unsigned int keycode = key->keycode;

+        unsigned int keystate = key->state;

+#else

+bool QxtGlobalShortcutPrivate::nativeEventFilter(const QByteArray & eventType,

+    void *message, long *result)

+{

+    Q_UNUSED(result);

+

+    xcb_key_press_event_t *kev = 0;

+    if (eventType == "xcb_generic_event_t") {

+        xcb_generic_event_t *ev = static_cast<xcb_generic_event_t *>(message);

+        if ((ev->response_type & 127) == XCB_KEY_PRESS)

+            kev = static_cast<xcb_key_press_event_t *>(message);

+    }

+

+    if (kev != 0) {

+        unsigned int keycode = kev->detail;

+        unsigned int keystate = 0;

+        if(kev->state & XCB_MOD_MASK_1)

+            keystate |= Mod1Mask;

+        if(kev->state & XCB_MOD_MASK_CONTROL)

+            keystate |= ControlMask;

+        if(kev->state & XCB_MOD_MASK_4)

+            keystate |= Mod4Mask;

+        if(kev->state & XCB_MOD_MASK_SHIFT)

+            keystate |= ShiftMask;

+#endif

+        activateShortcut(keycode,

+            // Mod1Mask == Alt, Mod4Mask == Meta

+            keystate & (ShiftMask | ControlMask | Mod1Mask | Mod4Mask));

+    }

+    return false;

+}

+

+quint32 QxtGlobalShortcutPrivate::nativeModifiers(Qt::KeyboardModifiers modifiers)

+{

+    // ShiftMask, LockMask, ControlMask, Mod1Mask, Mod2Mask, Mod3Mask, Mod4Mask, and Mod5Mask

+    quint32 native = 0;

+    if (modifiers & Qt::ShiftModifier)

+        native |= ShiftMask;

+    if (modifiers & Qt::ControlModifier)

+        native |= ControlMask;

+    if (modifiers & Qt::AltModifier)

+        native |= Mod1Mask;

+    if (modifiers & Qt::MetaModifier)

+        native |= Mod4Mask;

+

+    // TODO: resolve these?

+    //if (modifiers & Qt::MetaModifier)

+    //if (modifiers & Qt::KeypadModifier)

+    //if (modifiers & Qt::GroupSwitchModifier)

+    return native;

+}

+

+quint32 QxtGlobalShortcutPrivate::nativeKeycode(Qt::Key key)

+{

+    QxtX11Data x11;

+    if (!x11.isValid())

+        return 0;

+

+    KeySym keysym = XStringToKeysym(QKeySequence(key).toString().toLatin1().data());

+    if (keysym == NoSymbol)

+        keysym = static_cast<ushort>(key);

+

+    return XKeysymToKeycode(x11.display(), keysym);

+}

+

+bool QxtGlobalShortcutPrivate::registerShortcut(quint32 nativeKey, quint32 nativeMods)

+{

+    QxtX11Data x11;

+    return x11.isValid() && x11.grabKey(nativeKey, nativeMods, x11.rootWindow());

+}

+

+bool QxtGlobalShortcutPrivate::unregisterShortcut(quint32 nativeKey, quint32 nativeMods)

+{

+    QxtX11Data x11;

+    return x11.isValid() && x11.ungrabKey(nativeKey, nativeMods, x11.rootWindow());

+}

diff --git a/qxt-mini/qplatformnativeinterface.h b/qxt-mini/qplatformnativeinterface.h
new file mode 100644
index 00000000..eaa24a9e
--- /dev/null
+++ b/qxt-mini/qplatformnativeinterface.h
@@ -0,0 +1,99 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** 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, Digia gives you certain additional
+** rights.  These rights are described in the Digia 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.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPLATFORMNATIVEINTERFACE_H
+#define QPLATFORMNATIVEINTERFACE_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is part of the QPA API and is not meant to be used
+// in applications. Usage of this API may make your code
+// source and binary incompatible with future versions of Qt.
+//
+
+#include <QtGui/qwindowdefs.h>
+#include <QtCore/QObject>
+#include <QtCore/QVariant>
+
+QT_BEGIN_NAMESPACE
+
+
+class QOpenGLContext;
+class QScreen;
+class QWindow;
+class QPlatformWindow;
+class QBackingStore;
+
+class Q_GUI_EXPORT QPlatformNativeInterface : public QObject
+{
+    Q_OBJECT
+public:
+    virtual void *nativeResourceForIntegration(const QByteArray &resource);
+    virtual void *nativeResourceForContext(const QByteArray &resource, QOpenGLContext *context);
+    virtual void *nativeResourceForScreen(const QByteArray &resource, QScreen *screen);
+    virtual void *nativeResourceForWindow(const QByteArray &resource, QWindow *window);
+    virtual void *nativeResourceForBackingStore(const QByteArray &resource, QBackingStore *backingStore);
+
+    typedef void * (*NativeResourceForIntegrationFunction)();
+    typedef void * (*NativeResourceForContextFunction)(QOpenGLContext *context);
+    typedef void * (*NativeResourceForScreenFunction)(QScreen *screen);
+    typedef void * (*NativeResourceForWindowFunction)(QWindow *window);
+    typedef void * (*NativeResourceForBackingStoreFunction)(QBackingStore *backingStore);
+    virtual NativeResourceForIntegrationFunction nativeResourceFunctionForIntegration(const QByteArray &resource);
+    virtual NativeResourceForContextFunction nativeResourceFunctionForContext(const QByteArray &resource);
+    virtual NativeResourceForScreenFunction nativeResourceFunctionForScreen(const QByteArray &resource);
+    virtual NativeResourceForWindowFunction nativeResourceFunctionForWindow(const QByteArray &resource);
+    virtual NativeResourceForBackingStoreFunction nativeResourceFunctionForBackingStore(const QByteArray &resource);
+
+    virtual QVariantMap windowProperties(QPlatformWindow *window) const;
+    virtual QVariant windowProperty(QPlatformWindow *window, const QString &name) const;
+    virtual QVariant windowProperty(QPlatformWindow *window, const QString &name, const QVariant &defaultValue) const;
+    virtual void setWindowProperty(QPlatformWindow *window, const QString &name, const QVariant &value);
+
+Q_SIGNALS:
+    void windowPropertyChanged(QPlatformWindow *window, const QString &propertyName);
+};
+
+QT_END_NAMESPACE
+
+#endif // QPLATFORMNATIVEINTERFACE_H
diff --git a/qxt-mini/qxtglobal.h b/qxt-mini/qxtglobal.h
new file mode 100644
index 00000000..7d5abfbe
--- /dev/null
+++ b/qxt-mini/qxtglobal.h
@@ -0,0 +1,233 @@
+
+/****************************************************************************
+** Copyright (c) 2006 - 2011, the LibQxt project.
+** See the Qxt AUTHORS file for a list of authors and copyright holders.
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are met:
+**     * Redistributions of source code must retain the above copyright
+**       notice, this list of conditions and the following disclaimer.
+**     * Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution.
+**     * Neither the name of the LibQxt project nor the
+**       names of its contributors may be used to endorse or promote products
+**       derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+** DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**
+** <http://libqxt.org>  <foundation@libqxt.org>
+*****************************************************************************/
+
+#ifndef QXTGLOBAL_H
+#define QXTGLOBAL_H
+
+#include <QtGlobal>
+
+#define QXT_VERSION 0x000700
+#define QXT_VERSION_STR "0.7.0"
+
+//--------------------------global macros------------------------------
+
+#ifndef QXT_NO_MACROS
+
+#ifndef _countof
+#define _countof(x) (sizeof(x)/sizeof(*x))
+#endif
+
+#endif // QXT_NO_MACROS
+
+//--------------------------export macros------------------------------
+
+#define QXT_DLLEXPORT DO_NOT_USE_THIS_ANYMORE
+
+#if !defined(QXT_STATIC) && !defined(QXT_DOXYGEN_RUN)
+#    if defined(BUILD_QXT_CORE)
+#        define QXT_CORE_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_CORE_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_CORE_EXPORT
+#endif // BUILD_QXT_CORE
+ 
+#if !defined(QXT_STATIC) && !defined(QXT_DOXYGEN_RUN)
+#    if defined(BUILD_QXT_GUI)
+#        define QXT_GUI_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_GUI_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_GUI_EXPORT
+#endif // BUILD_QXT_GUI
+ 
+#if !defined(QXT_STATIC) && !defined(QXT_DOXYGEN_RUN)
+#    if defined(BUILD_QXT_NETWORK)
+#        define QXT_NETWORK_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_NETWORK_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_NETWORK_EXPORT
+#endif // BUILD_QXT_NETWORK
+ 
+#if !defined(QXT_STATIC) && !defined(QXT_DOXYGEN_RUN)
+#    if defined(BUILD_QXT_SQL)
+#        define QXT_SQL_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_SQL_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_SQL_EXPORT
+#endif // BUILD_QXT_SQL
+ 
+#if !defined(QXT_STATIC) && !defined(QXT_DOXYGEN_RUN)
+#    if defined(BUILD_QXT_WEB)
+#        define QXT_WEB_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_WEB_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_WEB_EXPORT
+#endif // BUILD_QXT_WEB
+ 
+#if !defined(QXT_STATIC) && !defined(QXT_DOXYGEN_RUN)
+#    if defined(BUILD_QXT_BERKELEY)
+#        define QXT_BERKELEY_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_BERKELEY_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_BERKELEY_EXPORT
+#endif // BUILD_QXT_BERKELEY
+
+#if !defined(QXT_STATIC) && !defined(QXT_DOXYGEN_RUN)
+#    if defined(BUILD_QXT_ZEROCONF)
+#        define QXT_ZEROCONF_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_ZEROCONF_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_ZEROCONF_EXPORT
+#endif // QXT_ZEROCONF_EXPORT
+
+#if defined(BUILD_QXT_CORE) || defined(BUILD_QXT_GUI) || defined(BUILD_QXT_SQL) || defined(BUILD_QXT_NETWORK) || defined(BUILD_QXT_WEB) || defined(BUILD_QXT_BERKELEY) || defined(BUILD_QXT_ZEROCONF)
+#   define BUILD_QXT
+#endif
+
+QXT_CORE_EXPORT const char* qxtVersion();
+
+#ifndef QT_BEGIN_NAMESPACE
+#define QT_BEGIN_NAMESPACE
+#endif
+
+#ifndef QT_END_NAMESPACE
+#define QT_END_NAMESPACE
+#endif
+
+#ifndef QT_FORWARD_DECLARE_CLASS
+#define QT_FORWARD_DECLARE_CLASS(Class) class Class;
+#endif
+
+/****************************************************************************
+** This file is derived from code bearing the following notice:
+** The sole author of this file, Adam Higerd, has explicitly disclaimed all
+** copyright interest and protection for the content within. This file has
+** been placed in the public domain according to United States copyright
+** statute and case law. In jurisdictions where this public domain dedication
+** is not legally recognized, anyone who receives a copy of this file is
+** permitted to use, modify, duplicate, and redistribute this file, in whole
+** or in part, with no restrictions or conditions. In these jurisdictions,
+** this file shall be copyright (C) 2006-2008 by Adam Higerd.
+****************************************************************************/
+
+#define QXT_DECLARE_PRIVATE(PUB) friend class PUB##Private; QxtPrivateInterface<PUB, PUB##Private> qxt_d;
+#define QXT_DECLARE_PUBLIC(PUB) friend class PUB;
+#define QXT_INIT_PRIVATE(PUB) qxt_d.setPublic(this);
+#define QXT_D(PUB) PUB##Private& d = qxt_d()
+#define QXT_P(PUB) PUB& p = qxt_p()
+
+template <typename PUB>
+class QxtPrivate
+{
+public:
+    virtual ~QxtPrivate()
+    {}
+    inline void QXT_setPublic(PUB* pub)
+    {
+        qxt_p_ptr = pub;
+    }
+
+protected:
+    inline PUB& qxt_p()
+    {
+        return *qxt_p_ptr;
+    }
+    inline const PUB& qxt_p() const
+    {
+        return *qxt_p_ptr;
+    }
+    inline PUB* qxt_ptr()
+    {
+        return qxt_p_ptr;
+    }
+    inline const PUB* qxt_ptr() const
+    {
+        return qxt_p_ptr;
+    }
+
+private:
+    PUB* qxt_p_ptr;
+};
+
+template <typename PUB, typename PVT>
+class QxtPrivateInterface
+{
+    friend class QxtPrivate<PUB>;
+public:
+    QxtPrivateInterface()
+    {
+        pvt = new PVT;
+    }
+    ~QxtPrivateInterface()
+    {
+        delete pvt;
+    }
+
+    inline void setPublic(PUB* pub)
+    {
+        pvt->QXT_setPublic(pub);
+    }
+    inline PVT& operator()()
+    {
+        return *static_cast<PVT*>(pvt);
+    }
+    inline const PVT& operator()() const
+    {
+        return *static_cast<PVT*>(pvt);
+    }
+    inline PVT * operator->()
+    {
+	return static_cast<PVT*>(pvt);
+    }
+    inline const PVT * operator->() const
+    {
+	return static_cast<PVT*>(pvt);
+    }
+private:
+    QxtPrivateInterface(const QxtPrivateInterface&) { }
+    QxtPrivateInterface& operator=(const QxtPrivateInterface&) { }
+    QxtPrivate<PUB>* pvt;
+};
+
+#endif // QXT_GLOBAL
diff --git a/qxt-mini/qxtglobalshortcut.cpp b/qxt-mini/qxtglobalshortcut.cpp
new file mode 100644
index 00000000..72548d6f
--- /dev/null
+++ b/qxt-mini/qxtglobalshortcut.cpp
@@ -0,0 +1,223 @@
+#include "qxtglobalshortcut.h"

+/****************************************************************************

+** Copyright (c) 2006 - 2011, the LibQxt project.

+** See the Qxt AUTHORS file for a list of authors and copyright holders.

+** All rights reserved.

+**

+** Redistribution and use in source and binary forms, with or without

+** modification, are permitted provided that the following conditions are met:

+**     * Redistributions of source code must retain the above copyright

+**       notice, this list of conditions and the following disclaimer.

+**     * Redistributions in binary form must reproduce the above copyright

+**       notice, this list of conditions and the following disclaimer in the

+**       documentation and/or other materials provided with the distribution.

+**     * Neither the name of the LibQxt project nor the

+**       names of its contributors may be used to endorse or promote products

+**       derived from this software without specific prior written permission.

+**

+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+** DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY

+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

+** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+**

+** <http://libqxt.org>  <foundation@libqxt.org>

+*****************************************************************************/

+

+#include "qxtglobalshortcut_p.h"

+#include <QAbstractEventDispatcher>

+#include <QtDebug>

+

+#ifndef Q_WS_MAC

+int QxtGlobalShortcutPrivate::ref = 0;

+#   if QT_VERSION < QT_VERSION_CHECK(5,0,0)

+QAbstractEventDispatcher::EventFilter QxtGlobalShortcutPrivate::prevEventFilter = 0;

+#   endif

+#endif // Q_WS_MAC

+QHash<QPair<quint32, quint32>, QxtGlobalShortcut*> QxtGlobalShortcutPrivate::shortcuts;

+

+QxtGlobalShortcutPrivate::QxtGlobalShortcutPrivate() : enabled(true), key(Qt::Key(0)), mods(Qt::NoModifier)

+{

+#ifndef Q_WS_MAC

+    if (ref == 0) {

+#   if QT_VERSION < QT_VERSION_CHECK(5,0,0)

+        prevEventFilter = QAbstractEventDispatcher::instance()->setEventFilter(eventFilter);

+#   else

+        QAbstractEventDispatcher::instance()->installNativeEventFilter(this);

+#endif

+    }

+    ++ref;

+#endif // Q_WS_MAC

+}

+

+QxtGlobalShortcutPrivate::~QxtGlobalShortcutPrivate()

+{

+#ifndef Q_WS_MAC

+    --ref;

+    if (ref == 0) {

+        QAbstractEventDispatcher *ed = QAbstractEventDispatcher::instance();

+        if (ed != 0) {

+#   if QT_VERSION < QT_VERSION_CHECK(5,0,0)

+            ed->setEventFilter(prevEventFilter);

+#   else

+            ed->removeNativeEventFilter(this);

+#   endif

+        }

+    }

+#endif // Q_WS_MAC

+}

+

+bool QxtGlobalShortcutPrivate::setShortcut(const QKeySequence& shortcut)

+{

+    Qt::KeyboardModifiers allMods = Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier;

+    key = shortcut.isEmpty() ? Qt::Key(0) : Qt::Key((shortcut[0] ^ allMods) & shortcut[0]);

+    mods = shortcut.isEmpty() ? Qt::KeyboardModifiers(0) : Qt::KeyboardModifiers(shortcut[0] & allMods);

+    const quint32 nativeKey = nativeKeycode(key);

+    const quint32 nativeMods = nativeModifiers(mods);

+    const bool res = registerShortcut(nativeKey, nativeMods);

+    if (res)

+        shortcuts.insert(qMakePair(nativeKey, nativeMods), &qxt_p());

+    else

+        qWarning() << "QxtGlobalShortcut failed to register:" << QKeySequence(key + mods).toString();

+    return res;

+}

+

+bool QxtGlobalShortcutPrivate::unsetShortcut()

+{

+    bool res = false;

+    const quint32 nativeKey = nativeKeycode(key);

+    const quint32 nativeMods = nativeModifiers(mods);

+    if (shortcuts.value(qMakePair(nativeKey, nativeMods)) == &qxt_p())

+        res = unregisterShortcut(nativeKey, nativeMods);

+    if (res)

+        shortcuts.remove(qMakePair(nativeKey, nativeMods));

+    else

+        qWarning() << "QxtGlobalShortcut failed to unregister:" << QKeySequence(key + mods).toString();

+    key = Qt::Key(0);

+    mods = Qt::KeyboardModifiers(0);

+    return res;

+}

+

+void QxtGlobalShortcutPrivate::activateShortcut(quint32 nativeKey, quint32 nativeMods)

+{

+    QxtGlobalShortcut* shortcut = shortcuts.value(qMakePair(nativeKey, nativeMods));

+    if (shortcut && shortcut->isEnabled())

+        emit shortcut->activated();

+}

+

+/*!

+    \class QxtGlobalShortcut

+    \inmodule QxtWidgets

+    \brief The QxtGlobalShortcut class provides a global shortcut aka "hotkey".

+

+    A global shortcut triggers even if the application is not active. This

+    makes it easy to implement applications that react to certain shortcuts

+    still if some other application is active or if the application is for

+    example minimized to the system tray.

+

+    Example usage:

+    \code

+    QxtGlobalShortcut* shortcut = new QxtGlobalShortcut(window);

+    connect(shortcut, SIGNAL(activated()), window, SLOT(toggleVisibility()));

+    shortcut->setShortcut(QKeySequence("Ctrl+Shift+F12"));

+    \endcode

+

+    \bold {Note:} Since Qxt 0.6 QxtGlobalShortcut no more requires QxtApplication.

+ */

+

+/*!

+    \fn QxtGlobalShortcut::activated()

+

+    This signal is emitted when the user types the shortcut's key sequence.

+

+    \sa shortcut

+ */

+

+/*!

+    Constructs a new QxtGlobalShortcut with \a parent.

+ */

+QxtGlobalShortcut::QxtGlobalShortcut(QObject* parent)

+        : QObject(parent)

+{

+    QXT_INIT_PRIVATE(QxtGlobalShortcut);

+}

+

+/*!

+    Constructs a new QxtGlobalShortcut with \a shortcut and \a parent.

+ */

+QxtGlobalShortcut::QxtGlobalShortcut(const QKeySequence& shortcut, QObject* parent)

+        : QObject(parent)

+{

+    QXT_INIT_PRIVATE(QxtGlobalShortcut);

+    setShortcut(shortcut);

+}

+

+/*!

+    Destructs the QxtGlobalShortcut.

+ */

+QxtGlobalShortcut::~QxtGlobalShortcut()

+{

+    if (qxt_d().key != 0)

+        qxt_d().unsetShortcut();

+}

+

+/*!

+    \property QxtGlobalShortcut::shortcut

+    \brief the shortcut key sequence

+

+    \bold {Note:} Notice that corresponding key press and release events are not

+    delivered for registered global shortcuts even if they are disabled.

+    Also, comma separated key sequences are not supported.

+    Only the first part is used:

+

+    \code

+    qxtShortcut->setShortcut(QKeySequence("Ctrl+Alt+A,Ctrl+Alt+B"));

+    Q_ASSERT(qxtShortcut->shortcut() == QKeySequence("Ctrl+Alt+A"));

+    \endcode

+ */

+QKeySequence QxtGlobalShortcut::shortcut() const

+{

+    return QKeySequence(qxt_d().key | qxt_d().mods);

+}

+

+bool QxtGlobalShortcut::setShortcut(const QKeySequence& shortcut)

+{

+    if (qxt_d().key != 0)

+        qxt_d().unsetShortcut();

+    return qxt_d().setShortcut(shortcut);

+}

+

+/*!

+    \property QxtGlobalShortcut::enabled

+    \brief whether the shortcut is enabled

+

+    A disabled shortcut does not get activated.

+

+    The default value is \c true.

+

+    \sa setDisabled()

+ */

+bool QxtGlobalShortcut::isEnabled() const

+{

+    return qxt_d().enabled;

+}

+

+void QxtGlobalShortcut::setEnabled(bool enabled)

+{

+    qxt_d().enabled = enabled;

+}

+

+/*!

+    Sets the shortcut \a disabled.

+

+    \sa enabled

+ */

+void QxtGlobalShortcut::setDisabled(bool disabled)

+{

+    qxt_d().enabled = !disabled;

+}

diff --git a/qxt-mini/qxtglobalshortcut.h b/qxt-mini/qxtglobalshortcut.h
new file mode 100644
index 00000000..a81942d2
--- /dev/null
+++ b/qxt-mini/qxtglobalshortcut.h
@@ -0,0 +1,64 @@
+#ifndef QXTGLOBALSHORTCUT_H

+/****************************************************************************

+** Copyright (c) 2006 - 2011, the LibQxt project.

+** See the Qxt AUTHORS file for a list of authors and copyright holders.

+** All rights reserved.

+**

+** Redistribution and use in source and binary forms, with or without

+** modification, are permitted provided that the following conditions are met:

+**     * Redistributions of source code must retain the above copyright

+**       notice, this list of conditions and the following disclaimer.

+**     * Redistributions in binary form must reproduce the above copyright

+**       notice, this list of conditions and the following disclaimer in the

+**       documentation and/or other materials provided with the distribution.

+**     * Neither the name of the LibQxt project nor the

+**       names of its contributors may be used to endorse or promote products

+**       derived from this software without specific prior written permission.

+**

+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+** DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY

+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

+** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+**

+** <http://libqxt.org>  <foundation@libqxt.org>

+*****************************************************************************/

+

+#define QXTGLOBALSHORTCUT_H

+

+#include "qxtglobal.h"

+#include <QObject>

+#include <QKeySequence>

+class QxtGlobalShortcutPrivate;

+

+class QXT_GUI_EXPORT QxtGlobalShortcut : public QObject

+{

+    Q_OBJECT

+    QXT_DECLARE_PRIVATE(QxtGlobalShortcut)

+    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)

+    Q_PROPERTY(QKeySequence shortcut READ shortcut WRITE setShortcut)

+

+public:

+    explicit QxtGlobalShortcut(QObject* parent = 0);

+    explicit QxtGlobalShortcut(const QKeySequence& shortcut, QObject* parent = 0);

+    virtual ~QxtGlobalShortcut();

+

+    QKeySequence shortcut() const;

+    bool setShortcut(const QKeySequence& shortcut);

+

+    bool isEnabled() const;

+

+public Q_SLOTS:

+    void setEnabled(bool enabled = true);

+    void setDisabled(bool disabled = true);

+

+Q_SIGNALS:

+    void activated();

+};

+

+#endif // QXTGLOBALSHORTCUT_H

diff --git a/qxt-mini/qxtglobalshortcut_p.h b/qxt-mini/qxtglobalshortcut_p.h
new file mode 100644
index 00000000..1a788852
--- /dev/null
+++ b/qxt-mini/qxtglobalshortcut_p.h
@@ -0,0 +1,84 @@
+#ifndef QXTGLOBALSHORTCUT_P_H

+/****************************************************************************

+** Copyright (c) 2006 - 2011, the LibQxt project.

+** See the Qxt AUTHORS file for a list of authors and copyright holders.

+** All rights reserved.

+**

+** Redistribution and use in source and binary forms, with or without

+** modification, are permitted provided that the following conditions are met:

+**     * Redistributions of source code must retain the above copyright

+**       notice, this list of conditions and the following disclaimer.

+**     * Redistributions in binary form must reproduce the above copyright

+**       notice, this list of conditions and the following disclaimer in the

+**       documentation and/or other materials provided with the distribution.

+**     * Neither the name of the LibQxt project nor the

+**       names of its contributors may be used to endorse or promote products

+**       derived from this software without specific prior written permission.

+**

+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+** DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY

+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

+** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+**

+** <http://libqxt.org>  <foundation@libqxt.org>

+*****************************************************************************/

+

+#define QXTGLOBALSHORTCUT_P_H

+

+#include "qxtglobalshortcut.h"

+#include <QAbstractEventDispatcher>

+#include <QKeySequence>

+#include <QHash>

+

+#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)

+#include <QAbstractNativeEventFilter>

+#endif

+

+

+class QxtGlobalShortcutPrivate : public QxtPrivate<QxtGlobalShortcut>

+#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)

+        ,public QAbstractNativeEventFilter

+#endif

+{

+public:

+    QXT_DECLARE_PUBLIC(QxtGlobalShortcut)

+    QxtGlobalShortcutPrivate();

+    ~QxtGlobalShortcutPrivate();

+

+    bool enabled;

+    Qt::Key key;

+    Qt::KeyboardModifiers mods;

+

+    bool setShortcut(const QKeySequence& shortcut);

+    bool unsetShortcut();

+

+    static bool error;

+#ifndef Q_WS_MAC

+    static int ref;

+#if QT_VERSION < QT_VERSION_CHECK(5,0,0)

+    static QAbstractEventDispatcher::EventFilter prevEventFilter;

+    static bool eventFilter(void* message);

+#else

+    virtual bool nativeEventFilter(const QByteArray & eventType, void * message, long * result);

+#endif // QT_VERSION < QT_VERSION_CHECK(5,0,0)

+#endif // Q_WS_MAC

+

+    static void activateShortcut(quint32 nativeKey, quint32 nativeMods);

+

+private:

+    static quint32 nativeKeycode(Qt::Key keycode);

+    static quint32 nativeModifiers(Qt::KeyboardModifiers modifiers);

+

+    static bool registerShortcut(quint32 nativeKey, quint32 nativeMods);

+    static bool unregisterShortcut(quint32 nativeKey, quint32 nativeMods);

+

+    static QHash<QPair<quint32, quint32>, QxtGlobalShortcut*> shortcuts;

+};

+

+#endif // QXTGLOBALSHORTCUT_P_H