Changeset 846 for trunk/src/gui/kernel/qapplication_x11.cpp

Timestamp:

May 5, 2011, 5:36:53 AM (14 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/kernel/qapplication_x11.cpp (modified) (21 diffs)

trunk/src/gui/kernel/qapplication_x11.cpp

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
@@ -75 +75 @@
 #include "qvarlengtharray.h"
 #include "qdebug.h"
-#include <private/qunicodetables_p.h>
 #include <private/qcrashhandler_p.h>
 #include <private/qcolor_p.h>
@@ -214 +213 @@
 
     "DTWM_IS_RUNNING\0"
-    "KDE_FULL_SESSION\0"
-    "KWIN_RUNNING\0"
-    "KWM_RUNNING\0"
-    "GNOME_BACKGROUND_PROPERTIES\0"
     "ENLIGHTENMENT_DESKTOP\0"
+    "_DT_SAVE_MODE\0"
     "_SGI_DESKS_MANAGER\0"
 
@@ -279 +275 @@
     "_NET_SYSTEM_TRAY_VISUAL\0"
 
+    "_NET_ACTIVE_WINDOW\0"
+
     // Property formats
     "COMPOUND_TEXT\0"
@@ -402 +400 @@
 #endif
 
+typedef bool(*QX11FilterFunction)(XEvent *event);
+
+Q_GLOBAL_STATIC(QList<QX11FilterFunction>, x11Filters)
+
+Q_GUI_EXPORT void qt_installX11EventFilter(QX11FilterFunction func)
+{
+    Q_ASSERT(func);
+
+    if (QList<QX11FilterFunction> *list = x11Filters())
+        list->append(func);
+}
+
+Q_GUI_EXPORT void qt_removeX11EventFilter(QX11FilterFunction func)
+{
+    Q_ASSERT(func);
+
+    if (QList<QX11FilterFunction> *list = x11Filters())
+        list->removeOne(func);
+}
+
+
 static bool qt_x11EventFilter(XEvent* ev)
 {
@@ -407 +426 @@
     if (qApp->filterEvent(ev, &unused))
         return true;
+    if (const QList<QX11FilterFunction> *list = x11Filters()) {
+        for (QList<QX11FilterFunction>::const_iterator it = list->constBegin(); it != list->constEnd(); ++it) {
+            if ((*it)(ev))
+                return true;
+        }
+    }
+
     return qApp->x11EventFilter(ev);
 }
@@ -625 +651 @@
 static int qt_x_errhandler(Display *dpy, XErrorEvent *err)
 {
+    if (X11->display != dpy) {
+        // only handle X errors for our display
+        return 0;
+    }
+
     switch (err->error_code) {
     case BadAtom:
@@ -632 +663 @@
                 || err->resourceid == ATOM(_NET_SUPPORTED)
                 || err->resourceid == ATOM(_NET_SUPPORTING_WM_CHECK)
-                || err->resourceid == ATOM(KDE_FULL_SESSION)
-                || err->resourceid == ATOM(KWIN_RUNNING)
                 || err->resourceid == ATOM(XdndProxy)
                 || err->resourceid == ATOM(XdndAware))) {
@@ -665 +694 @@
         }
         if (X11->ignore_badwindow)
-            return 0;
-        break;
-
-    case BadMatch:
-        if (err->request_code == 42 /* X_SetInputFocus */)
             return 0;
         break;
@@ -710 +734 @@
         else if (err->request_code == X11->mitshm_major)
             extensionName = "MIT-SHM";
+#ifndef QT_NO_XKB
+        else if(err->request_code == X11->xkb_major)
+            extensionName = "XKEYBOARD";
+#endif
 
         char minor_str[256];
@@ -1635 +1663 @@
     X11->xinput_eventbase = 0;
     X11->xinput_errorbase = 0;
+
+    X11->use_xkb = false;
+    X11->xkb_major = 0;
+    X11->xkb_eventbase = 0;
+    X11->xkb_errorbase = 0;
 
     // MIT-SHM
@@ -2109 +2142 @@
 #endif // QT_NO_XINPUT
 
+#ifndef QT_NO_XKB
+        int xkblibMajor = XkbMajorVersion;
+        int xkblibMinor = XkbMinorVersion;
+        X11->use_xkb = XkbQueryExtension(X11->display,
+                                         &X11->xkb_major,
+                                         &X11->xkb_eventbase,
+                                         &X11->xkb_errorbase,
+                                         &xkblibMajor,
+                                         &xkblibMinor);
+        if (X11->use_xkb) {
+            // If XKB is detected, set the GrabsUseXKBState option so input method
+            // compositions continue to work (ie. deadkeys)
+            unsigned int state = XkbPCF_GrabsUseXKBStateMask;
+            (void) XkbSetPerClientControls(X11->display, state, &state);
+
+            // select for group change events
+            XkbSelectEventDetails(X11->display,
+                                  XkbUseCoreKbd,
+                                  XkbStateNotify,
+                                  XkbAllStateComponentsMask,
+                                  XkbGroupStateMask);
+
+            // current group state is queried when creating the keymapper, no need to do it here
+        }
+#endif
+
+
 #if !defined(QT_NO_FONTCONFIG)
         int dpi = 0;
@@ -2123 +2183 @@
         for (int s = 0; s < ScreenCount(X11->display); ++s) {
             int subpixel = FC_RGBA_UNKNOWN;
-#if RENDER_MAJOR > 0 || RENDER_MINOR >= 6
+#if !defined(QT_NO_XRENDER) && (RENDER_MAJOR > 0 || RENDER_MINOR >= 6)
             if (X11->use_xrender) {
                 int rsp = XRenderQuerySubpixelOrder(X11->display, s);
@@ -2187 +2247 @@
         QKeyMapper::changeKeyboard();
 
-#ifndef QT_NO_XKB
-        if (qt_keymapper_private()->useXKB) {
-            // If XKB is detected, set the GrabsUseXKBState option so input method
-            // compositions continue to work (ie. deadkeys)
-            unsigned int state = XkbPCF_GrabsUseXKBStateMask;
-            (void) XkbSetPerClientControls(X11->display, state, &state);
-        }
-#endif // QT_NO_XKB
-
         // Misc. initialization
 #if 0 //disabled for now..
@@ -2228 +2279 @@
         X11->desktopVersion = 0;
 
-        // See if the current window manager is using the freedesktop.org spec to give its name
-        Window windowManagerWindow = XNone;
-        Atom typeReturned;
-        int formatReturned;
-        unsigned long nitemsReturned;
-        unsigned long unused;
-        unsigned char *data = 0;
-        if (XGetWindowProperty(QX11Info::display(), QX11Info::appRootWindow(),
-                           ATOM(_NET_SUPPORTING_WM_CHECK),
-                           0, 1024, False, XA_WINDOW, &typeReturned,
-                           &formatReturned, &nitemsReturned, &unused, &data)
-              == Success) {
-            if (typeReturned == XA_WINDOW && formatReturned == 32)
-                windowManagerWindow = *((Window*) data);
-            if (data)
+        Atom type;
+        int format;
+        unsigned long length, after;
+        uchar *data = 0;
+        int rc;
+
+        do {
+            if (!qgetenv("KDE_FULL_SESSION").isEmpty()) {
+                X11->desktopEnvironment = DE_KDE;
+                X11->desktopVersion = qgetenv("KDE_SESSION_VERSION").toInt();
+                break;
+            }
+
+            if (qgetenv("DESKTOP_SESSION") == "gnome") {
+                X11->desktopEnvironment = DE_GNOME;
+                break;
+            }
+
+            // GNOME_DESKTOP_SESSION_ID is deprecated for some reason, but still check it
+            if (!qgetenv("GNOME_DESKTOP_SESSION_ID").isEmpty()) {
+                X11->desktopEnvironment = DE_GNOME;
+                break;
+            }
+
+            rc = XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(_DT_SAVE_MODE),
+                                    0, 2, False, XA_STRING, &type, &format, &length,
+                                    &after, &data);
+            if (rc == Success && length) {
+                if (!strcmp(reinterpret_cast<char *>(data), "xfce4")) {
+                    // Pretend that xfce4 is gnome, as it uses the same libraries.
+                    // The detection above is stolen from xdg-open.
+                    X11->desktopEnvironment = DE_GNOME;
+                    break;
+                }
+
+                // We got the property but it wasn't xfce4. Free data before it gets overwritten.
                 XFree(data);
-
-            if (windowManagerWindow != XNone) {
-                QString wmName;
-                Atom utf8atom = ATOM(UTF8_STRING);
-                if (XGetWindowProperty(QX11Info::display(), windowManagerWindow, ATOM(_NET_WM_NAME),
-                                       0, 1024, False, utf8atom, &typeReturned,
-                                       &formatReturned, &nitemsReturned, &unused, &data)
-                    == Success) {
-                    if (typeReturned == utf8atom && formatReturned == 8)
-                        wmName = QString::fromUtf8((const char*)data);
-                    if (data)
-                        XFree(data);
-                    if (wmName == QLatin1String("KWin"))
-                        X11->desktopEnvironment = DE_KDE;
-                    if (wmName == QLatin1String("Metacity"))
-                        X11->desktopEnvironment = DE_GNOME;
-                }
-            }
-        }
-
-        // Running a different/newer/older window manager?  Try some other things
-        if (X11->desktopEnvironment == DE_UNKNOWN){
-            Atom type;
-            int format;
-            unsigned long length, after;
-            uchar *data = 0;
-
-            QString session = QString::fromLocal8Bit(qgetenv("DESKTOP_SESSION"));
-            if (session == QLatin1String("kde")) {
-                X11->desktopEnvironment = DE_KDE;
-            } else if (session == QLatin1String("gnome") || session == QLatin1String("xfce")) {
-                X11->desktopEnvironment = DE_GNOME;
-            } else if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(DTWM_IS_RUNNING),
-                                          0, 1, False, AnyPropertyType, &type, &format, &length,
-                                   &after, &data) == Success && length) {
+                data = 0;
+            }
+
+            rc = XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(DTWM_IS_RUNNING),
+                                    0, 1, False, AnyPropertyType, &type, &format, &length,
+                                    &after, &data);
+            if (rc == Success && length) {
                 // DTWM is running, meaning most likely CDE is running...
                 X11->desktopEnvironment = DE_CDE;
-            } else if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(),
-                                          ATOM(GNOME_BACKGROUND_PROPERTIES), 0, 1, False, AnyPropertyType,
-                                          &type, &format, &length, &after, &data) == Success && length) {
-                X11->desktopEnvironment = DE_GNOME;
-            } else if (!qgetenv("GNOME_DESKTOP_SESSION_ID").isEmpty()) {
-                X11->desktopEnvironment = DE_GNOME;
-            } else if ((XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(KDE_FULL_SESSION),
-                                           0, 1, False, AnyPropertyType, &type, &format, &length, &after, &data) == Success
-                        && length)
-                       || (XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(KWIN_RUNNING),
-                                              0, 1, False, AnyPropertyType, &type, &format, &length,
-                                              &after, &data) == Success
-                           && length)
-                       || (XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(KWM_RUNNING),
-                                              0, 1, False, AnyPropertyType, &type, &format, &length,
-                                              &after, &data) == Success && length)) {
-                X11->desktopEnvironment = DE_KDE;
-            } else if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(_SGI_DESKS_MANAGER),
-                                          0, 1, False, XA_WINDOW, &type, &format, &length, &after, &data) == Success
-                       && length) {
+                break;
+            }
+
+            rc = XGetWindowProperty(X11->display, QX11Info::appRootWindow(),
+                                    ATOM(_SGI_DESKS_MANAGER), 0, 1, False, XA_WINDOW,
+                                    &type, &format, &length, &after, &data);
+            if (rc == Success && length) {
                 X11->desktopEnvironment = DE_4DWM;
-            }
-            if (data)
-                XFree((char *)data);
-        }
-
-        if (X11->desktopEnvironment == DE_KDE)
-            X11->desktopVersion = QString::fromLocal8Bit(qgetenv("KDE_SESSION_VERSION")).toInt();
+                break;
+            }
+
+            if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(),
+                               ATOM(_NET_SUPPORTING_WM_CHECK),
+                               0, 1024, False, XA_WINDOW, &type,
+                               &format, &length, &after, &data) == Success) {
+                if (type == XA_WINDOW && format == 32) {
+                    Window windowManagerWindow = *((Window*) data);
+                    XFree(data);
+                    data = 0;
+
+                    if (windowManagerWindow != XNone) {
+                        Atom utf8atom = ATOM(UTF8_STRING);
+                        if (XGetWindowProperty(QX11Info::display(), windowManagerWindow, ATOM(_NET_WM_NAME),
+                                               0, 1024, False, utf8atom, &type,
+                                               &format, &length, &after, &data) == Success) {
+                            if (type == utf8atom && format == 8) {
+                                if (qstrcmp((const char *)data, "MCompositor") == 0)
+                                    X11->desktopEnvironment = DE_MEEGO_COMPOSITOR;
+                            }
+                        }
+                    }
+                }
+            }
+
+        } while(0);
+
+        if (data)
+            XFree((char *)data);
 
 #if !defined(QT_NO_STYLE_GTK)
@@ -3053 +3107 @@
                     X11->time = event->xclient.data.l[1];
                 QWidget *amw = activeModalWidget();
+                if (amw && amw->testAttribute(Qt::WA_X11DoNotAcceptFocus))
+                    amw = 0;
                 if (amw && !QApplicationPrivate::tryModalHelper(widget, 0)) {
                     QWidget *p = amw->parentWidget();
@@ -3251 +3307 @@
         return 0;
     }
+#ifndef QT_NO_XKB
+    else if (X11->use_xkb && event->type == X11->xkb_eventbase) {
+        XkbAnyEvent *xkbevent = (XkbAnyEvent *) event;
+        switch (xkbevent->xkb_type) {
+        case XkbStateNotify:
+            {
+                XkbStateNotifyEvent *xkbstateevent = (XkbStateNotifyEvent *) xkbevent;
+                if ((xkbstateevent->changed & XkbGroupStateMask) != 0) {
+                    qt_keymapper_private()->xkb_currentGroup = xkbstateevent->group;
+                    QKeyMapper::changeKeyboard();
+                }
+                break;
+            }
+        default:
+            break;
+        }
+    }
+#endif
 
     if (!widget) {                                // don't know this windows
@@ -3620 +3694 @@
     case MapNotify:                                // window shown
         if (widget->isWindow()) {
+            // if we got a MapNotify when we were not waiting for it, it most
+            // likely means the user has already asked to hide the window before
+            // it ever being shown, so we try to withdraw a window after sending
+            // the QShowEvent.
+            bool pendingHide = widget->testAttribute(Qt::WA_WState_ExplicitShowHide) && widget->testAttribute(Qt::WA_WState_Hidden);
             widget->d_func()->topData()->waitingForMapNotify = 0;
 
@@ -3639 +3718 @@
                 }
             }
+            if (pendingHide) // hide the window
+                XWithdrawWindow(X11->display, widget->internalWinId(), widget->x11Info().screen());
         }
         break;
@@ -3686 +3767 @@
                 QWidget *newparent = QWidget::find(event->xreparent.parent);
                 if (! newparent || (newparent->windowType() == Qt::Desktop)) {
-                    // we dont' know about the new parent (or we've been
+                    // we don't know about the new parent (or we've been
                     // reparented to root), perhaps a window manager
                     // has been (re)started?  reset the focus model to unknown
@@ -5246 +5327 @@
         if (isVisible() && data->crect.size() != oldSize) {
             Q_ASSERT(d->extra->topextra);
-            QWidgetBackingStore *bs = d->extra->topextra->backingStore;
+            QWidgetBackingStore *bs = d->extra->topextra->backingStore.data();
             const bool hasStaticContents = bs && bs->hasStaticContents();
             // If we have a backing store with static contents, we have to disable the top-level