1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 // ### 4.0: examine Q_EXPORT's below. The respective symbols had all

    43 // been in use (e.g. in the KDE wm) before the introduction of a version

    44 // map. One might want to turn some of them into proper public API and

    45 // provide a proper alternative for others. See also the exports in

    46 // qapplication_win.cpp, which suggest a unification.

    47 

    48 #include "qplatformdefs.h"

    49 

    50 #include "qcolormap.h"

    51 #include "qdesktopwidget.h"

    52 #include "qapplication.h"

    53 #include "qapplication_p.h"

    54 #include "qcursor.h"

    55 #include "qwidget.h"

    56 #include "qbitarray.h"

    57 #include "qpainter.h"

    58 #include "qfile.h"

    59 #include "qpixmapcache.h"

    60 #include "qdatetime.h"

    61 #include "qtextcodec.h"

    62 #include "qdatastream.h"

    63 #include "qbuffer.h"

    64 #include "qsocketnotifier.h"

    65 #include "qsessionmanager.h"

    66 #include "qclipboard.h"

    67 #include "qwhatsthis.h"

    68 #include "qsettings.h"

    69 #include "qstylefactory.h"

    70 #include "qfileinfo.h"

    71 #include "qdir.h"

    72 #include "qhash.h"

    73 #include "qevent.h"

    74 #include "qevent_p.h"

    75 #include "qvarlengtharray.h"

    76 #include "qdebug.h"

    77 #include <private/qunicodetables_p.h>

    78 #include <private/qcrashhandler_p.h>

    79 #include <private/qcolor_p.h>

    80 #include <private/qcursor_p.h>

    81 #include <private/qiconloader_p.h>

    82 #include <private/gtksymbols_p.h>

    83 #include "qstyle.h"

    84 #include "qmetaobject.h"

    85 #include "qtimer.h"

    86 #include "qlibrary.h"

    87 #include <private/qgraphicssystemfactory_p.h>

    88 #include "qguiplatformplugin_p.h"

    89 #include "qkde_p.h"

    90 

    91 #if !defined (QT_NO_TABLET)

    92 extern "C" {

    93 #   define class c_class  //XIproto.h has a name member named 'class' which the c++ compiler doesn't like

    94 #   include <wacomcfg.h>

    95 #   undef class

    96 }

    97 #endif

    98 

    99 //#define ALIEN_DEBUG

   100 

   101 #if !defined(QT_NO_GLIB)

   102 #  include "qguieventdispatcher_glib_p.h"

   103 #endif

   104 #include "qeventdispatcher_x11_p.h"

   105 #include <private/qpaintengine_x11_p.h>

   106 

   107 #include <private/qkeymapper_p.h>

   108 

   109 // Input method stuff

   110 #ifndef QT_NO_IM

   111 #include "qinputcontext.h"

   112 #include "qinputcontextfactory.h"

   113 #endif // QT_NO_IM

   114 

   115 #ifndef QT_NO_XFIXES

   116 #include <X11/extensions/Xfixes.h>

   117 #endif // QT_NO_XFIXES

   118 

   119 #include "qt_x11_p.h"

   120 #include "qx11info_x11.h"

   121 

   122 #define XK_MISCELLANY

   123 #include <X11/keysymdef.h>

   124 #if !defined(QT_NO_XINPUT)

   125 #include <X11/extensions/XI.h>

   126 #endif

   127 

   128 #include <stdlib.h>

   129 #include <string.h>

   130 #include <ctype.h>

   131 #include <locale.h>

   132 

   133 #include "qwidget_p.h"

   134 

   135 #include <private/qbackingstore_p.h>

   136 

   137 #ifdef QT_RX71_MULTITOUCH

   138 #  include <qsocketnotifier.h>

   139 #  include <linux/input.h>

   140 #  include <errno.h>

   141 #endif

   142 

   143 #if _POSIX_VERSION+0 < 200112L && !defined(Q_OS_BSD4)

   144 # define QT_NO_UNSETENV

   145 #endif

   146 

   147 QT_BEGIN_NAMESPACE

   148 

   149 //#define X_NOT_BROKEN

   150 #ifdef X_NOT_BROKEN

   151 // Some X libraries are built with setlocale #defined to _Xsetlocale,

   152 // even though library users are then built WITHOUT such a definition.

   153 // This creates a problem - Qt might setlocale() one value, but then

   154 // X looks and doesn't see the value Qt set. The solution here is to

   155 // implement _Xsetlocale just in case X calls it - redirecting it to

   156 // the real libC version.

   157 //

   158 # ifndef setlocale

   159 extern "C" char *_Xsetlocale(int category, const char *locale);

   160 char *_Xsetlocale(int category, const char *locale)

   161 {

   162     //qDebug("_Xsetlocale(%d,%s),category,locale");

   163     return setlocale(category,locale);

   164 }

   165 # endif // setlocale

   166 #endif // X_NOT_BROKEN

   167 

   168 /* Warning: if you modify this string, modify the list of atoms in qt_x11_p.h as well! */

   169 static const char * x11_atomnames = {

   170     // window-manager <-> client protocols

   171     "WM_PROTOCOLS\0"

   172     "WM_DELETE_WINDOW\0"

   173     "WM_TAKE_FOCUS\0"

   174     "_NET_WM_PING\0"

   175     "_NET_WM_CONTEXT_HELP\0"

   176     "_NET_WM_SYNC_REQUEST\0"

   177     "_NET_WM_SYNC_REQUEST_COUNTER\0"

   178 

   179     // ICCCM window state

   180     "WM_STATE\0"

   181     "WM_CHANGE_STATE\0"

   182 

   183     // Session management

   184     "WM_CLIENT_LEADER\0"

   185     "WM_WINDOW_ROLE\0"

   186     "SM_CLIENT_ID\0"

   187 

   188     // Clipboard

   189     "CLIPBOARD\0"

   190     "INCR\0"

   191     "TARGETS\0"

   192     "MULTIPLE\0"

   193     "TIMESTAMP\0"

   194     "SAVE_TARGETS\0"

   195     "CLIP_TEMPORARY\0"

   196     "_QT_SELECTION\0"

   197     "_QT_CLIPBOARD_SENTINEL\0"

   198     "_QT_SELECTION_SENTINEL\0"

   199     "CLIPBOARD_MANAGER\0"

   200 

   201     "RESOURCE_MANAGER\0"

   202 

   203     "_XSETROOT_ID\0"

   204 

   205     "_QT_SCROLL_DONE\0"

   206     "_QT_INPUT_ENCODING\0"

   207 

   208     "_MOTIF_WM_HINTS\0"

   209 

   210     "DTWM_IS_RUNNING\0"

   211     "KDE_FULL_SESSION\0"

   212     "KWIN_RUNNING\0"

   213     "KWM_RUNNING\0"

   214     "GNOME_BACKGROUND_PROPERTIES\0"

   215     "ENLIGHTENMENT_DESKTOP\0"

   216     "_SGI_DESKS_MANAGER\0"

   217 

   218     // EWMH (aka NETWM)

   219     "_NET_SUPPORTED\0"

   220     "_NET_VIRTUAL_ROOTS\0"

   221     "_NET_WORKAREA\0"

   222 

   223     "_NET_MOVERESIZE_WINDOW\0"

   224     "_NET_WM_MOVERESIZE\0"

   225 

   226     "_NET_WM_NAME\0"

   227     "_NET_WM_ICON_NAME\0"

   228     "_NET_WM_ICON\0"

   229 

   230     "_NET_WM_PID\0"

   231 

   232     "_NET_WM_WINDOW_OPACITY\0"

   233 

   234     "_NET_WM_STATE\0"

   235     "_NET_WM_STATE_ABOVE\0"

   236     "_NET_WM_STATE_BELOW\0"

   237     "_NET_WM_STATE_FULLSCREEN\0"

   238     "_NET_WM_STATE_MAXIMIZED_HORZ\0"

   239     "_NET_WM_STATE_MAXIMIZED_VERT\0"

   240     "_NET_WM_STATE_MODAL\0"

   241     "_NET_WM_STATE_STAYS_ON_TOP\0"

   242     "_NET_WM_STATE_DEMANDS_ATTENTION\0"

   243 

   244     "_NET_WM_USER_TIME\0"

   245     "_NET_WM_USER_TIME_WINDOW\0"

   246     "_NET_WM_FULL_PLACEMENT\0"

   247 

   248     "_NET_WM_WINDOW_TYPE\0"

   249     "_NET_WM_WINDOW_TYPE_DESKTOP\0"

   250     "_NET_WM_WINDOW_TYPE_DOCK\0"

   251     "_NET_WM_WINDOW_TYPE_TOOLBAR\0"

   252     "_NET_WM_WINDOW_TYPE_MENU\0"

   253     "_NET_WM_WINDOW_TYPE_UTILITY\0"

   254     "_NET_WM_WINDOW_TYPE_SPLASH\0"

   255     "_NET_WM_WINDOW_TYPE_DIALOG\0"

   256     "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU\0"

   257     "_NET_WM_WINDOW_TYPE_POPUP_MENU\0"

   258     "_NET_WM_WINDOW_TYPE_TOOLTIP\0"

   259     "_NET_WM_WINDOW_TYPE_NOTIFICATION\0"

   260     "_NET_WM_WINDOW_TYPE_COMBO\0"

   261     "_NET_WM_WINDOW_TYPE_DND\0"

   262     "_NET_WM_WINDOW_TYPE_NORMAL\0"

   263     "_KDE_NET_WM_WINDOW_TYPE_OVERRIDE\0"

   264 

   265     "_KDE_NET_WM_FRAME_STRUT\0"

   266 

   267     "_NET_STARTUP_INFO\0"

   268     "_NET_STARTUP_INFO_BEGIN\0"

   269 

   270     "_NET_SUPPORTING_WM_CHECK\0"

   271 

   272     "_NET_WM_CM_S0\0"

   273 

   274     "_NET_SYSTEM_TRAY_VISUAL\0"

   275 

   276     // Property formats

   277     "COMPOUND_TEXT\0"

   278     "TEXT\0"

   279     "UTF8_STRING\0"

   280 

   281     // xdnd

   282     "XdndEnter\0"

   283     "XdndPosition\0"

   284     "XdndStatus\0"

   285     "XdndLeave\0"

   286     "XdndDrop\0"

   287     "XdndFinished\0"

   288     "XdndTypeList\0"

   289     "XdndActionList\0"

   290 

   291     "XdndSelection\0"

   292 

   293     "XdndAware\0"

   294     "XdndProxy\0"

   295 

   296     "XdndActionCopy\0"

   297     "XdndActionLink\0"

   298     "XdndActionMove\0"

   299     "XdndActionPrivate\0"

   300 

   301     // Motif DND

   302     "_MOTIF_DRAG_AND_DROP_MESSAGE\0"

   303     "_MOTIF_DRAG_INITIATOR_INFO\0"

   304     "_MOTIF_DRAG_RECEIVER_INFO\0"

   305     "_MOTIF_DRAG_WINDOW\0"

   306     "_MOTIF_DRAG_TARGETS\0"

   307 

   308     "XmTRANSFER_SUCCESS\0"

   309     "XmTRANSFER_FAILURE\0"

   310 

   311     // Xkb

   312     "_XKB_RULES_NAMES\0"

   313 

   314     // XEMBED

   315     "_XEMBED\0"

   316     "_XEMBED_INFO\0"

   317 

   318     "Wacom Stylus\0"

   319     "Wacom Cursor\0"

   320     "Wacom Eraser\0"

   321 };

   322 

   323 Q_GUI_EXPORT QX11Data *qt_x11Data = 0;

   324 

   325 /*****************************************************************************

   326   Internal variables and functions

   327  *****************************************************************************/

   328 static const char *appName = 0;                        // application name

   329 static const char *appClass = 0;                        // application class

   330 static const char *appFont        = 0;                // application font

   331 static const char *appBGCol        = 0;                // application bg color

   332 static const char *appFGCol        = 0;                // application fg color

   333 static const char *appBTNCol        = 0;                // application btn color

   334 static const char *mwGeometry        = 0;                // main widget geometry

   335 static const char *mwTitle        = 0;                // main widget title

   336 char    *qt_ximServer        = 0;                // XIM Server will connect to

   337 static bool        appSync                = false;        // X11 synchronization

   338 #if defined(QT_DEBUG)

   339 static bool        appNoGrab        = false;        // X11 grabbing enabled

   340 static bool        appDoGrab        = false;        // X11 grabbing override (gdb)

   341 #endif

   342 static bool        app_save_rootinfo = false;        // save root info

   343 static bool        app_do_modal        = false;        // modal mode

   344 static Window        curWin = 0;                        // current window

   345 

   346 

   347 // function to update the workarea of the screen - in qdesktopwidget_x11.cpp

   348 extern void qt_desktopwidget_update_workarea();

   349 

   350 // Function to change the window manager state (from qwidget_x11.cpp)

   351 extern void qt_change_net_wm_state(const QWidget *w, bool set, Atom one, Atom two = 0);

   352 

   353 // modifier masks for alt, meta, super, hyper, and mode_switch - detected when the application starts

   354 // and/or keyboard layout changes

   355 uchar qt_alt_mask = 0;

   356 uchar qt_meta_mask = 0;

   357 uchar qt_super_mask = 0;

   358 uchar qt_hyper_mask = 0;

   359 uchar qt_mode_switch_mask = 0;

   360 

   361 // flags for extensions for special Languages, currently only for RTL languages

   362 bool         qt_use_rtl_extensions = false;

   363 

   364 static Window        mouseActWindow             = 0;        // window where mouse is

   365 static Qt::MouseButton  mouseButtonPressed   = Qt::NoButton; // last mouse button pressed

   366 static Qt::MouseButtons mouseButtonState     = Qt::NoButton; // mouse button state

   367 static Time        mouseButtonPressTime = 0;        // when was a button pressed

   368 static short        mouseXPos, mouseYPos;                // mouse pres position in act window

   369 static short        mouseGlobalXPos, mouseGlobalYPos; // global mouse press position

   370 

   371 extern QWidgetList *qt_modal_stack;                // stack of modal widgets

   372 

   373 // window where mouse buttons have been pressed

   374 static Window pressed_window = XNone;

   375 

   376 // popup control

   377 static bool replayPopupMouseEvent = false;

   378 static bool popupGrabOk;

   379 

   380 bool qt_sm_blockUserInput = false;                // session management

   381 

   382 Q_GUI_EXPORT int qt_xfocusout_grab_counter = 0;

   383 

   384 #if !defined (QT_NO_TABLET)

   385 Q_GLOBAL_STATIC(QTabletDeviceDataList, tablet_devices)

   386 QTabletDeviceDataList *qt_tablet_devices()

   387 {

   388     return tablet_devices();

   389 }

   390 

   391 extern bool qt_tabletChokeMouse;

   392 #endif

   393 

   394 static bool qt_x11EventFilter(XEvent* ev)

   395 {

   396     long unused;

   397     if (qApp->filterEvent(ev, &unused))

   398         return true;

   399     return qApp->x11EventFilter(ev);

   400 }

   401 

   402 #if !defined(QT_NO_XIM)

   403 XIMStyle        qt_xim_preferred_style = 0;

   404 #endif

   405 int qt_ximComposingKeycode=0;

   406 QTextCodec * qt_input_mapper = 0;

   407 

   408 extern bool qt_check_clipboard_sentinel(); //def in qclipboard_x11.cpp

   409 extern bool qt_check_selection_sentinel(); //def in qclipboard_x11.cpp

   410 extern bool qt_xfixes_clipboard_changed(Window clipboardOwner, Time timestamp); //def in qclipboard_x11.cpp

   411 extern bool qt_xfixes_selection_changed(Window selectionOwner, Time timestamp); //def in qclipboard_x11.cpp

   412 

   413 static void        qt_save_rootinfo();

   414 Q_GUI_EXPORT bool qt_try_modal(QWidget *, XEvent *);

   415 

   416 QWidget *qt_button_down = 0; // last widget to be pressed with the mouse

   417 QPointer<QWidget> qt_last_mouse_receiver = 0;

   418 static QWidget *qt_popup_down = 0;  // popup that contains the pressed widget

   419 

   420 extern bool qt_xdnd_dragging;

   421 

   422 // gui or non-gui from qapplication.cpp

   423 extern bool qt_is_gui_used;

   424 

   425 /*!

   426     \internal

   427     Try to resolve a \a symbol from \a library with the version specified

   428     by \a vernum.

   429 

   430     Note that, in the case of the Xfixes library, \a vernum is not the same as

   431     \c XFIXES_MAJOR - it is a part of soname and may differ from the Xfixes

   432     version.

   433 */

   434 static void* qt_load_library_runtime(const char *library, int vernum,

   435                                      int highestVernum, const char *symbol)

   436 {

   437     QList<int> versions;

   438     // we try to load in the following order:

   439     // explicit version -> the default one -> (from the highest (highestVernum) to the lowest (vernum) )

   440     if (vernum != -1)

   441         versions << vernum;

   442     versions << -1;

   443     if (vernum != -1) {

   444         for(int i = highestVernum; i > vernum; --i)

   445             versions << i;

   446     }

   447     Q_FOREACH(int version, versions) {

   448         QLatin1String libName(library);

   449         QLibrary xfixesLib(libName, version);

   450         if (xfixesLib.load()) {

   451             void *ptr = xfixesLib.resolve(symbol);

   452             if (ptr)

   453                 return ptr;

   454         }

   455     }

   456     return 0;

   457 }

   458 

   459 #ifndef QT_NO_XINPUT

   460 # ifdef QT_RUNTIME_XINPUT

   461 #  define XINPUT_LOAD_RUNTIME(vernum, symbol, symbol_type) \

   462     (symbol_type)qt_load_library_runtime("libXi", vernum, 6, #symbol);

   463 #  define XINPUT_LOAD(symbol) \

   464     XINPUT_LOAD_RUNTIME(1, symbol, Ptr##symbol)

   465 # else // not runtime XInput

   466 #  define XINPUT_LOAD(symbol) symbol

   467 # endif // QT_RUNTIME_XINPUT

   468 #else // not using Xinput at all

   469 # define XINPUT_LOAD(symbol) 0

   470 #endif // QT_NO_XINPUT

   471 

   472 #ifndef QT_NO_XFIXES

   473 # ifdef QT_RUNTIME_XFIXES

   474 #  define XFIXES_LOAD_RUNTIME(vernum, symbol, symbol_type) \

   475     (symbol_type)qt_load_library_runtime("libXfixes", vernum, 4, #symbol);

   476 #  define XFIXES_LOAD_V1(symbol) \

   477     XFIXES_LOAD_RUNTIME(1, symbol, Ptr##symbol)

   478 #  define XFIXES_LOAD_V2(symbol) \

   479     XFIXES_LOAD_RUNTIME(2, symbol, Ptr##symbol)

   480 

   481 # else // not runtime Xfixes

   482 

   483 #  if XFIXES_MAJOR >= 2

   484 #   define XFIXES_LOAD_V1(symbol) symbol

   485 #   define XFIXES_LOAD_V2(symbol) symbol

   486 #  elif XFIXES_MAJOR >= 1

   487 #   define XFIXES_LOAD_V1(symbol) symbol

   488 #   define XFIXES_LOAD_V2(symbol) 0

   489 #  else

   490 #   error Unsupported version of Xfixes

   491 #  endif

   492 # endif // QT_RUNTIME_XFIXES

   493 #else // not using Xfixes at all

   494 # define XFIXES_LOAD_V1(symbol) 0

   495 # define XFIXES_LOAD_V2(symbol) 0

   496 #endif // QT_NO_XFIXES

   497 

   498 #ifndef QT_NO_XFIXES

   499 

   500 struct qt_xfixes_selection_event_data

   501 {

   502     // which selection to filter out.

   503     Atom selection;

   504 };

   505 

   506 #if defined(Q_C_CALLBACKS)

   507 extern "C" {

   508 #endif

   509 

   510 static Bool qt_xfixes_scanner(Display*, XEvent *event, XPointer arg)

   511 {

   512     qt_xfixes_selection_event_data *data =

   513         reinterpret_cast<qt_xfixes_selection_event_data*>(arg);

   514     if (event->type == X11->xfixes_eventbase + XFixesSelectionNotify) {

   515         XFixesSelectionNotifyEvent *xfixes_event = reinterpret_cast<XFixesSelectionNotifyEvent*>(event);

   516         if (xfixes_event->selection == data->selection)

   517             return true;

   518     }

   519     return false;

   520 }

   521 

   522 #if defined(Q_C_CALLBACKS)

   523 }

   524 #endif

   525 

   526 #endif // QT_NO_XFIXES

   527 

   528 class QETWidget : public QWidget                // event translator widget

   529 {

   530 public:

   531     QWidgetPrivate* d_func() { return QWidget::d_func(); }

   532     bool translateMouseEvent(const XEvent *);

   533     void translatePaintEvent(const XEvent *);

   534     bool translateConfigEvent(const XEvent *);

   535     bool translateCloseEvent(const XEvent *);

   536     bool translateScrollDoneEvent(const XEvent *);

   537     bool translateWheelEvent(int global_x, int global_y, int delta, Qt::MouseButtons buttons,

   538                              Qt::KeyboardModifiers modifiers, Qt::Orientation orient);

   539 #if !defined (QT_NO_TABLET)

   540     bool translateXinputEvent(const XEvent*, QTabletDeviceData *tablet);

   541 #endif

   542     bool translatePropertyEvent(const XEvent *);

   543 

   544     void doDeferredMap()

   545     {

   546         Q_ASSERT(testAttribute(Qt::WA_WState_Created));

   547         if (!testAttribute(Qt::WA_Resized)) {

   548             adjustSize();

   549             setAttribute(Qt::WA_Resized, false);

   550         }

   551 

   552         /*

   553           workaround for WM's that throw away ConfigureRequests from the following:

   554 

   555           window->hide();

   556           window->move(x, y); // could also be resize(), move()+resize(), or setGeometry()

   557           window->show();

   558         */

   559         QRect r = geometry();

   560 

   561         XMoveResizeWindow(X11->display,

   562                           internalWinId(),

   563                           r.x(),

   564                           r.y(),

   565                           r.width(),

   566                           r.height());

   567 

   568         // static gravity!

   569         XSizeHints sh;

   570         long unused;

   571         XGetWMNormalHints(X11->display, internalWinId(), &sh, &unused);

   572         sh.flags |= USPosition | PPosition | USSize | PSize | PWinGravity;

   573         sh.x = r.x();

   574         sh.y = r.y();

   575         sh.width = r.width();

   576         sh.height = r.height();

   577         sh.win_gravity = StaticGravity;

   578         XSetWMNormalHints(X11->display, internalWinId(), &sh);

   579 

   580         setAttribute(Qt::WA_Mapped);

   581         if (testAttribute(Qt::WA_DontShowOnScreen))

   582             return;

   583         d_func()->topData()->waitingForMapNotify = 1;

   584         XMapWindow(X11->display, internalWinId());

   585     }

   586 };

   587 

   588 

   589 void QApplicationPrivate::createEventDispatcher()

   590 {

   591     Q_Q(QApplication);

   592 #if !defined(QT_NO_GLIB)

   593     if (qgetenv("QT_NO_GLIB").isEmpty() && QEventDispatcherGlib::versionSupported())

   594         eventDispatcher = (q->type() != QApplication::Tty

   595                            ? new QGuiEventDispatcherGlib(q)

   596                            : new QEventDispatcherGlib(q));

   597     else

   598 #endif

   599         eventDispatcher = (q->type() != QApplication::Tty

   600                            ? new QEventDispatcherX11(q)

   601                            : new QEventDispatcherUNIX(q));

   602 }

   603 

   604 /*****************************************************************************

   605   Default X error handlers

   606  *****************************************************************************/

   607 

   608 #if defined(Q_C_CALLBACKS)

   609 extern "C" {

   610 #endif

   611 

   612 static int (*original_x_errhandler)(Display *dpy, XErrorEvent *);

   613 static int (*original_xio_errhandler)(Display *dpy);

   614 

   615 static int qt_x_errhandler(Display *dpy, XErrorEvent *err)

   616 {

   617     switch (err->error_code) {

   618     case BadAtom:

   619         if (err->request_code == 20 /* X_GetProperty */

   620             && (err->resourceid == XA_RESOURCE_MANAGER

   621                 || err->resourceid == XA_RGB_DEFAULT_MAP

   622                 || err->resourceid == ATOM(_NET_SUPPORTED)

   623                 || err->resourceid == ATOM(_NET_SUPPORTING_WM_CHECK)

   624                 || err->resourceid == ATOM(KDE_FULL_SESSION)

   625                 || err->resourceid == ATOM(KWIN_RUNNING)

   626                 || err->resourceid == ATOM(XdndProxy)

   627                 || err->resourceid == ATOM(XdndAware))) {

   628             // Perhaps we're running under SECURITY reduction? :/

   629             return 0;

   630         }

   631         break;

   632 

   633     case BadWindow:

   634         if (err->request_code == 2 /* X_ChangeWindowAttributes */

   635             || err->request_code == 38 /* X_QueryPointer */) {

   636             for (int i = 0; i < ScreenCount(dpy); ++i) {

   637                 if (err->resourceid == RootWindow(dpy, i)) {

   638                     // Perhaps we're running under SECURITY reduction? :/

   639                     return 0;

   640                 }

   641             }

   642         }

   643         X11->seen_badwindow = true;

   644         if (err->request_code == 25 /* X_SendEvent */) {

   645             for (int i = 0; i < ScreenCount(dpy); ++i) {

   646                 if (err->resourceid == RootWindow(dpy, i)) {

   647                     // Perhaps we're running under SECURITY reduction? :/

   648                     return 0;

   649                 }

   650             }

   651             if (X11->xdndHandleBadwindow()) {

   652                 qDebug("xdndHandleBadwindow returned true");

   653                 return 0;

   654             }

   655         }

   656         if (X11->ignore_badwindow)

   657             return 0;

   658         break;

   659 

   660     case BadMatch:

   661         if (err->request_code == 42 /* X_SetInputFocus */)

   662             return 0;

   663         break;

   664 

   665     default:

   666 #if !defined(QT_NO_XINPUT)

   667         if (err->request_code == X11->xinput_major

   668             && err->error_code == (X11->xinput_errorbase + XI_BadDevice)

   669             && err->minor_code == 3 /* X_OpenDevice */) {

   670             return 0;

   671         }

   672 #endif

   673         break;

   674     }

   675 

   676     char errstr[256];

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

   678     char buffer[256];

   679     char request_str[256];

   680     qsnprintf(buffer, 256, "%d", err->request_code);

   681     XGetErrorDatabaseText(dpy, "XRequest", buffer, "", request_str, 256);

   682     if (err->request_code < 128) {

   683         // X error for a normal protocol request

   684         qWarning( "X Error: %s %d\n"

   685                   "  Major opcode: %d (%s)\n"

   686                   "  Resource id:  0x%lx",

   687                   errstr, err->error_code,

   688                   err->request_code,

   689                   request_str,

   690                   err->resourceid );

   691     } else {

   692         // X error for an extension request

   693         const char *extensionName = 0;

   694         if (err->request_code == X11->xrender_major)

   695             extensionName = "RENDER";

   696         else if (err->request_code == X11->xrandr_major)

   697             extensionName = "RANDR";

   698         else if (err->request_code == X11->xinput_major)

   699             extensionName = "XInputExtension";

   700         else if (err->request_code == X11->mitshm_major)

   701             extensionName = "MIT-SHM";

   702 

   703         char minor_str[256];

   704         if (extensionName) {

   705             qsnprintf(buffer, 256, "%s.%d", extensionName, err->minor_code);

   706             XGetErrorDatabaseText(dpy, "XRequest", buffer, "", minor_str, 256);

   707         } else {

   708             extensionName = "Uknown extension";

   709             qsnprintf(minor_str, 256, "Unknown request");

   710         }

   711         qWarning( "X Error: %s %d\n"

   712                   "  Extension:    %d (%s)\n"

   713                   "  Minor opcode: %d (%s)\n"

   714                   "  Resource id:  0x%lx",

   715                   errstr, err->error_code,

   716                   err->request_code,

   717                   extensionName,

   718                   err->minor_code,

   719                   minor_str,

   720                   err->resourceid );

   721     }

   722 

   723     // ### we really should distinguish between severe, non-severe and

   724     // ### application specific errors

   725 

   726     return 0;

   727 }

   728 

   729 

   730 static int qt_xio_errhandler(Display *)

   731 {

   732     qWarning("%s: Fatal IO error: client killed", appName);

   733     QApplicationPrivate::reset_instance_pointer();

   734     exit(1);

   735     //### give the application a chance for a proper shutdown instead,

   736     //### exit(1) doesn't help.

   737     return 0;

   738 }

   739 

   740 #if defined(Q_C_CALLBACKS)

   741 }

   742 #endif

   743 

   744 #ifndef QT_NO_XSYNC

   745 struct qt_sync_request_event_data

   746 {

   747     WId window;

   748 };

   749 

   750 #if defined(Q_C_CALLBACKS)

   751 extern "C" {

   752 #endif

   753 

   754 static Bool qt_sync_request_scanner(Display*, XEvent *event, XPointer arg)

   755 {

   756     qt_sync_request_event_data *data =

   757         reinterpret_cast<qt_sync_request_event_data*>(arg);

   758     if (event->type == ClientMessage &&

   759         event->xany.window == data->window &&

   760         event->xclient.message_type == ATOM(WM_PROTOCOLS) &&

   761         (Atom)event->xclient.data.l[0] == ATOM(_NET_WM_SYNC_REQUEST)) {

   762         QWidget *w = QWidget::find(event->xany.window);

   763         if (QTLWExtra *tlw = ((QETWidget*)w)->d_func()->maybeTopData()) {

   764             const ulong timestamp = (const ulong) event->xclient.data.l[1];

   765             if (timestamp > X11->time)

   766                 X11->time = timestamp;

   767             if (timestamp == CurrentTime || timestamp > tlw->syncRequestTimestamp) {

   768                 tlw->syncRequestTimestamp = timestamp;

   769                 tlw->newCounterValueLo = event->xclient.data.l[2];

   770                 tlw->newCounterValueHi = event->xclient.data.l[3];

   771             }

   772         }

   773         return true;

   774     }

   775     return false;

   776 }

   777 

   778 #if defined(Q_C_CALLBACKS)

   779 }

   780 #endif

   781 #endif // QT_NO_XSYNC

   782 

   783 static void qt_x11_create_intern_atoms()

   784 {

   785     const char *names[QX11Data::NAtoms];

   786     const char *ptr = x11_atomnames;

   787 

   788     int i = 0;

   789     while (*ptr) {

   790         names[i++] = ptr;

   791         while (*ptr)

   792             ++ptr;

   793         ++ptr;

   794     }

   795 

   796     Q_ASSERT(i == QX11Data::NPredefinedAtoms);

   797 

   798     QByteArray settings_atom_name("_QT_SETTINGS_TIMESTAMP_");

   799     settings_atom_name += XDisplayName(X11->displayName);

   800     names[i++] = settings_atom_name;

   801 

   802     Q_ASSERT(i == QX11Data::NAtoms);

   803 #if defined(XlibSpecificationRelease) && (XlibSpecificationRelease >= 6)

   804     XInternAtoms(X11->display, (char **)names, i, False, X11->atoms);

   805 #else

   806     for (i = 0; i < QX11Data::NAtoms; ++i)

   807         X11->atoms[i] = XInternAtom(X11->display, (char *)names[i], False);

   808 #endif

   809 }

   810 

   811 Q_GUI_EXPORT void qt_x11_apply_settings_in_all_apps()

   812 {

   813     QByteArray stamp;

   814     QDataStream s(&stamp, QIODevice::WriteOnly);

   815     s << QDateTime::currentDateTime();

   816 

   817     XChangeProperty(QX11Info::display(), QX11Info::appRootWindow(0),

   818                     ATOM(_QT_SETTINGS_TIMESTAMP), ATOM(_QT_SETTINGS_TIMESTAMP), 8,

   819                     PropModeReplace, (unsigned char *)stamp.data(), stamp.size());

   820 }

   821 

   822 /*! \internal

   823     apply the settings to the application

   824 */

   825 bool QApplicationPrivate::x11_apply_settings()

   826 {

   827     QSettings settings(QSettings::UserScope, QLatin1String("Trolltech"));

   828 

   829     settings.beginGroup(QLatin1String("Qt"));

   830 

   831     /*

   832       Qt settings. This is now they are written into the datastream.

   833 

   834       Palette / *                - QPalette

   835       font                       - QFont

   836       libraryPath                - QStringList

   837       style                      - QString

   838       doubleClickInterval        - int

   839       keyboardInputInterval  - int

   840       cursorFlashTime            - int

   841       wheelScrollLines           - int

   842       colorSpec                  - QString

   843       defaultCodec               - QString

   844       globalStrut/width          - int

   845       globalStrut/height         - int

   846       GUIEffects                 - QStringList

   847       Font Substitutions/ *      - QStringList

   848       Font Substitutions/...     - QStringList

   849     */

   850 

   851     QStringList strlist;

   852     int i;

   853     QPalette pal(Qt::black);

   854     int groupCount = 0;

   855     strlist = settings.value(QLatin1String("Palette/active")).toStringList();

   856     if (!strlist.isEmpty()) {

   857         ++groupCount;

   858         for (i = 0; i < qMin(strlist.count(), int(QPalette::NColorRoles)); i++)

   859             pal.setColor(QPalette::Active, (QPalette::ColorRole) i,

   860                          QColor(strlist[i]));

   861     }

   862     strlist = settings.value(QLatin1String("Palette/inactive")).toStringList();

   863     if (!strlist.isEmpty()) {

   864         ++groupCount;

   865         for (i = 0; i < qMin(strlist.count(), int(QPalette::NColorRoles)); i++)

   866             pal.setColor(QPalette::Inactive, (QPalette::ColorRole) i,

   867                          QColor(strlist[i]));

   868     }

   869     strlist = settings.value(QLatin1String("Palette/disabled")).toStringList();

   870     if (!strlist.isEmpty()) {

   871         ++groupCount;

   872         for (i = 0; i < qMin(strlist.count(), int(QPalette::NColorRoles)); i++)

   873             pal.setColor(QPalette::Disabled, (QPalette::ColorRole) i,

   874                          QColor(strlist[i]));

   875     }

   876 

   877     // ### Fix properly for 4.6

   878     bool usingGtkSettings = QApplicationPrivate::app_style && QApplicationPrivate::app_style->inherits("QGtkStyle");

   879     if (!usingGtkSettings) {

   880         if (groupCount == QPalette::NColorGroups)

   881             QApplicationPrivate::setSystemPalette(pal);

   882     }

   883 

   884     if (!appFont) {

   885         // ### Fix properly for 4.6

   886         if (!usingGtkSettings) {

   887             QFont font(QApplication::font());

   888             QString fontDescription;

   889             // Override Qt font if KDE4 settings can be used

   890             if (X11->desktopVersion == 4) {

   891                 QSettings kdeSettings(QKde::kdeHome() + QLatin1String("/share/config/kdeglobals"), QSettings::IniFormat);

   892                 fontDescription = kdeSettings.value(QLatin1String("font")).toString();

   893                 if (fontDescription.isEmpty()) {

   894                     // KDE stores fonts without quotes

   895                     fontDescription = kdeSettings.value(QLatin1String("font")).toStringList().join(QLatin1String(","));

   896                 }

   897             }

   898             if (fontDescription.isEmpty())

   899                 fontDescription = settings.value(QLatin1String("font")).toString();

   900             if (!fontDescription .isEmpty()) {

   901                 font.fromString(fontDescription );

   902                 QApplicationPrivate::setSystemFont(font);

   903             }

   904         }

   905     }

   906 

   907     // read library (ie. plugin) path list

   908     QString libpathkey =

   909         QString::fromLatin1("%1.%2/libraryPath")

   910         .arg(QT_VERSION >> 16)

   911         .arg((QT_VERSION & 0xff00) >> 8);

   912     QStringList pathlist = settings.value(libpathkey).toString().split(QLatin1Char(':'));

   913     if (! pathlist.isEmpty()) {

   914         QStringList::ConstIterator it = pathlist.constBegin();

   915         while (it != pathlist.constEnd())

   916             QApplication::addLibraryPath(*it++);

   917     }

   918 

   919     // read new QStyle

   920     QString stylename = settings.value(QLatin1String("style")).toString();

   921 

   922     if (stylename.isEmpty() && QApplicationPrivate::styleOverride.isNull() && X11->use_xrender) {

   923         stylename = qt_guiPlatformPlugin()->styleName();

   924     }

   925 

   926     static QString currentStyleName = stylename;

   927     if (QCoreApplication::startingUp()) {

   928         if (!stylename.isEmpty() && QApplicationPrivate::styleOverride.isNull())

   929             QApplicationPrivate::styleOverride = stylename;

   930     } else {

   931         if (currentStyleName != stylename) {

   932             currentStyleName = stylename;

   933             QApplication::setStyle(stylename);

   934         }

   935     }

   936 

   937     int num =

   938         settings.value(QLatin1String("doubleClickInterval"),

   939                        QApplication::doubleClickInterval()).toInt();

   940     QApplication::setDoubleClickInterval(num);

   941 

   942     num =

   943         settings.value(QLatin1String("cursorFlashTime"),

   944                        QApplication::cursorFlashTime()).toInt();

   945     QApplication::setCursorFlashTime(num);

   946 

   947     num =

   948         settings.value(QLatin1String("wheelScrollLines"),

   949                        QApplication::wheelScrollLines()).toInt();

   950     QApplication::setWheelScrollLines(num);

   951 

   952     QString colorspec = settings.value(QLatin1String("colorSpec"),

   953                                        QVariant(QLatin1String("default"))).toString();

   954     if (colorspec == QLatin1String("normal"))

   955         QApplication::setColorSpec(QApplication::NormalColor);

   956     else if (colorspec == QLatin1String("custom"))

   957         QApplication::setColorSpec(QApplication::CustomColor);

   958     else if (colorspec == QLatin1String("many"))

   959         QApplication::setColorSpec(QApplication::ManyColor);

   960     else if (colorspec != QLatin1String("default"))

   961         colorspec = QLatin1String("default");

   962 

   963     QString defaultcodec = settings.value(QLatin1String("defaultCodec"),

   964                                           QVariant(QLatin1String("none"))).toString();

   965     if (defaultcodec != QLatin1String("none")) {

   966         QTextCodec *codec = QTextCodec::codecForName(defaultcodec.toLatin1());

   967         if (codec)

   968             QTextCodec::setCodecForTr(codec);

   969     }

   970 

   971     int w = settings.value(QLatin1String("globalStrut/width")).toInt();

   972     int h = settings.value(QLatin1String("globalStrut/height")).toInt();

   973     QSize strut(w, h);

   974     if (strut.isValid())

   975         QApplication::setGlobalStrut(strut);

   976 

   977     QStringList effects = settings.value(QLatin1String("GUIEffects")).toStringList();

   978     QApplication::setEffectEnabled(Qt::UI_General,

   979                                    effects.contains(QLatin1String("general")));

   980     QApplication::setEffectEnabled(Qt::UI_AnimateMenu,

   981                                    effects.contains(QLatin1String("animatemenu")));

   982     QApplication::setEffectEnabled(Qt::UI_FadeMenu,

   983                                    effects.contains(QLatin1String("fademenu")));

   984     QApplication::setEffectEnabled(Qt::UI_AnimateCombo,

   985                                    effects.contains(QLatin1String("animatecombo")));

   986     QApplication::setEffectEnabled(Qt::UI_AnimateTooltip,

   987                                    effects.contains(QLatin1String("animatetooltip")));

   988     QApplication::setEffectEnabled(Qt::UI_FadeTooltip,

   989                                    effects.contains(QLatin1String("fadetooltip")));

   990     QApplication::setEffectEnabled(Qt::UI_AnimateToolBox,

   991                                    effects.contains(QLatin1String("animatetoolbox")));

   992 

   993     if (!X11->has_fontconfig) {

   994         settings.beginGroup(QLatin1String("Font Substitutions"));

   995         QStringList fontsubs = settings.childKeys();

   996         if (!fontsubs.isEmpty()) {

   997             QStringList::Iterator it = fontsubs.begin();

   998             for (; it != fontsubs.end(); ++it) {

   999                 QString fam = *it;

  1000                 QStringList subs = settings.value(fam).toStringList();

  1001                 QFont::insertSubstitutions(fam, subs);

  1002             }

  1003         }

  1004         settings.endGroup();

  1005     }

  1006 

  1007     qt_use_rtl_extensions =

  1008         settings.value(QLatin1String("useRtlExtensions"), false).toBool();

  1009 

  1010 #ifndef QT_NO_XIM

  1011     if (qt_xim_preferred_style == 0) {

  1012         QString ximInputStyle = settings.value(QLatin1String("XIMInputStyle"),

  1013                                                QVariant(QLatin1String("on the spot"))).toString().toLower();

  1014         if (ximInputStyle == QLatin1String("on the spot"))

  1015             qt_xim_preferred_style = XIMPreeditCallbacks | XIMStatusNothing;

  1016         else if (ximInputStyle == QLatin1String("over the spot"))

  1017             qt_xim_preferred_style = XIMPreeditPosition | XIMStatusNothing;

  1018         else if (ximInputStyle == QLatin1String("off the spot"))

  1019             qt_xim_preferred_style = XIMPreeditArea | XIMStatusArea;

  1020         else if (ximInputStyle == QLatin1String("root"))

  1021             qt_xim_preferred_style = XIMPreeditNothing | XIMStatusNothing;

  1022     }

  1023 #endif

  1024     QStringList inputMethods = QInputContextFactory::keys();

  1025     if (inputMethods.size() > 2 && inputMethods.contains(QLatin1String("imsw-multi"))) {

  1026         X11->default_im = QLatin1String("imsw-multi");

  1027     } else {

  1028         X11->default_im = settings.value(QLatin1String("DefaultInputMethod"),

  1029                                          QLatin1String("xim")).toString();

  1030     }

  1031 

  1032     settings.endGroup(); // Qt

  1033 

  1034     return true;

  1035 }

  1036 

  1037 

  1038 /*! \internal

  1039     Resets the QApplication::instance() pointer to zero

  1040 */

  1041 void QApplicationPrivate::reset_instance_pointer()

  1042 { QApplication::self = 0; }

  1043 

  1044 

  1045 // read the _QT_INPUT_ENCODING property and apply the settings to

  1046 // the application

  1047 static void qt_set_input_encoding()

  1048 {

  1049     Atom type;

  1050     int format;

  1051     ulong  nitems, after = 1;

  1052     unsigned char *data = 0;

  1053 

  1054     int e = XGetWindowProperty(X11->display, QX11Info::appRootWindow(),

  1055                                 ATOM(_QT_INPUT_ENCODING), 0, 1024,

  1056                                 False, XA_STRING, &type, &format, &nitems,

  1057                                 &after, &data);

  1058     if (e != Success || !nitems || type == XNone) {

  1059         // Always use the locale codec, since we have no examples of non-local

  1060         // XIMs, and since we cannot get a sensible answer about the encoding

  1061         // from the XIM.

  1062         qt_input_mapper = QTextCodec::codecForLocale();

  1063 

  1064     } else {

  1065         if (!qstricmp((char *)data, "locale"))

  1066             qt_input_mapper = QTextCodec::codecForLocale();

  1067         else

  1068             qt_input_mapper = QTextCodec::codecForName((char *)data);

  1069         // make sure we have an input codec

  1070         if(!qt_input_mapper)

  1071             qt_input_mapper = QTextCodec::codecForName("ISO 8859-1");

  1072     }

  1073     if (qt_input_mapper && qt_input_mapper->mibEnum() == 11) // 8859-8

  1074         qt_input_mapper = QTextCodec::codecForName("ISO 8859-8-I");

  1075     if(data)

  1076         XFree((char *)data);

  1077 }

  1078 

  1079 // set font, foreground and background from x11 resources. The

  1080 // arguments may override the resource settings.

  1081 static void qt_set_x11_resources(const char* font = 0, const char* fg = 0,

  1082                                  const char* bg = 0, const char* button = 0)

  1083 {

  1084 

  1085     QString resFont, resFG, resBG, resButton, resEF, sysFont, selectBackground, selectForeground;

  1086 

  1087     QApplication::setEffectEnabled(Qt::UI_General, false);

  1088     QApplication::setEffectEnabled(Qt::UI_AnimateMenu, false);

  1089     QApplication::setEffectEnabled(Qt::UI_FadeMenu, false);

  1090     QApplication::setEffectEnabled(Qt::UI_AnimateCombo, false);

  1091     QApplication::setEffectEnabled(Qt::UI_AnimateTooltip, false);

  1092     QApplication::setEffectEnabled(Qt::UI_FadeTooltip, false);

  1093     QApplication::setEffectEnabled(Qt::UI_AnimateToolBox, false);

  1094 

  1095     bool paletteAlreadySet = false;

  1096     if (QApplication::desktopSettingsAware()) {

  1097         // first, read from settings

  1098         QApplicationPrivate::x11_apply_settings();

  1099         // the call to QApplication::style() below creates the system

  1100         // palette, which breaks the logic after the RESOURCE_MANAGER

  1101         // loop... so I have to save this value to be able to use it later

  1102         paletteAlreadySet = (QApplicationPrivate::sys_pal != 0);

  1103 

  1104         // second, parse the RESOURCE_MANAGER property

  1105         int format;

  1106         ulong  nitems, after = 1;

  1107         QString res;

  1108         long offset = 0;

  1109         Atom type = XNone;

  1110 

  1111         while (after > 0) {

  1112             uchar *data = 0;

  1113             if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(0),

  1114                                    ATOM(RESOURCE_MANAGER),

  1115                                    offset, 8192, False, AnyPropertyType,

  1116                                    &type, &format, &nitems, &after,

  1117                                    &data) != Success) {

  1118                 res = QString();

  1119                 break;

  1120             }

  1121             if (type == XA_STRING)

  1122                 res += QString::fromLatin1((char*)data);

  1123             else

  1124                 res += QString::fromLocal8Bit((char*)data);

  1125             offset += 2048; // offset is in 32bit quantities... 8192/4 == 2048

  1126             if (data)

  1127                 XFree((char *)data);

  1128         }

  1129 

  1130         QString key, value;

  1131         int l = 0, r;

  1132         QString apn = QString::fromLocal8Bit(appName);

  1133         QString apc = QString::fromLocal8Bit(appClass);

  1134         int apnl = apn.length();