/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

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

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

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

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

// qapplication_win.cpp, which suggest a unification.

#include "qplatformdefs.h"

#include "qcolormap.h"

#include "qdesktopwidget.h"

#include "qapplication.h"

#include "qapplication_p.h"

#include "qcursor.h"

#include "qwidget.h"

#include "qbitarray.h"

#include "qpainter.h"

#include "qfile.h"

#include "qpixmapcache.h"

#include "qdatetime.h"

#include "qtextcodec.h"

#include "qdatastream.h"

#include "qbuffer.h"

#include "qsocketnotifier.h"

#include "qsessionmanager.h"

#include "qclipboard.h"

#include "qwhatsthis.h"

#include "qsettings.h"

#include "qstylefactory.h"

#include "qfileinfo.h"

#include "qdir.h"

#include "qhash.h"

#include "qevent.h"

#include "qevent_p.h"

#include "qvarlengtharray.h"

#include "qdebug.h"

#include <private/qunicodetables_p.h>

#include <private/qcrashhandler_p.h>

#include <private/qcolor_p.h>

#include <private/qcursor_p.h>

#include <private/qiconloader_p.h>

#include <qgtkstyle.h>

#include "qstyle.h"

#include "qmetaobject.h"

#include "qtimer.h"

#include "qlibrary.h"

#include <private/qgraphicssystemfactory_p.h>

#include "qguiplatformplugin_p.h"

#include "qkde_p.h"

#if !defined (QT_NO_TABLET)

extern "C" {

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

#   include <wacomcfg.h>

#   undef class

}

#endif

//#define ALIEN_DEBUG

#if !defined(QT_NO_GLIB)

#  include "qguieventdispatcher_glib_p.h"

#endif

#include "qeventdispatcher_x11_p.h"

#include <private/qpaintengine_x11_p.h>

#include <private/qkeymapper_p.h>

// Input method stuff

#ifndef QT_NO_IM

#include "qinputcontext.h"

#include "qinputcontextfactory.h"

#endif // QT_NO_IM

#ifndef QT_NO_XFIXES

#include <X11/extensions/Xfixes.h>

#endif // QT_NO_XFIXES

#include "qt_x11_p.h"

#include "qx11info_x11.h"

#define XK_MISCELLANY

#include <X11/keysymdef.h>

#if !defined(QT_NO_XINPUT)

#include <X11/extensions/XI.h>

#endif

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <locale.h>

#include "qwidget_p.h"

#include <private/qbackingstore_p.h>

#ifdef QT_RX71_MULTITOUCH

#  include <qsocketnotifier.h>

#  include <linux/input.h>

#  include <errno.h>

#endif

#if defined(Q_WS_MAEMO_5)

#  include <private/qmenu_maemo5_p.h>

#  include <QMenuBar>

#  include <QWidgetAction>

#endif

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

# define QT_NO_UNSETENV

#endif

QT_BEGIN_NAMESPACE

extern bool qt_sendSpontaneousEvent(QObject*,QEvent*);

//#define X_NOT_BROKEN

#ifdef X_NOT_BROKEN

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

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

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

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

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

// the real libC version.

//

# ifndef setlocale

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

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

{

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

    return setlocale(category,locale);

}

# endif // setlocale

#endif // X_NOT_BROKEN

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

static const char * x11_atomnames = {

    // window-manager <-> client protocols

    "WM_PROTOCOLS\0"

    "WM_DELETE_WINDOW\0"

    "WM_TAKE_FOCUS\0"

    "_NET_WM_PING\0"

    "_NET_WM_CONTEXT_HELP\0"

    "_NET_WM_SYNC_REQUEST\0"

    "_NET_WM_SYNC_REQUEST_COUNTER\0"

    // ICCCM window state

    "WM_STATE\0"

    "WM_CHANGE_STATE\0"

    // Session management

    "WM_CLIENT_LEADER\0"

    "WM_WINDOW_ROLE\0"

    "SM_CLIENT_ID\0"

    // Clipboard

    "CLIPBOARD\0"

    "INCR\0"

    "TARGETS\0"

    "MULTIPLE\0"

    "TIMESTAMP\0"

    "SAVE_TARGETS\0"

    "CLIP_TEMPORARY\0"

    "_QT_SELECTION\0"

    "_QT_CLIPBOARD_SENTINEL\0"

    "_QT_SELECTION_SENTINEL\0"

    "CLIPBOARD_MANAGER\0"

    "RESOURCE_MANAGER\0"

    "_XSETROOT_ID\0"

    "_QT_SCROLL_DONE\0"

    "_QT_INPUT_ENCODING\0"

    "_MOTIF_WM_HINTS\0"

    "DTWM_IS_RUNNING\0"

    "KDE_FULL_SESSION\0"

    "KWIN_RUNNING\0"

    "KWM_RUNNING\0"

    "GNOME_BACKGROUND_PROPERTIES\0"

    "ENLIGHTENMENT_DESKTOP\0"

    "_SGI_DESKS_MANAGER\0"

    // EWMH (aka NETWM)

    "_NET_SUPPORTED\0"

    "_NET_VIRTUAL_ROOTS\0"

    "_NET_WORKAREA\0"

    "_NET_MOVERESIZE_WINDOW\0"

    "_NET_WM_MOVERESIZE\0"

    "_NET_WM_NAME\0"

    "_NET_WM_ICON_NAME\0"

    "_NET_WM_ICON\0"

    "_NET_WM_PID\0"

    "_NET_WM_WINDOW_OPACITY\0"

    "_NET_WM_STATE\0"

    "_NET_WM_STATE_ABOVE\0"

    "_NET_WM_STATE_BELOW\0"

    "_NET_WM_STATE_FULLSCREEN\0"

    "_NET_WM_STATE_MAXIMIZED_HORZ\0"

    "_NET_WM_STATE_MAXIMIZED_VERT\0"

    "_NET_WM_STATE_MODAL\0"

    "_NET_WM_STATE_STAYS_ON_TOP\0"

    "_NET_WM_STATE_DEMANDS_ATTENTION\0"

    "_NET_WM_USER_TIME\0"

    "_NET_WM_USER_TIME_WINDOW\0"

    "_NET_WM_FULL_PLACEMENT\0"

    "_NET_WM_WINDOW_TYPE\0"

    "_NET_WM_WINDOW_TYPE_DESKTOP\0"

    "_NET_WM_WINDOW_TYPE_DOCK\0"

    "_NET_WM_WINDOW_TYPE_TOOLBAR\0"

    "_NET_WM_WINDOW_TYPE_MENU\0"

    "_NET_WM_WINDOW_TYPE_UTILITY\0"

    "_NET_WM_WINDOW_TYPE_SPLASH\0"

    "_NET_WM_WINDOW_TYPE_DIALOG\0"

    "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU\0"

    "_NET_WM_WINDOW_TYPE_POPUP_MENU\0"

    "_NET_WM_WINDOW_TYPE_TOOLTIP\0"

    "_NET_WM_WINDOW_TYPE_NOTIFICATION\0"

    "_NET_WM_WINDOW_TYPE_COMBO\0"

    "_NET_WM_WINDOW_TYPE_DND\0"

    "_NET_WM_WINDOW_TYPE_NORMAL\0"

    "_KDE_NET_WM_WINDOW_TYPE_OVERRIDE\0"

    "_KDE_NET_WM_FRAME_STRUT\0"

    "_NET_STARTUP_INFO\0"

    "_NET_STARTUP_INFO_BEGIN\0"

    "_NET_SUPPORTING_WM_CHECK\0"

    "_NET_WM_CM_S0\0"

    "_NET_SYSTEM_TRAY_VISUAL\0"

    "_NET_ACTIVE_WINDOW\0"

    // Property formats

    "COMPOUND_TEXT\0"

    "TEXT\0"

    "UTF8_STRING\0"

    // xdnd

    "XdndEnter\0"

    "XdndPosition\0"

    "XdndStatus\0"

    "XdndLeave\0"

    "XdndDrop\0"

    "XdndFinished\0"

    "XdndTypeList\0"

    "XdndActionList\0"

    "XdndSelection\0"

    "XdndAware\0"

    "XdndProxy\0"

    "XdndActionCopy\0"

    "XdndActionLink\0"

    "XdndActionMove\0"

    "XdndActionPrivate\0"

    // Motif DND

    "_MOTIF_DRAG_AND_DROP_MESSAGE\0"

    "_MOTIF_DRAG_INITIATOR_INFO\0"

    "_MOTIF_DRAG_RECEIVER_INFO\0"

    "_MOTIF_DRAG_WINDOW\0"

    "_MOTIF_DRAG_TARGETS\0"

    "XmTRANSFER_SUCCESS\0"

    "XmTRANSFER_FAILURE\0"

    // Xkb

    "_XKB_RULES_NAMES\0"

#ifdef Q_WS_MAEMO_5

    // Hildon Desktop (WM)

    "_HILDON_WM_WINDOW_TYPE_APP_MENU\0"

    "_HILDON_WM_WINDOW_TYPE_HOME_APPLET\0"

    "_HILDON_WM_WINDOW_MENU_INDICATOR\0"

    "_HILDON_WM_WINDOW_PROGRESS_INDICATOR\0"

    "_HILDON_NON_COMPOSITED_WINDOW\0"

    "_HILDON_PORTRAIT_MODE_REQUEST\0"

    "_HILDON_PORTRAIT_MODE_SUPPORT\0"

    "_HILDON_STACKABLE_WINDOW\0"

    "_HILDON_APPLET_ID\0"

    "_HILDON_ZOOM_KEY_ATOM\0"

    "_HILDON_NOTIFICATION_TYPE\0"

    "_NET_WM_CONTEXT_CUSTOM\0"

    "_MB_GRAB_TRANSFER\0"

    // Hildon Input Method

    "_HILDON_IM_WINDOW\0"                    // find the global im window

    "_HILDON_IM_ACTIVATE\0"                  // activate the input method

    "_HILDON_IM_SURROUNDING\0"               // send surrounding

    "_HILDON_IM_SURROUNDING_CONTENT\0"       // send surrounding header

    "_HILDON_IM_KEY_EVENT\0"                 // send key event to im

    "_HILDON_IM_INSERT_UTF8\0"               // input method wants to insert data

    "_HILDON_IM_COM\0"                       // input method wants to communicate with us

    "_HILDON_IM_CLIPBOARD_COPIED\0"          //### NOT USED YET

    "_HILDON_IM_CLIPBOARD_SELECTION_QUERY\0" //### NOT USED YET

    "_HILDON_IM_CLIPBOARD_SELECTION_REPLY\0" // tell im whether we have a selection or not

    "_HILDON_IM_INPUT_MODE\0"

    "_HILDON_IM_PREEDIT_COMMITTED\0"

    "_HILDON_IM_PREEDIT_COMMITTED_CONTENT\0"

#endif

    // XEMBED

    "_XEMBED\0"

    "_XEMBED_INFO\0"

    "Wacom Stylus\0"

    "Wacom Cursor\0"

    "Wacom Eraser\0"

};

Q_GUI_EXPORT QX11Data *qt_x11Data = 0;

/*****************************************************************************

  Internal variables and functions

 *****************************************************************************/

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

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

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

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

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

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

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

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

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

static bool        appSync                = false;        // X11 synchronization

#if defined(QT_DEBUG)

static bool        appNoGrab        = false;        // X11 grabbing enabled

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

#endif

static bool        app_save_rootinfo = false;        // save root info

static bool        app_do_modal        = false;        // modal mode

static Window        curWin = 0;                        // current window

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

extern void qt_desktopwidget_update_workarea();

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

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

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

// and/or keyboard layout changes

uchar qt_alt_mask = 0;

uchar qt_meta_mask = 0;

uchar qt_super_mask = 0;

uchar qt_hyper_mask = 0;

uchar qt_mode_switch_mask = 0;

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

bool         qt_use_rtl_extensions = false;

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

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

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

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

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

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

extern QWidgetList *qt_modal_stack;                // stack of modal widgets

// window where mouse buttons have been pressed

static Window pressed_window = XNone;

// popup control

static bool replayPopupMouseEvent = false;

static bool popupGrabOk;

bool qt_sm_blockUserInput = false;                // session management

Q_GUI_EXPORT int qt_xfocusout_grab_counter = 0;

#if !defined (QT_NO_TABLET)

Q_GLOBAL_STATIC(QTabletDeviceDataList, tablet_devices)

QTabletDeviceDataList *qt_tablet_devices()

{

    return tablet_devices();

}

extern bool qt_tabletChokeMouse;

#endif

static bool qt_x11EventFilter(XEvent* ev)

{

    long unused;

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

        return true;

    return qApp->x11EventFilter(ev);

}

#if !defined(QT_NO_XIM)

XIMStyle        qt_xim_preferred_style = 0;

#endif

int qt_ximComposingKeycode=0;

QTextCodec * qt_input_mapper = 0;

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

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

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

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

static void        qt_save_rootinfo();

Q_GUI_EXPORT bool qt_try_modal(QWidget *, XEvent *);

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

QPointer<QWidget> qt_last_mouse_receiver = 0;

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

extern bool qt_xdnd_dragging;

// gui or non-gui from qapplication.cpp

extern bool qt_is_gui_used;

/*!

    \internal

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

    by \a vernum.

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

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

    version.

*/

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

                                     int highestVernum, const char *symbol)

{

    QList<int> versions;

    // we try to load in the following order:

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

    if (vernum != -1)

        versions << vernum;

    versions << -1;

    if (vernum != -1) {

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

            versions << i;

    }

    Q_FOREACH(int version, versions) {

        QLatin1String libName(library);

        QLibrary xfixesLib(libName, version);

        if (xfixesLib.load()) {

            void *ptr = xfixesLib.resolve(symbol);

            if (ptr)

                return ptr;

        }

    }

    return 0;

}

#ifndef QT_NO_XINPUT

# ifdef QT_RUNTIME_XINPUT

#  define XINPUT_LOAD_RUNTIME(vernum, symbol, symbol_type) \

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

#  define XINPUT_LOAD(symbol) \

    XINPUT_LOAD_RUNTIME(1, symbol, Ptr##symbol)

# else // not runtime XInput

#  define XINPUT_LOAD(symbol) symbol

# endif // QT_RUNTIME_XINPUT

#else // not using Xinput at all

# define XINPUT_LOAD(symbol) 0

#endif // QT_NO_XINPUT

#ifndef QT_NO_XFIXES

# ifdef QT_RUNTIME_XFIXES

#  define XFIXES_LOAD_RUNTIME(vernum, symbol, symbol_type) \

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

#  define XFIXES_LOAD_V1(symbol) \

    XFIXES_LOAD_RUNTIME(1, symbol, Ptr##symbol)

#  define XFIXES_LOAD_V2(symbol) \

    XFIXES_LOAD_RUNTIME(2, symbol, Ptr##symbol)

# else // not runtime Xfixes

#  if XFIXES_MAJOR >= 2

#   define XFIXES_LOAD_V1(symbol) symbol

#   define XFIXES_LOAD_V2(symbol) symbol

#  elif XFIXES_MAJOR >= 1

#   define XFIXES_LOAD_V1(symbol) symbol

#   define XFIXES_LOAD_V2(symbol) 0

#  else

#   error Unsupported version of Xfixes

#  endif

# endif // QT_RUNTIME_XFIXES

#else // not using Xfixes at all

# define XFIXES_LOAD_V1(symbol) 0

# define XFIXES_LOAD_V2(symbol) 0

#endif // QT_NO_XFIXES

#ifndef QT_NO_XFIXES

struct qt_xfixes_selection_event_data

{

    // which selection to filter out.

    Atom selection;

};

#if defined(Q_C_CALLBACKS)

extern "C" {

#endif

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

{

    qt_xfixes_selection_event_data *data =

        reinterpret_cast<qt_xfixes_selection_event_data*>(arg);

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

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

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

            return true;

    }

    return false;

}

#if defined(Q_C_CALLBACKS)

}

#endif

#endif // QT_NO_XFIXES

/*

 *  This class is used to access some protected values inside each QWidget.

 *  Warning: this class is never instantiated. Instead widgets are casted to QETWidgets.

 *  So don't try to add instance variables here.

 */

class QETWidget : public QWidget                // event translator widget

{

public:

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

    bool translateMouseEvent(const XEvent *);

    void translatePaintEvent(const XEvent *);

    bool translateConfigEvent(const XEvent *);

    bool translateCloseEvent(const XEvent *);

    bool translateScrollDoneEvent(const XEvent *);

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

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

#if !defined (QT_NO_TABLET)

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

#endif

    bool translatePropertyEvent(const XEvent *);

    void doDeferredMap()

    {

        Q_ASSERT(testAttribute(Qt::WA_WState_Created));

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

            adjustSize();

            setAttribute(Qt::WA_Resized, false);

        }

        /*

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

          window->hide();

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

          window->show();

        */

        QRect r = geometry();

        XMoveResizeWindow(X11->display,

                          internalWinId(),

                          r.x(),

                          r.y(),

                          r.width(),

                          r.height());

        // static gravity!

        XSizeHints sh;

        long unused;

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

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

        sh.x = r.x();

        sh.y = r.y();

        sh.width = r.width();

        sh.height = r.height();

        sh.win_gravity = StaticGravity;

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

        setAttribute(Qt::WA_Mapped);

        if (testAttribute(Qt::WA_DontShowOnScreen))

            return;

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

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

    }

};

#if defined(Q_WS_MAEMO_5)

/*

 *  Class to handle long tap events on Maemo 5.

 *  Long taps are converted into right click and context menu events.

 */

class QLongTapTimerHandler : public QObject

{

public:

    QLongTapTimerHandler(QObject *parent)

        : QObject(parent), timerId(0)

    { }

    void start( QETWidget* w )

    {

        lastWidget = w;

        timerId = startTimer(LONG_TAP_TIME_INTERVAL);

    }

    void stop()

    {

        if (timerId)

            killTimer(timerId);

        timerId = 0;

    }

    enum { LONG_TAP_TIME_INTERVAL = 1100 };

    enum { LONG_TAP_MAX_DIST = 15 };

    int timerId;

    QPointer<QETWidget> lastWidget;

protected:

     void timerEvent(QTimerEvent *event);

};

// singleton

static QLongTapTimerHandler *longTapHandler = 0;

#endif

void QApplicationPrivate::createEventDispatcher()

{

    Q_Q(QApplication);

#if !defined(QT_NO_GLIB)

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

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

                           ? new QGuiEventDispatcherGlib(q)

                           : new QEventDispatcherGlib(q));

    else

#endif

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

                           ? new QEventDispatcherX11(q)

                           : new QEventDispatcherUNIX(q));

}

/*****************************************************************************

  Default X error handlers

 *****************************************************************************/

#if defined(Q_C_CALLBACKS)

extern "C" {

#endif

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

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

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

{

    switch (err->error_code) {

    case BadAtom:

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

            && (err->resourceid == XA_RESOURCE_MANAGER

                || err->resourceid == XA_RGB_DEFAULT_MAP

                || 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))) {

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

            return 0;

        }

        break;

    case BadWindow:

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

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

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

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

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

                    return 0;

                }

            }

        }

        X11->seen_badwindow = true;

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

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

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

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

                    return 0;

                }

            }

            if (X11->xdndHandleBadwindow()) {

                qDebug("xdndHandleBadwindow returned true");

                return 0;

            }

        }

        if (X11->ignore_badwindow)

            return 0;

        break;

    case BadMatch:

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

            return 0;

        break;

    default:

#if !defined(QT_NO_XINPUT)

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

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

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

            return 0;

        }

#endif

        break;

    }

    char errstr[256];

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

    char buffer[256];

    char request_str[256];

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

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

    if (err->request_code < 128) {

        // X error for a normal protocol request

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

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

                  "  Resource id:  0x%lx",

                  errstr, err->error_code,

                  err->request_code,

                  request_str,

                  err->resourceid );

    } else {

        // X error for an extension request

        const char *extensionName = 0;

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

            extensionName = "RENDER";

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

            extensionName = "RANDR";

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

            extensionName = "XInputExtension";

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

            extensionName = "MIT-SHM";

        char minor_str[256];

        if (extensionName) {

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

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

        } else {

            extensionName = "Uknown extension";

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

        }

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

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

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

                  "  Resource id:  0x%lx",

                  errstr, err->error_code,

                  err->request_code,

                  extensionName,

                  err->minor_code,

                  minor_str,

                  err->resourceid );

    }

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

    // ### application specific errors

    return 0;

}

static int qt_xio_errhandler(Display *)

{

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

    QApplicationPrivate::reset_instance_pointer();

    exit(1);

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

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

    return 0;

}

#if defined(Q_C_CALLBACKS)

}

#endif

#ifndef QT_NO_XSYNC

struct qt_sync_request_event_data

{

    WId window;

};

#if defined(Q_C_CALLBACKS)

extern "C" {

#endif

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

{

    qt_sync_request_event_data *data =

        reinterpret_cast<qt_sync_request_event_data*>(arg);

    if (event->type == ClientMessage &&

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

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

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

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

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

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

            if (timestamp > X11->time)

                X11->time = timestamp;

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

                tlw->syncRequestTimestamp = timestamp;

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

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

            }

        }

        return true;

    }

    return false;

}

#if defined(Q_C_CALLBACKS)

}

#endif

#endif // QT_NO_XSYNC

static void qt_x11_create_intern_atoms()

{

    const char *names[QX11Data::NAtoms];

    const char *ptr = x11_atomnames;

    int i = 0;

    while (*ptr) {

        names[i++] = ptr;

        while (*ptr)

            ++ptr;

        ++ptr;

    }

    Q_ASSERT(i == QX11Data::NPredefinedAtoms);

    QByteArray settings_atom_name("_QT_SETTINGS_TIMESTAMP_");

    settings_atom_name += XDisplayName(X11->displayName);

    names[i++] = settings_atom_name;

    Q_ASSERT(i == QX11Data::NAtoms);

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

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

#else

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

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

#endif

}

Q_GUI_EXPORT void qt_x11_apply_settings_in_all_apps()

{

    QByteArray stamp;

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

    s << QDateTime::currentDateTime();

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

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

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

}

/*! \internal

    apply the settings to the application

*/

bool QApplicationPrivate::x11_apply_settings()

{

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

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

    /*

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

      Palette / *                - QPalette

      font                       - QFont

      libraryPath                - QStringList

      style                      - QString

      doubleClickInterval        - int

      keyboardInputInterval  - int

      cursorFlashTime            - int

      wheelScrollLines           - int

      colorSpec                  - QString

      defaultCodec               - QString

      globalStrut/width          - int

      globalStrut/height         - int

      GUIEffects                 - QStringList

      Font Substitutions/ *      - QStringList

      Font Substitutions/...     - QStringList

    */

    QStringList strlist;

    int i;

    QPalette pal(Qt::black);

    int groupCount = 0;

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

    if (!strlist.isEmpty()) {

        ++groupCount;

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

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

                         QColor(strlist[i]));

    }

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

    if (!strlist.isEmpty()) {

        ++groupCount;

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

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

                         QColor(strlist[i]));

    }

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

    if (!strlist.isEmpty()) {

        ++groupCount;

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

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

                         QColor(strlist[i]));

    }

    // ### Fix properly for 4.6

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

    if (!usingGtkSettings) {

        if (groupCount == QPalette::NColorGroups)

            QApplicationPrivate::setSystemPalette(pal);

    }

    if (!appFont) {

        // ### Fix properly for 4.6

        if (!usingGtkSettings) {

            QFont font(QApplication::font());

            QString fontDescription;

            // Override Qt font if KDE4 settings can be used

            if (X11->desktopVersion == 4) {

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

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

                if (fontDescription.isEmpty()) {

                    // KDE stores fonts without quotes

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

                }

            }

            if (fontDescription.isEmpty())

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

            if (!fontDescription .isEmpty()) {

                font.fromString(fontDescription );

                QApplicationPrivate::setSystemFont(font);

            }

        }

    }

    // read library (ie. plugin) path list

    QString libpathkey =

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

        .arg(QT_VERSION >> 16)

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

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

    if (! pathlist.isEmpty()) {

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

        while (it != pathlist.constEnd())

            QApplication::addLibraryPath(*it++);

    }

    // read new QStyle

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

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

        stylename = qt_guiPlatformPlugin()->styleName();

    }

    static QString currentStyleName = stylename;

    if (QCoreApplication::startingUp()) {

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

            QApplicationPrivate::styleOverride = stylename;

    } else {

        if (currentStyleName != stylename) {

            currentStyleName = stylename;

            QApplication::setStyle(stylename);

        }

    }

    int num =

        settings.value(QLatin1String("doubleClickInterval"),

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

    QApplication::setDoubleClickInterval(num);

#if defined(Q_WS_MAEMO_5)

    num = 0;

#else

    num =

        settings.value(QLatin1String("cursorFlashTime"),

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

#endif

    QApplication::setCursorFlashTime(num);

    num =

        settings.value(QLatin1String("wheelScrollLines"),

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

    QApplication::setWheelScrollLines(num);

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

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

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

        QApplication::setColorSpec(QApplication::NormalColor);

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

        QApplication::setColorSpec(QApplication::CustomColor);

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

        QApplication::setColorSpec(QApplication::ManyColor);

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

        colorspec = QLatin1String("default");

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

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

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

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

        if (codec)

            QTextCodec::setCodecForTr(codec);

    }

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

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

    QSize strut(w, h);

    if (strut.isValid())

        QApplication::setGlobalStrut(strut);

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

    QApplication::setEffectEnabled(Qt::UI_General,

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

    QApplication::setEffectEnabled(Qt::UI_AnimateMenu,

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

    QApplication::setEffectEnabled(Qt::UI_FadeMenu,

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

    QApplication::setEffectEnabled(Qt::UI_AnimateCombo,

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

    QApplication::setEffectEnabled(Qt::UI_AnimateTooltip,

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

    QApplication::setEffectEnabled(Qt::UI_FadeTooltip,

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

    QApplication::setEffectEnabled(Qt::UI_AnimateToolBox,

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

    if (!X11->has_fontconfig) {

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

        QStringList fontsubs = settings.childKeys();

        if (!fontsubs.isEmpty()) {

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

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

                QString fam = *it;

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

                QFont::insertSubstitutions(fam, subs);

            }

        }

        settings.endGroup();

    }

    qt_use_rtl_extensions =

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

#ifndef QT_NO_XIM

    if (qt_xim_preferred_style == 0) {

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

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

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

            qt_xim_preferred_style = XIMPreeditCallbacks | XIMStatusNothing;

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

            qt_xim_preferred_style = XIMPreeditPosition | XIMStatusNothing;

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

            qt_xim_preferred_style = XIMPreeditArea | XIMStatusArea;

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

            qt_xim_preferred_style = XIMPreeditNothing | XIMStatusNothing;

    }

#endif

    QStringList inputMethods = QInputContextFactory::keys();

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

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

    } else {

#ifndef Q_WS_MAEMO_5

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

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

#else

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

                                         QLatin1String("hildon")).toString();

#endif

    }

    settings.endGroup(); // Qt

    return true;

}

/*! \internal

    Resets the QApplication::instance() pointer to zero

*/

void QApplicationPrivate::reset_instance_pointer()

{ QApplication::self = 0; }

// read the _QT_INPUT_ENCODING property and apply the settings to

// the application

static void qt_set_input_encoding()

{

    Atom type;

    int format;

    ulong  nitems, after = 1;

    unsigned char *data = 0;

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

                                ATOM(_QT_INPUT_ENCODING), 0, 1024,

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

                                &after, &data);

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

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

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

        // from the XIM.

        qt_input_mapper = QTextCodec::codecForLocale();

    } else {

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

            qt_input_mapper = QTextCodec::codecForLocale();

        else

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

        // make sure we have an input codec

        if(!qt_input_mapper)

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

    }

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

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

    if(data)

        XFree((char *)data);

}

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

// arguments may override the resource settings.

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

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

{

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

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

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

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

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

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

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

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

    bool paletteAlreadySet = false;

    if (QApplication::desktopSettingsAware()) {

        // first, read from settings

        QApplicationPrivate::x11_apply_settings();

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

        // palette, which breaks the logic after the RESOURCE_MANAGER

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

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

        // second, parse the RESOURCE_MANAGER property

        int format;

        ulong  nitems, after = 1;

        QString res;

        long offset = 0;

        Atom type = XNone;

        while (after > 0) {

            uchar *data = 0;

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

                                   ATOM(RESOURCE_MANAGER),

                                   offset, 8192, False, AnyPropertyType,

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

                                   &data) != Success) {

                res = QString();

                break;

            }

            if (type == XA_STRING)

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

            else

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

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

            if (data)

                XFree((char *)data);

        }

        QString key, value;

        int l = 0, r;

        QString apn = QString::fromLocal8Bit(appName);

        QString apc = QString::fromLocal8Bit(appClass);

        int apnl = apn.length();

        int apcl = apc.length();

        int resl = res.length();

        while (l < resl) {

            r = res.indexOf(QLatin1Char('\n'), l);

            if (r < 0)

                r = resl;

            while (res.at(l).isSpace())

                l++;

            bool mine = false;

            QChar sc = res.at(l + 1);

            if (res.at(l) == QLatin1Char('*') &&

                (sc == QLatin1Char('f') || sc == QLatin1Char('b') || sc == QLatin1Char('g') ||

                 sc == QLatin1Char('F') || sc == QLatin1Char('B') || sc == QLatin1Char('G') ||

                 sc == QLatin1Char('s') || sc == QLatin1Char('S')

                 // capital T only, since we're looking for "Text.selectSomething"

                 || sc == QLatin1Char('T'))) {

                // OPTIMIZED, since we only want "*[fbgsT].."

                QString item = res.mid(l, r - l).simplified();

                int i = item.indexOf(QLatin1Char(':'));

                key = item.left(i).trimmed().mid(1).toLower();

                value = item.right(item.length() - i - 1).trimmed();

                mine = true;

            } else if ((apnl && res.at(l) == apn.at(0)) || (appClass && apcl && res.at(l) == apc.at(0))) {

                if (res.mid(l,apnl) == apn && (res.at(l+apnl) == QLatin1Char('.')

                                               || res.at(l+apnl) == QLatin1Char('*'))) {

                    QString item = res.mid(l, r - l).simplified();

                    int i = item.indexOf(QLatin1Char(':'));

                    key = item.left(i).trimmed().mid(apnl+1).toLower();

                    value = item.right(item.length() - i - 1).trimmed();

                    mine = true;

                } else if (res.mid(l,apcl) == apc && (res.at(l+apcl) == QLatin1Char('.')

                                                      || res.at(l+apcl) == QLatin1Char('*'))) {

                    QString item = res.mid(l, r - l).simplified();

                    int i = item.indexOf(QLatin1Char(':'));

                    key = item.left(i).trimmed().mid(apcl+1).toLower();

                    value = item.right(item.length() - i - 1).trimmed();

                    mine = true;

                }

            }

            if (mine) {

                if (!font && key == QLatin1String("systemfont"))

                    sysFont = value.left(value.lastIndexOf(QLatin1Char(':')));

                if (!font && key == QLatin1String("font"))

                    resFont = value;

                else if (!fg && !paletteAlreadySet) {

                    if (key == QLatin1String("foreground"))

                        resFG = value;

                    else if (!bg && key == QLatin1String("background"))

                        resBG = value;

                    else if (!bg && !button && key == QLatin1String("button.background"))

                        resButton = value;

                    else if (key == QLatin1String("text.selectbackground")) {

                        selectBackground = value;

                    } else if (key == QLatin1String("text.selectforeground")) {

                        selectForeground = value;

                    }

                } else if (key == QLatin1String("guieffects"))

                    resEF = value;

                // NOTE: if you add more, change the [fbg] stuff above

            }

            l = r + 1;

        }

    }

    if (!sysFont.isEmpty())

        resFont = sysFont;

    if (resFont.isEmpty())

        resFont = QString::fromLocal8Bit(font);

    if (resFG.isEmpty())

        resFG = QString::fromLocal8Bit(fg);

    if (resBG.isEmpty())

        resBG = QString::fromLocal8Bit(bg);

    if (resButton.isEmpty())

        resButton = QString::fromLocal8Bit(button);

    if (!resFont.isEmpty()

        && !X11->has_fontconfig

        && !QApplicationPrivate::sys_font) {

        // set application font

        QFont fnt;

        fnt.setRawName(resFont);

        // the font we get may actually be an alias for another font,

        // so we reset the application font to the real font info.

        if (! fnt.exactMatch()) {

            QFontInfo fontinfo(fnt);

            fnt.setFamily(fontinfo.family());

            fnt.setRawMode(fontinfo.rawMode());

            if (! fnt.rawMode()) {

                fnt.setItalic(fontinfo.italic());

                fnt.setWeight(fontinfo.weight());

                fnt.setUnderline(fontinfo.underline());

                fnt.setStrikeOut(fontinfo.strikeOut());

                fnt.setStyleHint(fontinfo.styleHint());

                if (fnt.pointSize() <= 0 && fnt.pixelSize() <= 0) {

                    // size is all wrong... fix it

                    qreal pointSize = fontinfo.pixelSize() * 72. / (float) QX11Info::appDpiY();

                    if (pointSize <= 0)

                        pointSize = 12;

                    fnt.setPointSize(qRound(pointSize));

                }

            }

        }

        QApplicationPrivate::setSystemFont(fnt);

    }

    // QGtkStyle sets it's own system palette

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

    bool kdeColors = (QApplication::desktopSettingsAware() && X11->desktopEnvironment == DE_KDE);

    if (!gtkStyle && (kdeColors || (button || !resBG.isEmpty() || !resFG.isEmpty()))) {// set app colors

        bool allowX11ColorNames = QColor::allowX11ColorNames();

        QColor::setAllowX11ColorNames(true);

        (void) QApplication::style();  // trigger creation of application style and system palettes

        QColor btn;

        QColor bg;

        QColor fg;

        QColor bfg;

        QColor wfg;

        if (!resBG.isEmpty())

            bg = QColor(resBG);

        if (!bg.isValid())

            bg = QApplicationPrivate::sys_pal->color(QPalette::Active, QPalette::Window);

        if (!resFG.isEmpty())

            fg = QColor(resFG);

        if (!fg.isValid())

            fg = QApplicationPrivate::sys_pal->color(QPalette::Active, QPalette::WindowText);

        if (!resButton.isEmpty())

            btn = QColor(resButton);

        else if (!resBG.isEmpty())

            btn = bg;

        if (!btn.isValid())

            btn = QApplicationPrivate::sys_pal->color(QPalette::Active, QPalette::Button);

        int h,s,v;

        fg.getHsv(&h,&s,&v);

        QColor base = Qt::white;

        bool bright_mode = false;

        if (v >= 255 - 50) {

            base = btn.darker(150);

            bright_mode = true;

        }

        QPalette pal(fg, btn, btn.lighter(125), btn.darker(130), btn.darker(120), wfg.isValid() ? wfg : fg, Qt::white, base, bg);

        QColor disabled((fg.red()   + btn.red())  / 2,

                        (fg.green() + btn.green())/ 2,

                        (fg.blue()  + btn.blue()) / 2);

        pal.setColorGroup(QPalette::Disabled, disabled, btn, btn.lighter(125),

                          btn.darker(130), btn.darker(150), disabled, Qt::white, Qt::white, bg);

        QColor highlight, highlightText;

        if (!selectBackground.isEmpty() && !selectForeground.isEmpty()) {

            highlight = QColor(selectBackground);

            highlightText = QColor(selectForeground);

        }

        if (highlight.isValid() && highlightText.isValid()) {

            pal.setColor(QPalette::Highlight, highlight);

            pal.setColor(QPalette::HighlightedText, highlightText);

            // calculate disabled colors by removing saturation

            highlight.setHsv(highlight.hue(), 0, highlight.value(), highlight.alpha());

            highlightText.setHsv(highlightText.hue(), 0, highlightText.value(), highlightText.alpha());

            pal.setColor(QPalette::Disabled, QPalette::Highlight, highlight);

            pal.setColor(QPalette::Disabled, QPalette::HighlightedText, highlightText);

        } else if (bright_mode) {

            pal.setColor(QPalette::HighlightedText, base);

            pal.setColor(QPalette::Highlight, Qt::white);

            pal.setColor(QPalette::Disabled, QPalette::HighlightedText, base);

            pal.setColor(QPalette::Disabled, QPalette::Highlight, Qt::white);

        } else {

            pal.setColor(QPalette::HighlightedText, Qt::white);

            pal.setColor(QPalette::Highlight, Qt::darkBlue);

            pal.setColor(QPalette::Disabled, QPalette::HighlightedText, Qt::white);

            pal.setColor(QPalette::Disabled, QPalette::Highlight, Qt::darkBlue);

        }

        pal = qt_guiPlatformPlugin()->palette().resolve(pal);

        QApplicationPrivate::setSystemPalette(pal);

        QColor::setAllowX11ColorNames(allowX11ColorNames);

    }

    if (!resEF.isEmpty()) {

        QStringList effects = resEF.split(QLatin1Char(' '));

        QApplication::setEffectEnabled(Qt::UI_General, effects.contains(QLatin1String("general")));

        QApplication::setEffectEnabled(Qt::UI_AnimateMenu,

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

        QApplication::setEffectEnabled(Qt::UI_FadeMenu,

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

        QApplication::setEffectEnabled(Qt::UI_AnimateCombo,

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

        QApplication::setEffectEnabled(Qt::UI_AnimateTooltip,

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

        QApplication::setEffectEnabled(Qt::UI_FadeTooltip,

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

        QApplication::setEffectEnabled(Qt::UI_AnimateToolBox,

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

    }

    QIconLoader::instance()->updateSystemTheme();

}

// update the supported array

static void qt_get_net_supported()

{

    Atom type;

    int format;

    long offset = 0;

    unsigned long nitems, after;

    unsigned char *data = 0;

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

                               ATOM(_NET_SUPPORTED), 0, 0,

                               False, XA_ATOM, &type, &format, &nitems, &after, &data);

    if (data)

        XFree(data);

    if (X11->net_supported_list)

        delete [] X11->net_supported_list;

    X11->net_supported_list = 0;

    if (e == Success && type == XA_ATOM && format == 32) {

        QBuffer ts;

        ts.open(QIODevice::WriteOnly);

        while (after > 0) {

            XGetWindowProperty(X11->display, QX11Info::appRootWindow(),

                               ATOM(_NET_SUPPORTED), offset, 1024,

                               False, XA_ATOM, &type, &format, &nitems, &after, &data);

            if (type == XA_ATOM && format == 32) {

                ts.write(reinterpret_cast<char *>(data), nitems * sizeof(long));

                offset += nitems;

            } else

                after = 0;

            if (data)

                XFree(data);

        }

        // compute nitems

        QByteArray buffer(ts.buffer());

        nitems = buffer.size() / sizeof(Atom);

        X11->net_supported_list = new Atom[nitems + 1];

        Atom *a = (Atom *) buffer.data();

        uint i;

        for (i = 0; i < nitems; i++)

            X11->net_supported_list[i] = a[i];

        X11->net_supported_list[nitems] = 0;

    }

}

bool QX11Data::isSupportedByWM(Atom atom)

{

    if (!X11->net_supported_list)

        return false;

    bool supported = false;

    int i = 0;

    while (X11->net_supported_list[i] != 0) {

        if (X11->net_supported_list[i++] == atom) {

            supported = true;

            break;

        }

    }

    return supported;

}

// update the virtual roots array

static void qt_get_net_virtual_roots()

{

    if (X11->net_virtual_root_list)

        delete [] X11->net_virtual_root_list;

    X11->net_virtual_root_list = 0;

    if (!X11->isSupportedByWM(ATOM(_NET_VIRTUAL_ROOTS)))

        return;

    Atom type;

    int format;

    long offset = 0;

    unsigned long nitems, after;

    unsigned char *data;

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

                               ATOM(_NET_VIRTUAL_ROOTS), 0, 0,

                               False, XA_ATOM, &type, &format, &nitems, &after, &data);

    if (data)

        XFree(data);

    if (e == Success && type == XA_ATOM && format == 32) {

        QBuffer ts;

        ts.open(QIODevice::WriteOnly);

        while (after > 0) {

            XGetWindowProperty(X11->display, QX11Info::appRootWindow(),

                               ATOM(_NET_VIRTUAL_ROOTS), offset, 1024,

                               False, XA_ATOM, &type, &format, &nitems, &after, &data);

            if (type == XA_ATOM && format == 32) {

                ts.write(reinterpret_cast<char *>(data), nitems * 4);

                offset += nitems;

            } else

                after = 0;

            if (data)

                XFree(data);

        }

        // compute nitems

        QByteArray buffer(ts.buffer());

        nitems = buffer.size() / sizeof(Window);

        X11->net_virtual_root_list = new Window[nitems + 1];

        Window *a = (Window *) buffer.data();

        uint i;

        for (i = 0; i < nitems; i++)

            X11->net_virtual_root_list[i] = a[i];

        X11->net_virtual_root_list[nitems] = 0;

    }

}

void qt_net_remove_user_time(QWidget *tlw)

{

    Q_ASSERT(tlw);

    QTLWExtra *extra = tlw->d_func()->maybeTopData();

    if (extra && extra->userTimeWindow) {

        Q_ASSERT(tlw->internalWinId());

        XDeleteProperty(X11->display, tlw->internalWinId(), ATOM(_NET_WM_USER_TIME_WINDOW));

        XDestroyWindow(X11->display, extra->userTimeWindow);

        extra->userTimeWindow = 0;

    }

}

void qt_net_update_user_time(QWidget *tlw, unsigned long timestamp)

{

    Q_ASSERT(tlw);

    Q_ASSERT(tlw->isWindow());

    Q_ASSERT(tlw->testAttribute(Qt::WA_WState_Created));

    QTLWExtra *extra = tlw->d_func()->topData();

    WId wid = tlw->internalWinId();

    const bool isSupportedByWM = X11->isSupportedByWM(ATOM(_NET_WM_USER_TIME_WINDOW));

    if (extra->userTimeWindow || isSupportedByWM) {

        if (!extra->userTimeWindow) {

            extra->userTimeWindow = XCreateSimpleWindow(X11->display,

                                                        tlw->internalWinId(),

                                                        -1, -1, 1, 1, 0, 0, 0);