src/gui/kernel/qapplication_x11.cpp File Reference

#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 "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 "qstyle.h"
#include "qmetaobject.h"
#include "qguieventdispatcher_glib_p.h"
#include "qeventdispatcher_x11_p.h"
#include <private/qpaintengine_x11_p.h>
#include <private/qkeymapper_p.h>
#include "qinputcontext.h"
#include "qinputcontextfactory.h"
#include <X11/extensions/Xfixes.h>
#include "qt_x11_p.h"
#include "qx11info_x11.h"
#include <X11/keysymdef.h>
#include <X11/extensions/XI.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <locale.h>
#include "qwidget_p.h"
#include <private/qbackingstore_p.h>
#include <X11/SM/SMlib.h>
#include "qapplication_x11.moc"

Include dependency graph for qapplication_x11.cpp:

Go to the source code of this file.

Classes
class	QETWidget
struct	PaintEventInfo
class	QSessionManagerPrivate
class	QSmSocketReceiver
struct	QT_smcConn
Defines
#define	XK_MISCELLANY
Functions
static void	qt_detect_broken_window_manager ()
void	qt_desktopwidget_update_workarea ()
QTabletDeviceDataList *	qt_tablet_devices ()
static bool	qt_x11EventFilter (XEvent *ev)
bool	qt_check_clipboard_sentinel ()
bool	qt_check_selection_sentinel ()
static void	qt_save_rootinfo ()
Q_GUI_EXPORT bool	qt_try_modal (QWidget *, XEvent *)
static int	qt_x_errhandler (Display *dpy, XErrorEvent *err)
static int	qt_xio_errhandler (Display *)
static void	qt_x11_create_intern_atoms ()
Q_GUI_EXPORT void	qt_x11_apply_settings_in_all_apps ()
static void	qt_set_input_encoding ()
static void	qt_set_x11_resources (const char *font=0, const char *fg=0, const char *bg=0, const char *button=0)
static void	qt_get_net_supported ()
bool	qt_net_supports (Atom atom)
static void	qt_get_net_virtual_roots ()
static void	qt_net_update_user_time (QWidget *tlw)
static void	qt_check_focus_model ()
static bool	isXInputSupported (Display *dpy)
static void	getXDefault (const char *group, const char *key, int *val)
static void	getXDefault (const char *group, const char *key, double *val)
static void	getXDefault (const char *group, const char *key, bool *val)
void	qt_init (QApplicationPrivate *priv, int, Display *display, Qt::HANDLE visual, Qt::HANDLE colormap)
void	qt_cleanup ()
void	qt_updated_rootinfo ()
bool	qt_wstate_iconified (WId winid)
bool	qt_nograb ()
void	qt_x11_enforce_cursor (QWidget *w)
void	qPRCreate (const QWidget *widget, Window oldwin)
void	qPRCleanup (QWidget *widget)
static QETWidget *	qPRFindWidget (Window oldwin)
static Qt::MouseButtons	translateMouseButtons (int s)
static Bool	isPaintOrScrollDoneEvent (Display *, XEvent *ev, XPointer a)
static bool	translateBySips (QWidget *that, QRect &paintRect)
bool	qt_sendSpontaneousEvent (QObject *receiver, QEvent *event)
static void	resetSmState ()
static void	sm_setProperty (const char *name, const char *type, int num_vals, SmPropValue *vals)
static void	sm_saveYourselfCallback (SmcConn smcConn, SmPointer clientData, int saveType, Bool shutdown, int interactStyle, Bool fast)
static void	sm_saveYourselfPhase2Callback (SmcConn smcConn, SmPointer clientData)
static void	sm_dieCallback (SmcConn smcConn, SmPointer clientData)
static void	sm_shutdownCancelledCallback (SmcConn smcConn, SmPointer clientData)
static void	sm_saveCompleteCallback (SmcConn smcConn, SmPointer clientData)
static void	sm_interactCallback (SmcConn smcConn, SmPointer clientData)
static void	sm_performSaveYourself (QSessionManagerPrivate *)
static void	sm_setProperty (const QString &name, const QString &value)
static void	sm_setProperty (const QString &name, const QStringList &value)
Variables
static const char *	x11_atomnames
Q_GUI_EXPORT QX11Data *	qt_x11Data = 0
static const char *	appName = 0
static const char *	appClass = 0
static const char *	appFont = 0
static const char *	appBGCol = 0
static const char *	appFGCol = 0
static const char *	appBTNCol = 0
static const char *	mwGeometry = 0
static const char *	mwTitle = 0
char *	qt_ximServer = 0
static bool	appSync = false
static bool	app_save_rootinfo = false
static bool	app_do_modal = false
static Window	curWin = 0
bool	qt_broken_wm = false
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
bool	qt_use_rtl_extensions = false
static Window	mouseActWindow = 0
static Qt::MouseButton	mouseButtonPressed = Qt::NoButton
static Qt::MouseButtons	mouseButtonState = Qt::NoButton
static Time	mouseButtonPressTime = 0
static short	mouseXPos
static short	mouseYPos
static short	mouseGlobalXPos
static short	mouseGlobalYPos
QWidgetList *	qt_modal_stack
static Window	pressed_window = XNone
static bool	replayPopupMouseEvent = false
static bool	popupGrabOk
bool	qt_sm_blockUserInput = false
bool	qt_reuse_double_buffer = true
Q_GUI_EXPORT int	qt_xfocusout_grab_counter = 0
bool	qt_tabletChokeMouse
int	qt_ximComposingKeycode = 0
QTextCodec *	qt_input_mapper = 0
QWidget *	qt_button_down = 0
static QWidget *	qt_popup_down = 0
bool	qt_xdnd_dragging
bool	qt_is_gui_used
bool	qt_app_has_font
static int(*)	original_x_errhandler (Display *dpy, XErrorEvent *)
static int(*)	original_xio_errhandler (Display *dpy)
static QWidgetMapper *	wPRmapper = 0
static int	openPopupCount = 0
static SmcConn	smcConnection = 0
static bool	sm_interactionActive
static bool	sm_smActive
static int	sm_interactStyle
static int	sm_saveType
static bool	sm_cancel
static bool	sm_waitingForInteraction
static bool	sm_isshutdown
static bool	sm_phase2
static bool	sm_in_phase2
static QSmSocketReceiver *	sm_receiver = 0

---

Define Documentation

#define XK_MISCELLANY

Definition at line 86 of file qapplication_x11.cpp.

---

Function Documentation

static void getXDefault	(	const char *	group,
		const char *	key,
		bool *	val
	)			[static]

Definition at line 1201 of file qapplication_x11.cpp.

References c, and X11.

{
    char *str = XGetDefault(X11->display, group, key);
    if (str) {
        char c = str[0];
        if (isupper((int)c))
            c = tolower(c);
        if (c == 't' || c == 'y' || c == '1')
            *val = true;
        else if (c == 'f' || c == 'n' || c == '0')
            *val = false;
        if (c == 'o') {
            c = str[1];
            if (isupper((int)c))
                c = tolower(c);
            if (c == 'n')
                *val = true;
            if (c == 'f')
                *val = false;
        }
    }
}

static void getXDefault	(	const char *	group,
		const char *	key,
		double *	val
	)			[static]

Definition at line 1190 of file qapplication_x11.cpp.

References X11.

{
    char *str = XGetDefault(X11->display, group, key);
    if (str) {
        char *end = 0;
        double v = strtod(str, &end);
        if (str != end)
            *val = v;
    }
}

static void getXDefault	(	const char *	group,
		const char *	key,
		int *	val
	)			[static]

Definition at line 1179 of file qapplication_x11.cpp.

References X11.

{
    char *str = XGetDefault(X11->display, group, key);
    if (str) {
        char *end = 0;
        int v = strtol(str, &end, 0);
        if (str != end)
            *val = v;
    }
}

static Bool isPaintOrScrollDoneEvent	(	Display *	,
		XEvent *	ev,
		XPointer	a
	)			[static]

Definition at line 4144 of file qapplication_x11.cpp.

References ATOM, and info.

Referenced by QETWidget::translateConfigEvent(), and QETWidget::translatePaintEvent().

{
    PaintEventInfo *info = (PaintEventInfo *)a;
    if (ev->type == Expose || ev->type == GraphicsExpose
      ||    ev->type == ClientMessage
         && ev->xclient.message_type == ATOM(_QT_SCROLL_DONE))
    {
        if (ev->xexpose.window == info->window)
            return True;
    }
    return False;
}

static bool isXInputSupported

(

Display *

dpy

)

[static]

Definition at line 1157 of file qapplication_x11.cpp.

References version, and X11.

{
    Bool exists;
    XExtensionVersion *version;
    exists = XQueryExtension(dpy, "XInputExtension", &X11->xinput_major,
                             &X11->xinput_eventbase, &X11->xinput_errorbase);
    if (!exists)
        return false;
    version = XGetExtensionVersion(dpy, "XInputExtension");
    if (!version || version == reinterpret_cast<XExtensionVersion *>(NoSuchExtension))
        return false;

    XFree(version);
    return true;
}

void qPRCleanup

(

QWidget *

widget

)

Definition at line 2429 of file qapplication_x11.cpp.

References QHash< Key, T >::constBegin(), QHash< Key, T >::constEnd(), key, QHash< Key, T >::remove(), QWidget::setAttribute(), QHash< Key, T >::size(), QWidget::testAttribute(), Qt::WA_WState_Reparented, and wPRmapper.

Referenced by QWidget::destroy().

{
    QETWidget *etw = static_cast<QETWidget *>(const_cast<QWidget *>(widget));
    if (!(wPRmapper && widget->testAttribute(Qt::WA_WState_Reparented)))
        return;                                        // not a reparented widget
    for (QWidgetMapper::ConstIterator it = wPRmapper->constBegin(); it != wPRmapper->constEnd(); ++it) {
        QWidget *w = *it;
        int key = it.key();
        if (w == etw) {                       // found widget
            etw->setAttribute(Qt::WA_WState_Reparented, false); // clear flag
            wPRmapper->remove(key);// old window no longer needed
            if (wPRmapper->size() == 0) {        // became empty
                delete wPRmapper;                // then reset alt mapper
                wPRmapper = 0;
            }
            return;
        }
    }
}

Here is the call graph for this function:

void qPRCreate	(	const QWidget *	widget,
		Window	oldwin
	)

Definition at line 2419 of file qapplication_x11.cpp.

References QHash< Key, T >::insert(), w, Qt::WA_WState_Reparented, and wPRmapper.

Referenced by QWidgetPrivate::setParent_sys().

{                                                // QWidget::reparent mechanism
    if (!wPRmapper)
        wPRmapper = new QWidgetMapper;

    QETWidget *w = static_cast<QETWidget *>(const_cast<QWidget *>(widget));
    wPRmapper->insert((int)oldwin, w);        // add old window to mapper
    w->setAttribute(Qt::WA_WState_Reparented);        // set reparented flag
}

Here is the call graph for this function:

static QETWidget* qPRFindWidget

(

Window

oldwin

)

[static]

Definition at line 2449 of file qapplication_x11.cpp.

References QHash< Key, T >::value(), and wPRmapper.

{
    return wPRmapper ? (QETWidget*)wPRmapper->value((int)oldwin, 0) : 0;
}

Here is the call graph for this function:

bool qt_check_clipboard_sentinel

(

)

Definition at line 1274 of file qclipboard_x11.cpp.

References ATOM, QClipboardData::clear(), QApplication::clipboard(), clipboardData(), QApplication::desktop(), QWidget::internalWinId(), owner, pending_clipboard_changed, pending_timer_id, QDesktopWidget::screen(), QObject::startTimer(), Success, waiting_for_data, and X11.

{
    bool doIt = true;
    if (owner) {
        Window *owners;
        Atom actualType;
        int actualFormat;
        unsigned long nitems, bytesLeft;

        if (XGetWindowProperty(X11->display,
                               QApplication::desktop()->screen(0)->internalWinId(),
                               ATOM(_QT_CLIPBOARD_SENTINEL), 0, 2, False, XA_WINDOW,
                               &actualType, &actualFormat, &nitems, &bytesLeft,
                               (unsigned char **) &owners) == Success) {
            if (actualType == XA_WINDOW && actualFormat == 32 && nitems == 2) {
                Window win = owner->internalWinId();
                if (owners[0] == win || owners[1] == win)
                    doIt = false;
            }

            XFree(owners);
        }
    }

    if (doIt) {
        if (waiting_for_data) {
            pending_clipboard_changed = true;
            if (! pending_timer_id)
                pending_timer_id = QApplication::clipboard()->startTimer(0);
            doIt = false;
        } else {
            clipboardData()->clear();
        }
    }

    return doIt;
}

Here is the call graph for this function:

static void qt_check_focus_model

(

)

[static]

Definition at line 1145 of file qapplication_x11.cpp.

References QX11Data::FM_Other, QX11Data::FM_PointerRoot, X11, and XNone.

{
    Window fw = XNone;
    int unused;
    XGetInputFocus(X11->display, &fw, &unused);
    if (fw == PointerRoot)
        X11->focus_model = QX11Data::FM_PointerRoot;
    else
        X11->focus_model = QX11Data::FM_Other;
}

bool qt_check_selection_sentinel

(

)

Definition at line 1223 of file qclipboard_x11.cpp.

References ATOM, QClipboardData::clear(), QApplication::clipboard(), QApplication::desktop(), QWidget::internalWinId(), owner, pending_selection_changed, pending_timer_id, QDesktopWidget::screen(), selectionData(), QObject::startTimer(), Success, waiting_for_data, and X11.

{
    bool doIt = true;
    if (owner) {
        /*
          Since the X selection mechanism cannot give any signal when
          the selection has changed, we emulate it (for Qt processes) here.
          The notification should be ignored in case of either
          a) This is the process that did setData (because setData()
          then has already emitted dataChanged())
          b) This is the process that owned the selection when dataChanged()
          was called (because we have then received a SelectionClear event,
          and have already emitted dataChanged() as a result of that)
        */

        Window* owners;
        Atom actualType;
        int actualFormat;
        ulong nitems;
        ulong bytesLeft;

        if (XGetWindowProperty(X11->display,
                               QApplication::desktop()->screen(0)->internalWinId(),
                               ATOM(_QT_SELECTION_SENTINEL), 0, 2, False, XA_WINDOW,
                               &actualType, &actualFormat, &nitems,
                               &bytesLeft, (unsigned char**)&owners) == Success) {
            if (actualType == XA_WINDOW && actualFormat == 32 && nitems == 2) {
                Window win = owner->internalWinId();
                if (owners[0] == win || owners[1] == win)
                    doIt = false;
            }

            XFree(owners);
        }
    }

    if (doIt) {
        if (waiting_for_data) {
            pending_selection_changed = true;
            if (! pending_timer_id)
                pending_timer_id = QApplication::clipboard()->startTimer(0);
            doIt = false;
        } else {
            selectionData()->clear();
        }
    }

    return doIt;
}

Here is the call graph for this function:

void qt_cleanup

(

)

Definition at line 1991 of file qapplication_x11.cpp.

References app_save_rootinfo, appClass, QList< T >::at(), QCursorData::cleanup(), QColormap::cleanup(), QFont::cleanup(), QPixmapCache::clear(), QApplicationPrivate::inputContext, original_x_errhandler, original_xio_errhandler, qt_save_rootinfo(), qt_tablet_devices(), QList< T >::size(), and X11.

Referenced by QApplication::~QApplication().

{
    if (app_save_rootinfo)                        // root window must keep state
        qt_save_rootinfo();

    if (qt_is_gui_used) {
        QPixmapCache::clear();
        QCursorData::cleanup();
        QFont::cleanup();
        QColormap::cleanup();
    }

#ifndef QT_NO_XRENDER
    for (int i = 0; i < X11->solid_fill_count; ++i) {
        if (X11->solid_fills[i].picture)
            XRenderFreePicture(X11->display, X11->solid_fills[i].picture);
    }
    for (int i = 0; i < X11->pattern_fill_count; ++i) {
        if (X11->pattern_fills[i].picture)
            XRenderFreePicture(X11->display, X11->pattern_fills[i].picture);
    }
#endif
#if !defined (QT_NO_TABLET)
    QTabletDeviceDataList *devices = qt_tablet_devices();
    for (int i = 0; i < devices->size(); ++i)
        XCloseDevice(X11->display, (XDevice*)devices->at(i).device);
#endif

#if !defined(QT_NO_IM)
    delete QApplicationPrivate::inputContext;
    QApplicationPrivate::inputContext = 0;
#endif

    // Reset the error handlers
    XSetErrorHandler(original_x_errhandler);
    XSetIOErrorHandler(original_xio_errhandler);

    if (qt_is_gui_used && !X11->foreignDisplay)
        XCloseDisplay(X11->display);                // close X display
    X11->display = 0;

    delete [] X11->screens;

    if (X11->foreignDisplay) {
        delete [] (char *)appName;
        appName = 0;
    }

    delete [] (char *)appClass;
    appClass = 0;

    if (X11->net_supported_list)
        delete [] X11->net_supported_list;
    X11->net_supported_list = 0;

    if (X11->net_virtual_root_list)
        delete [] X11->net_virtual_root_list;
    X11->net_virtual_root_list = 0;

    delete X11;
    X11 = 0;
}

Here is the call graph for this function:

void qt_desktopwidget_update_workarea

(

)

Definition at line 40 of file qdesktopwidget_x11.cpp.

References qt_desktopwidget_workarea_dirty.

{
    qt_desktopwidget_workarea_dirty = true;
}

static void qt_detect_broken_window_manager

(

)

[static]

Definition at line 997 of file qapplication_x11.cpp.

References QX11Info::appRootWindow(), ATOM, data, qt_broken_wm, Success, type, and X11.

{
    Atom type;
    int format;
    ulong nitems, after;
    uchar *data = 0;

    // look for SGI's 4Dwm
    int e = XGetWindowProperty(X11->display, QX11Info::appRootWindow(),
                               ATOM(_SGI_DESKS_MANAGER), 0, 1, False, XA_WINDOW,
                               &type, &format, &nitems, &after, &data);
    if (data)
        XFree(data);

    if (e == Success && type == XA_WINDOW && format == 32 && nitems == 1 && after == 0) {
        // detected SGI 4Dwm
        qt_broken_wm = true;
    }
}

Here is the call graph for this function:

static void qt_get_net_supported

(

)

[static]

Definition at line 1019 of file qapplication_x11.cpp.

References a, QX11Info::appRootWindow(), ATOM, buffer, QBuffer::buffer(), data, QBuffer::open(), Success, type, QIODevice::write(), QIODevice::WriteOnly, and X11.

{
    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;
    }
}

Here is the call graph for this function:

static void qt_get_net_virtual_roots

(

)

[static]

Definition at line 1087 of file qapplication_x11.cpp.

References a, QX11Info::appRootWindow(), ATOM, buffer, QBuffer::buffer(), data, QBuffer::open(), qt_net_supports(), Success, type, QIODevice::write(), QIODevice::WriteOnly, and X11.

{
    if (X11->net_virtual_root_list)
        delete [] X11->net_virtual_root_list;
    X11->net_virtual_root_list = 0;

    if (!qt_net_supports(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;
    }
}

Here is the call graph for this function:

void qt_init	(	QApplicationPrivate *	priv,
		int	,
		Display *	display = 0,
		Qt::HANDLE	visual = 0,
		Qt::HANDLE	colormap = 0
	)

Definition at line 1229 of file qapplication_x11.cpp.

References appClass, appName, p, priv(), QByteArray::qstrdup(), and X11.

{
    X11 = new QX11Data;
    X11->display = display;
    X11->displayName = 0;
    X11->foreignDisplay = (display != 0);
    X11->focus_model = -1;

    // RANDR
    X11->use_xrandr = false;
    X11->xrandr_major = 0;
    X11->xrandr_eventbase = 0;
    X11->xrandr_errorbase = 0;

    // RENDER
    X11->use_xrender = false;
    X11->xrender_major = 0;
    X11->xrender_version = 0;

    // XFIXES
    X11->use_xfixes = false;
    X11->xfixes_major = 0;
    X11->xfixes_eventbase = 0;
    X11->xfixes_errorbase = 0;

    // XInputExtension
    X11->use_xinput = false;
    X11->xinput_major = 0;
    X11->xinput_eventbase = 0;
    X11->xinput_errorbase = 0;

    X11->sip_serial = 0;
    X11->net_supported_list = 0;
    X11->net_virtual_root_list = 0;
    X11->wm_client_leader = 0;
    X11->screens = 0;
    X11->screenCount = 0;
    X11->time = CurrentTime;
    X11->userTime = CurrentTime;
    X11->ignore_badwindow = false;
    X11->seen_badwindow = false;

    X11->motifdnd_active = false;

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

    // colormap control
    X11->visual_class = -1;
    X11->visual_id = -1;
    X11->color_count = 0;
    X11->custom_cmap = false;

    // outside visual/colormap
    X11->visual = reinterpret_cast<Visual *>(visual);
    X11->colormap = colormap;

#ifndef QT_NO_XRENDER
    memset(X11->solid_fills, 0, sizeof(X11->solid_fills));
    for (int i = 0; i < X11->solid_fill_count; ++i)
        X11->solid_fills[i].screen = -1;
    memset(X11->pattern_fills, 0, sizeof(X11->pattern_fills));
    for (int i = 0; i < X11->pattern_fill_count; ++i)
        X11->pattern_fills[i].screen = -1;
#endif

    X11->startupId = 0;

    int argc = priv->argc;
    char **argv = priv->argv;

    if (X11->display) {
        // Qt part of other application

        // Set application name and class
        appName = qstrdup("Qt-subapplication");
        char *app_class = 0;
        if (argv) {
            const char* p = strrchr(argv[0], '/');
            app_class = qstrdup(p ? p + 1 : argv[0]);
            if (app_class[0])
                app_class[0] = toupper(app_class[0]);
        }
        appClass = app_class;
    } else {
        // Qt controls everything (default)

        // Set application name and class
        char *app_class = 0;
        if (argv && argv[0]) {
            const char *p = strrchr(argv[0], '/');
            appName = p ? p + 1 : argv[0];
            app_class = qstrdup(appName);
            if (app_class[0])
                app_class[0] = toupper(app_class[0]);
        }
        appClass = app_class;
    }

    // Install default error handlers
    original_x_errhandler = XSetErrorHandler(qt_x_errhandler);
    original_xio_errhandler = XSetIOErrorHandler(qt_xio_errhandler);

    // Get command line params
    int j = argc ? 1 : 0;
    for (int i=1; i<argc; i++) {
        if (argv[i] && *argv[i] != '-') {
            argv[j++] = argv[i];
            continue;
        }
        QByteArray arg(argv[i]);
        if (arg == "-display") {
            if (++i < argc && !X11->display)
                X11->displayName = argv[i];
        } else if (arg == "-fn" || arg == "-font") {
            if (++i < argc)
                appFont = argv[i];
        } else if (arg == "-bg" || arg == "-background") {
            if (++i < argc)
                appBGCol = argv[i];
        } else if (arg == "-btn" || arg == "-button") {
            if (++i < argc)
                appBTNCol = argv[i];
        } else if (arg == "-fg" || arg == "-foreground") {
            if (++i < argc)
                appFGCol = argv[i];
        } else if (arg == "-name") {
            if (++i < argc)
                appName = argv[i];
        } else if (arg == "-title") {
            if (++i < argc)
                mwTitle = argv[i];
        } else if (arg == "-geometry") {
            if (++i < argc)
                mwGeometry = argv[i];
        } else if (arg == "-im") {
            if (++i < argc)
                qt_ximServer = argv[i];
#if 0
        } else if (arg == "-noxim") {
            noxim=true;
#endif
        } else if (arg == "-ncols") {   // xv and netscape use this name
            if (++i < argc)
                X11->color_count = qMax(0,atoi(argv[i]));
        } else if (arg == "-visual") {  // xv and netscape use this name
            if (++i < argc && !X11->visual) {
                QString s = QString::fromLocal8Bit(argv[i]).toLower();
                if (s == QLatin1String("staticgray"))
                    X11->visual_class = StaticGray;
                else if (s == QLatin1String("grayscale"))
                    X11->visual_class = XGrayScale;
                else if (s == QLatin1String("staticcolor"))
                    X11->visual_class = StaticColor;
                else if (s == QLatin1String("pseudocolor"))
                    X11->visual_class = PseudoColor;
                else if (s == QLatin1String("truecolor"))
                    X11->visual_class = TrueColor;
                else if (s == QLatin1String("directcolor"))
                    X11->visual_class = DirectColor;
                else
                    X11->visual_id = static_cast<int>(strtol(argv[i], 0, 0));
            }
#ifndef QT_NO_XIM
        } else if (arg == "-inputstyle") {
            if (++i < argc) {
                QString s = QString::fromLocal8Bit(argv[i]).toLower();
                if (s == QLatin1String("onthespot"))
                    qt_xim_preferred_style = XIMPreeditCallbacks |
                                             XIMStatusNothing;
                else if (s == QLatin1String("overthespot"))
                    qt_xim_preferred_style = XIMPreeditPosition |
                                             XIMStatusNothing;
                else if (s == QLatin1String("offthespot"))
                    qt_xim_preferred_style = XIMPreeditArea |
                                             XIMStatusArea;
                else if (s == QLatin1String("root"))
                    qt_xim_preferred_style = XIMPreeditNothing |
                                             XIMStatusNothing;
            }
#endif
        } else if (arg == "-cmap") {    // xv uses this name
            if (!X11->colormap)
                X11->custom_cmap = true;
        }
#if defined(QT_DEBUG)
        else if (arg == "-sync")
            appSync = !appSync;
        else if (arg == "-nograb")
            appNoGrab = !appNoGrab;
        else if (arg == "-dograb")
            appDoGrab = !appDoGrab;
#endif
        else
            argv[j++] = argv[i];
    }

    priv->argc = j;

#if defined(QT_DEBUG) && defined(Q_OS_LINUX)
    if (!appNoGrab && !appDoGrab) {
        QString s;
        s.sprintf("/proc/%d/cmdline", getppid());
        QFile f(s);
        if (f.open(QIODevice::ReadOnly)) {
            s.clear();
            char c;
            while (f.getChar(&c) && c) {
                if (c == '/')
                    s.clear();
                else
                    s += QLatin1Char(c);
            }
            if (s == QLatin1String("gdb")) {
                appNoGrab = true;
                qDebug("Qt: gdb: -nograb added to command-line options.\n"
                       "\t Use the -dograb option to enforce grabbing.");
            }
            f.close();
        }
    }
#endif

    // Connect to X server
    if (qt_is_gui_used && !X11->display) {
        if ((X11->display = XOpenDisplay(X11->displayName)) == 0) {
            qWarning("%s: cannot connect to X server %s", appName,
                     XDisplayName(X11->displayName));
            QApplicationPrivate::reset_instance_pointer();
            exit(1);
        }

        if (appSync)                                // if "-sync" argument
            XSynchronize(X11->display, true);
    }

    // Common code, regardless of whether display is foreign.

    // Get X parameters

    if (qt_is_gui_used) {
        X11->defaultScreen = DefaultScreen(X11->display);
        X11->screenCount = ScreenCount(X11->display);

        X11->screens = new QX11InfoData[X11->screenCount];

        for (int s = 0; s < X11->screenCount; s++) {
            QX11InfoData *screen = X11->screens + s;
            screen->ref = 1; // ensures it doesn't get deleted
            screen->screen = s;
            screen->dpiX = (DisplayWidth(X11->display, s) * 254 + DisplayWidthMM(X11->display, s)*5)
                           / (DisplayWidthMM(X11->display, s)*10);
            screen->dpiY = (DisplayHeight(X11->display, s) * 254 + DisplayHeightMM(X11->display, s)*5)
                           / (DisplayHeightMM(X11->display, s)*10);
        }

        QColormap::initialize();

        // Support protocols
        X11->xdndSetup();

        // Finally create all atoms
        qt_x11_create_intern_atoms();

        // look for broken window managers
        qt_detect_broken_window_manager();

        // initialize NET lists
        qt_get_net_supported();
        qt_get_net_virtual_roots();

#ifndef QT_NO_XRANDR
        // See if XRandR is supported on the connected display
        if (XQueryExtension(X11->display, "RANDR", &X11->xrandr_major,
                            &X11->xrandr_eventbase, &X11->xrandr_errorbase)
            && XRRQueryExtension(X11->display, &X11->xrandr_eventbase, &X11->xrandr_errorbase)) {
            // XRandR is supported
            X11->use_xrandr = true;
        }
#endif // QT_NO_XRANDR

#ifndef QT_NO_XRENDER
        int xrender_eventbase,  xrender_errorbase;
        // See if XRender is supported on the connected display
        if (XQueryExtension(X11->display, "RENDER", &X11->xrender_major,
                            &xrender_eventbase, &xrender_errorbase)
            && XRenderQueryExtension(X11->display, &xrender_eventbase,
                                     &xrender_errorbase)) {
            // XRender is supported, let's see if we have a PictFormat for the
            // default visual
            XRenderPictFormat *format =
                XRenderFindVisualFormat(X11->display,
                                        (Visual *) QX11Info::appVisual(X11->defaultScreen));
            // Check the version as well - we need v0.4 or higher
            int major = 0;
            int minor = 0;
            XRenderQueryVersion(X11->display, &major, &minor);
            if (qgetenv("QT_X11_NO_XRENDER").isNull() && format != 0) {
                X11->use_xrender = (major >= 0 && minor >= 5);
                X11->xrender_version = major*100+minor;
                // workaround for broken XServer on Ubuntu Breezy (6.8 compiled with 7.0
                // protocol headers)
                if (X11->xrender_version == 10
                    && VendorRelease(X11->display) < 60900000
                    && QByteArray(ServerVendor(X11->display)).contains("X.Org"))
                    X11->xrender_version = 9;
            }
        }
#endif // QT_NO_XRENDER

#ifndef QT_NO_XFIXES
        // See if Xfixes is supported on the connected display
        if (XQueryExtension(X11->display, "XFIXES", &X11->xfixes_major,
                            &X11->xfixes_eventbase, &X11->xfixes_errorbase)
            && XFixesQueryExtension(X11->display, &X11->xfixes_eventbase,
                                    &X11->xfixes_errorbase)) {
            // Xfixes is supported.
            // Note: the XFixes protocol version is negotiated using QueryVersion.
            // We supply the highest version we support, the X server replies with
            // the highest version it supports, but no higher than the version we
            // asked for. The version sent back is the protocol version the X server
            // will use to talk us. If this call is removed, the behavior of the
            // X server when it receives an XFixes request is undefined.
            int major = 3;
            int minor = 0;
            XFixesQueryVersion(X11->display, &major, &minor);
            X11->use_xfixes = (major >= 2);
            X11->xfixes_major = major;
        }
#endif // QT_NO_XFIXES

        X11->has_fontconfig = false;
#if !defined(QT_NO_FONTCONFIG)
        if (qgetenv("QT_X11_NO_FONTCONFIG").isNull())
            X11->has_fontconfig = FcInit();

        int dpi = 0;
        getXDefault("Xft", FC_DPI, &dpi);
        if (dpi) {
            for (int s = 0; s < ScreenCount(X11->display); ++s) {
                QX11Info::setAppDpiX(s, dpi);
                QX11Info::setAppDpiY(s, dpi);
            }
        }
        X11->fc_scale = 1.;
        getXDefault("Xft", FC_SCALE, &X11->fc_scale);
        for (int s = 0; s < ScreenCount(X11->display); ++s) {
            int subpixel = FC_RGBA_UNKNOWN;
#if RENDER_MAJOR > 0 || RENDER_MINOR >= 6
            if (X11->use_xrender) {
                int rsp = XRenderQuerySubpixelOrder(X11->display, s);
                switch (rsp) {
                default:
                case SubPixelUnknown:
                    subpixel = FC_RGBA_UNKNOWN;
                    break;
                case SubPixelHorizontalRGB:
                    subpixel = FC_RGBA_RGB;
                    break;
                case SubPixelHorizontalBGR:
                    subpixel = FC_RGBA_BGR;
                    break;
                case SubPixelVerticalRGB:
                    subpixel = FC_RGBA_VRGB;
                    break;
                case SubPixelVerticalBGR:
                    subpixel = FC_RGBA_VBGR;
                    break;
                case SubPixelNone:
                    subpixel = FC_RGBA_NONE;
                    break;
                }
            }
#endif
            getXDefault("Xft", FC_RGBA, &subpixel);
            X11->screens[s].subpixel = subpixel;
        }
        X11->fc_antialias = true;
        getXDefault("Xft", FC_ANTIALIAS, &X11->fc_antialias);
#ifdef FC_HINT_STYLE
        getXDefault("Xft", FC_HINT_STYLE, &X11->fc_hint_style);
#endif
#if 0
        // ###### these are implemented by Xft, not sure we need them
        getXDefault("Xft", FC_AUTOHINT, &X11->fc_autohint);
        getXDefault("Xft", FC_HINTING, &X11->fc_autohint);
        getXDefault("Xft", FC_MINSPACE, &X11->fc_autohint);
#endif
#endif // QT_NO_XRENDER

        // initialize key mapper
        QKeyMapper::changeKeyboard();

#ifndef QT_NO_XKB
        if (qt_keymapper_private()->useXKB) {
            // If XKB is detected, set the GrabsUseXKBState option so input method
            // compositions continue to work (ie. deadkeys)
            unsigned int state = XkbPCF_GrabsUseXKBStateMask;
            (void) XkbSetPerClientControls(X11->display, state, &state);
        }
#endif // QT_NO_XKB

        // Misc. initialization
#if 0 //disabled for now..
        QSegfaultHandler::initialize(priv->argv, priv->argc);
#endif
        QFont::initialize();
        QCursorData::initialize();
    }

    if(qt_is_gui_used) {
        qApp->setObjectName(QString::fromLocal8Bit(appName));

        int screen;
        for (screen = 0; screen < X11->screenCount; ++screen) {
            XSelectInput(X11->display, QX11Info::appRootWindow(screen),
                         KeymapStateMask | EnterWindowMask | LeaveWindowMask | PropertyChangeMask);

#ifndef QT_NO_XRANDR
            if (X11->use_xrandr)
                XRRSelectInput(X11->display, QX11Info::appRootWindow(screen), True);
#endif // QT_NO_XRANDR
        }
    }

    if (qt_is_gui_used) {
        // Attempt to determine the current running X11 Desktop Enviornment
        // Use dbus if/when we can, but fall back to using windowManagerName() for now

        X11->desktopEnvironment = DE_UNKNOWN;

        // See if the current window manager is using the freedesktop.org spec to give its name
        Window windowManagerWindow = XNone;
        Atom typeReturned;
        int formatReturned;
        unsigned long nitemsReturned;
        unsigned long unused;
        unsigned char *data = 0;
        if (XGetWindowProperty(QX11Info::display(), QX11Info::appRootWindow(),
                           ATOM(_NET_SUPPORTING_WM_CHECK),
                           0, 1024, False, XA_WINDOW, &typeReturned,
                           &formatReturned, &nitemsReturned, &unused, &data)
              == Success) {
            if (typeReturned == XA_WINDOW && formatReturned == 32)
                windowManagerWindow = *((Window*) data);
            if (data)
                XFree(data);

            if (windowManagerWindow != XNone) {
                QString wmName;
                Atom utf8atom = ATOM(UTF8_STRING);
                if (XGetWindowProperty(QX11Info::display(), windowManagerWindow, ATOM(_NET_WM_NAME),
                                       0, 1024, False, utf8atom, &typeReturned,
                                       &formatReturned, &nitemsReturned, &unused, &data)
                    == Success) {
                    if (typeReturned == utf8atom && formatReturned == 8)
                        wmName = QString::fromUtf8((const char*)data);
                    if (data)
                        XFree(data);
                    if (wmName == QLatin1String("KWin"))
                        X11->desktopEnvironment = DE_KDE;
                    if (wmName == QLatin1String("Metacity"))
                        X11->desktopEnvironment = DE_GNOME;
                }
            }
        }

        // Running a different/newer/older window manager?  Try some other things
        if (X11->desktopEnvironment == DE_UNKNOWN){
            Atom type;
            int format;
            unsigned long length, after;
            uchar *data = 0;

            if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(DTWM_IS_RUNNING),
                                   0, 1, False, AnyPropertyType, &type, &format, &length,
                                   &after, &data) == Success && length) {
                // DTWM is running, meaning most likely CDE is running...
                X11->desktopEnvironment = DE_CDE;
            } else if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(),
                                          ATOM(GNOME_BACKGROUND_PROPERTIES), 0, 1, False, AnyPropertyType,
                                          &type, &format, &length, &after, &data) == Success && length) {
                X11->desktopEnvironment = DE_GNOME;
            } else if ((XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(KDE_FULL_SESSION),
                                           0, 1, False, AnyPropertyType, &type, &format, &length, &after, &data) == Success
                        && length)
                       || (XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(KWIN_RUNNING),
                                              0, 1, False, AnyPropertyType, &type, &format, &length,
                                              &after, &data) == Success
                           && length)
                       || (XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(KWM_RUNNING),
                                              0, 1, False, AnyPropertyType, &type, &format, &length,
                                              &after, &data) == Success && length)) {
                X11->desktopEnvironment = DE_KDE;
            }
            if (data)
                XFree((char *)data);
        }

        qt_set_input_encoding();

        qt_set_x11_resources(appFont, appFGCol, appBGCol, appBTNCol);

        // be smart about the size of the default font. most X servers have helvetica
        // 12 point available at 2 resolutions:
        //     75dpi (12 pixels) and 100dpi (17 pixels).
        // At 95 DPI, a 12 point font should be 16 pixels tall - in which case a 17
        // pixel font is a closer match than a 12 pixel font
        int ptsz = (X11->use_xrender
                    ? 9
                    : (int) (((QX11Info::appDpiY() >= 95 ? 17. : 12.) *
                              72. / (float) QX11Info::appDpiY()) + 0.5));

        if (!qt_app_has_font) {
            QFont f(X11->has_fontconfig ? QLatin1String("Sans Serif") : QLatin1String("Helvetica"),
                    ptsz);
            QApplication::setFont(f);
        }

#if !defined (QT_NO_TABLET)
        if (isXInputSupported(X11->display)) {
            int ndev,
                i,
                j;
            bool gotStylus,
                gotEraser;
            XDeviceInfo *devices, *devs;
            XInputClassInfo *ip;
            XAnyClassPtr any;
            XValuatorInfoPtr v;
            XAxisInfoPtr a;
            XDevice *dev;

#if !defined(Q_OS_IRIX)
            // XFree86 divides a stylus and eraser into 2 devices, so we must do for both...
            const QString XFREENAMESTYLUS = QLatin1String("stylus");
            const QString XFREENAMEPEN = QLatin1String("pen");
            const QString XFREENAMEERASER = QLatin1String("eraser");
#endif

            devices = XListInputDevices(X11->display, &ndev);
            if (!devices) {
                qWarning("QApplication: Failed to get list of devices");
                ndev = -1;
            }
            QTabletEvent::TabletDevice deviceType;
            dev = 0;
            for (devs = devices, i = 0; i < ndev; i++, devs++) {
                gotStylus = false;
                gotEraser = false;

                QString devName = QString::fromLocal8Bit(devs->name).toLower();
#if defined(Q_OS_IRIX)
                if (devName == QLatin1String(WACOM_NAME)) {
                    deviceType = QTabletEvent::Stylus;
                    gotStylus = true;
                }
#else
                if (devName.startsWith(XFREENAMEPEN)
                    || devName.startsWith(XFREENAMESTYLUS)) {
                    deviceType = QTabletEvent::Stylus;
                    gotStylus = true;
                } else if (devName.startsWith(XFREENAMEERASER)) {
                    deviceType = QTabletEvent::XFreeEraser;
                    gotEraser = true;
                }
#endif

                if (gotStylus || gotEraser) {
                    dev = XOpenDevice(X11->display, devs->id);

                    if (!dev)
                        continue;

                    QTabletDeviceData device_data;
                    device_data.deviceType = deviceType;
                    device_data.eventCount = 0;
                    device_data.device = dev;
                    device_data.xinput_motion = -1;
                    device_data.xinput_key_press = -1;
                    device_data.xinput_key_release = -1;
                    device_data.xinput_button_press = -1;
                    device_data.xinput_button_release = -1;
                    device_data.xinput_proximity_in = -1;
                    device_data.xinput_proximity_out = -1;

                    if (dev->num_classes > 0) {
                        for (ip = dev->classes, j = 0; j < devs->num_classes;
                             ip++, j++) {
                            switch (ip->input_class) {
                            case KeyClass:
                                DeviceKeyPress(dev, device_data.xinput_key_press,
                                               device_data.eventList[device_data.eventCount]);
                                if (device_data.eventList[device_data.eventCount])
                                    ++device_data.eventCount;
                                DeviceKeyRelease(dev, device_data.xinput_key_release,
                                                 device_data.eventList[device_data.eventCount]);
                                if (device_data.eventList[device_data.eventCount])
                                    ++device_data.eventCount;
                                break;
                            case ButtonClass:
                                DeviceButtonPress(dev, device_data.xinput_button_press,
                                                  device_data.eventList[device_data.eventCount]);
                                if (device_data.eventList[device_data.eventCount])
                                    ++device_data.eventCount;
                                DeviceButtonRelease(dev, device_data.xinput_button_release,
                                                    device_data.eventList[device_data.eventCount]);
                                if (device_data.eventList[device_data.eventCount])
                                    ++device_data.eventCount;
                                break;
                            case ValuatorClass:
                                // I'm only going to be interested in motion when the
                                // stylus is already down anyway!
                                DeviceMotionNotify(dev, device_data.xinput_motion,
                                                   device_data.eventList[device_data.eventCount]);
                                if (device_data.eventList[device_data.eventCount])
                                    ++device_data.eventCount;
                                ProximityIn(dev, device_data.xinput_proximity_in, device_data.eventList[device_data.eventCount]);
                                if (device_data.eventList[device_data.eventCount])
                                    ++device_data.eventCount;
                                ProximityOut(dev, device_data.xinput_proximity_out, device_data.eventList[device_data.eventCount]);
                                if (device_data.eventList[device_data.eventCount])
                                    ++device_data.eventCount;
                            default:
                                break;
                            }
                        }
                    }

                    // get the min/max value for pressure!
                    any = (XAnyClassPtr) (devs->inputclassinfo);
                    for (j = 0; j < devs->num_classes; j++) {
                        if (any->c_class == ValuatorClass) {
                            v = (XValuatorInfoPtr) any;
                            a = (XAxisInfoPtr) ((char *) v +
                                                sizeof (XValuatorInfo));
#if defined (Q_OS_IRIX)
                            // I'm not exaclty wild about this, but the
                            // dimensions of the tablet are more relevant here
                            // than the min and max values from the axis
                            // (actually it seems to be 2/3 or what is in the
                            // axis.  So we'll try to parse it from this
                            // string. --tws
                            char returnString[SGIDeviceRtrnLen];
                            int tmp;
                            if (XSGIMiscQueryExtension(X11->display, &tmp, &tmp)
                                && XSGIDeviceQuery(X11->display, devs->id,
                                                   "dimensions", returnString)) {
                                QString str = QLatin1String(returnString);
                                int comma = str.indexOf(',');
                                device_data.minX = 0;
                                device_data.minY = 0;
                                device_data.maxX = str.left(comma).toInt();
                                device_data.maxY = str.mid(comma + 1).toInt();
                            } else {
                                device_data.minX = a[WAC_XCOORD_I].min_value;
                                device_data.maxX = a[WAC_XCOORD_I].max_value;
                                device_data.minY = a[WAC_YCOORD_I].min_value;
                                device_data.maxY = a[WAC_YCOORD_I].max_value;
                            }
                            device_data.minPressure = a[WAC_PRESSURE_I].min_value;
                            device_data.maxPressure = a[WAC_PRESSURE_I].max_value;
                            device_data.minTanPressure = a[WAC_TAN_PRESSURE_I].min_value;
                            device_data.maxTanPressure = a[WAC_TAN_PRESSURE_I].max_value;
                            device_data.minZ = a[WAC_ZCOORD_I].min_value;
                            device_data.maxZ = a[WAC_ZCOORD_I].max_value;
#else
                            device_data.minX = a[0].min_value;
                            device_data.maxX = a[0].max_value;
                            device_data.minY = a[1].min_value;
                            device_data.maxY = a[1].max_value;
                            device_data.minPressure = a[2].min_value;
                            device_data.maxPressure = a[2].max_value;
                            device_data.minTanPressure = 0;
                            device_data.maxTanPressure = 0;
                            device_data.minZ = 0;
                            device_data.maxZ = 0;
#endif

                            // got the max pressure no need to go further...
                            break;
                        }
                        any = (XAnyClassPtr) ((char *) any + any->length);
                    } // end of for loop

                    tablet_devices()->append(device_data);
                } // if (gotStylus || gotEraser)
            }
            XFreeDeviceList(devices);
        }
#endif // QT_NO_TABLET

        X11->startupId = getenv("DESKTOP_STARTUP_ID");
        putenv(strdup("DESKTOP_STARTUP_ID="));

   } else {
        // read some non-GUI settings when not using the X server...

        if (QApplication::desktopSettingsAware()) {
            QSettings settings(QSettings::UserScope, QLatin1String("Trolltech"));
            settings.beginGroup(QLatin1String("Qt"));

            // read library (ie. plugin) path list
            QString libpathkey = QString(QLatin1String("%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++);
            }

            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);
            }

            settings.endGroup(); // Qt
        }
    }
}

Here is the call graph for this function:

bool qt_net_supports

(

Atom

atom

)

Definition at line 1068 of file qapplication_x11.cpp.

References X11.

Referenced by QDialog::adjustPosition(), QDesktopWidget::availableGeometry(), QWidgetPrivate::create_sys(), qt_get_net_virtual_roots(), QWidgetPrivate::setGeometry_sys(), QWidget::setWindowState(), QWidgetPrivate::show_sys(), QETWidget::translateConfigEvent(), QETWidget::translatePropertyEvent(), and QWidgetPrivate::updateFrameStrut().

{
    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;
}

static void qt_net_update_user_time

(

QWidget *

tlw

)

[static]

Definition at line 1138 of file qapplication_x11.cpp.

References ATOM, QWidget::internalWinId(), QWidget::testAttribute(), Qt::WA_WState_Created, and X11.

{
    Q_ASSERT(tlw->testAttribute(Qt::WA_WState_Created));
    XChangeProperty(X11->display, tlw->internalWinId(), ATOM(_NET_WM_USER_TIME),
                    XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &X11->userTime, 1);
}

Here is the call graph for this function:

bool qt_nograb

(

)

Definition at line 2121 of file qapplication_x11.cpp.

Referenced by QApplicationPrivate::closePopup(), QWidget::grabKeyboard(), QWidget::grabMouse(), QApplicationPrivate::openPopup(), QWidget::releaseKeyboard(), and QWidget::releaseMouse().

{
#if defined(QT_DEBUG)
    return appNoGrab;
#else
    return false;
#endif
}

void qt_save_rootinfo

(

)

[static]

Definition at line 2059 of file qapplication_x11.cpp.

References QX11Info::appRootWindow(), ATOM, Success, and X11.

Referenced by qt_cleanup().

{
    Atom type;
    int format;
    unsigned long length, after;
    uchar *data = 0;

    if (ATOM(_XSETROOT_ID)) {                        // kill old pixmap
        if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(),
                                 ATOM(_XSETROOT_ID), 0, 1,
                                 True, AnyPropertyType, &type, &format,
                                 &length, &after, &data) == Success) {
            if (type == XA_PIXMAP && format == 32 && length == 1 &&
                 after == 0 && data) {
                XKillClient(X11->display, *((Pixmap*)data));
            }
            Pixmap dummy = XCreatePixmap(X11->display, QX11Info::appRootWindow(),
                                          1, 1, 1);
            XChangeProperty(X11->display, QX11Info::appRootWindow(),
                             ATOM(_XSETROOT_ID), XA_PIXMAP, 32,
                             PropModeReplace, (uchar *)&dummy, 1);
            XSetCloseDownMode(X11->display, RetainPermanent);
        }
    }
    if (data)
        XFree((char *)data);
}

Here is the call graph for this function:

bool qt_sendSpontaneousEvent	(	QObject *	receiver,
		QEvent *	event
	)

Definition at line 4185 of file qapplication_x11.cpp.

References QCoreApplication::sendSpontaneousEvent().

Referenced by QKeyMapper::changeKeyboard(), QWidgetPrivate::drawWidget(), and QKeyMapper::sendKeyEvent().

{
    return QCoreApplication::sendSpontaneousEvent(receiver, event);
}

Here is the call graph for this function:

static void qt_set_input_encoding

(

)

[static]

Definition at line 719 of file qapplication_x11.cpp.

References QX11Info::appRootWindow(), ATOM, QTextCodec::codecForLocale(), QTextCodec::codecForName(), data, QTextCodec::mibEnum(), QByteArray::qstricmp(), qt_input_mapper, Success, type, X11, and XNone.

{
    Atom type;
    int format;
    ulong  nitems, after = 1;
    const char *data = 0;

    int e = XGetWindowProperty(X11->display, QX11Info::appRootWindow(),
                                ATOM(_QT_INPUT_ENCODING), 0, 1024,
                                False, XA_STRING, &type, &format, &nitems,
                                &after, (unsigned char**)&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(data, "locale"))
            qt_input_mapper = QTextCodec::codecForLocale();
        else
            qt_input_mapper = QTextCodec::codecForName(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);
}

Here is the call graph for this function:

static void qt_set_x11_resources	(	const char *	font = 0,
		const char *	fg = 0,
		const char *	bg = 0,
		const char *	button = 0
	)			[static]

Definition at line 753 of file qapplication_x11.cpp.

References QPalette::Active, QColor::alpha, appClass, QX11Info::appDpiY(), appName, QX11Info::appRootWindow(), QString::at(), ATOM, base, QColor::blue, QPalette::Button, QStringList::contains(), QColor::dark(), Qt::darkBlue, data, QApplication::desktopSettingsAware(), QPalette::Disabled, QApplication::font(), QString::fromLatin1(), QString::fromLocal8Bit(), QColor::getHsv(), QColor::green, QPalette::Highlight, QPalette::HighlightedText, QColor::hue, QString::indexOf(), QString::isEmpty(), QUnicodeTables::isSpace(), QColor::isValid(), key, l, QString::left(), QString::length(), QColor::light(), QString::mid(), QFontInfo::pixelSize(), QFontInfo::pointSize(), qRound(), qt_app_has_font, QFontInfo::rawMode(), QColor::red, QString::right(), s, QApplication::setEffectEnabled(), QApplication::setFont(), QColor::setHsv(), QApplicationPrivate::setSystemPalette(), QString::simplified(), QString::split(), QApplication::style(), QApplicationPrivate::sys_pal, QString::toLower(), QString::trimmed(), type, Qt::UI_AnimateCombo, Qt::UI_AnimateMenu, Qt::UI_AnimateToolBox, Qt::UI_AnimateTooltip, Qt::UI_FadeMenu, Qt::UI_FadeTooltip, Qt::UI_General, value, QColor::value, Qt::white, QPalette::Window, QPalette::WindowText, X11, and XNone.

{

    QString resFont, resFG, resBG, 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;
            XGetWindowProperty(X11->display, QX11Info::appRootWindow(0),
                               ATOM(RESOURCE_MANAGER),
                               offset, 8192, False, AnyPropertyType,
                               &type, &format, &nitems, &after,
                               &data);
            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 (QUnicodeTables::isSpace(res.at(l)))
                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 (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 (!qt_app_has_font && !resFont.isEmpty()) { // 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));
                }
            }
        }

        if (fnt != QApplication::font()) {
            QApplication::setFont(fnt);
        }
    }

    if ((button || !resBG.isEmpty() || !resFG.isEmpty())) {// set app colors
        (void) QApplication::style();  // trigger creation of application style and system palettes
        QColor btn;
        QColor bg;
        QColor fg;
        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 (button)
            btn = QColor(QString::fromLocal8Bit(button));
        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.dark(150);
            bright_mode = true;
        }

        QPalette pal(fg, btn, btn.light(), btn.dark(), btn.dark(150), 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.light(125),
                          btn.dark(), btn.dark(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);
        }

        QApplicationPrivate::setSystemPalette(pal);
    }

    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")));
    }
}

Here is the call graph for this function:

QTabletDeviceDataList* qt_tablet_devices

(

)

Definition at line 314 of file qapplication_x11.cpp.

Referenced by QWidgetPrivate::create_sys(), qt_cleanup(), and QETWidget::translateMouseEvent().

{
    return tablet_devices();
}

bool qt_try_modal	(	QWidget *	,
		XEvent *
	)

Definition at line 3156 of file qapplication_x11.cpp.

References qt_button_down, qt_xdnd_dragging, QApplicationPrivate::tryModalHelper(), XKeyPress, and XKeyRelease.

{
    if (qt_xdnd_dragging) {
        // allow mouse events while DnD is active
        switch (event->type) {
        case ButtonPress:
        case ButtonRelease:
        case MotionNotify:
            return true;
        default:
            break;
        }
    }

    // allow mouse release events to be sent to widgets that have been pressed
    if (event->type == ButtonRelease && widget == qt_button_down)
        return true;

    if (QApplicationPrivate::tryModalHelper(widget))
        return true;

    // disallow mouse/key events
    switch (event->type) {
    case ButtonPress:
    case ButtonRelease:
    case MotionNotify:
    case XKeyPress:
    case XKeyRelease:
    case EnterNotify:
    case LeaveNotify:
    case ClientMessage:
        return false;
    default:
        break;
    }

    return true;
}

Here is the call graph for this function:

void qt_updated_rootinfo

(

)

Definition at line 2087 of file qapplication_x11.cpp.

References app_save_rootinfo.

{
    app_save_rootinfo = true;
}

bool qt_wstate_iconified

(

WId

winid

)

Definition at line 2092 of file qapplication_x11.cpp.

References ATOM, Success, and X11.

{
    Atom type;
    int format;
    unsigned long length, after;
    uchar *data = 0;
    int r = XGetWindowProperty(X11->display, winid, ATOM(WM_STATE), 0, 2,
                                 False, AnyPropertyType, &type, &format,
                                 &length, &after, &data);
    bool iconic = false;
    if (r == Success && data && format == 32) {
        // quint32 *wstate = (quint32*)data;
        unsigned long *wstate = (unsigned long *) data;
        iconic = (*wstate == IconicState);
        XFree((char *)data);
    }
    return iconic;
}

Q_GUI_EXPORT void qt_x11_apply_settings_in_all_apps

(

)

Definition at line 505 of file qapplication_x11.cpp.

References QX11Info::appRootWindow(), ATOM, QDateTime::currentDateTime(), QByteArray::data(), QX11Info::display(), s, QByteArray::size(), and QIODevice::WriteOnly.

Referenced by MainWindow::fileSave().

{
    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());
}

Here is the call graph for this function:

static void qt_x11_create_intern_atoms

(

)

[static]

Definition at line 477 of file qapplication_x11.cpp.

References i, QX11Data::NAtoms, QX11Data::NPredefinedAtoms, ptr, X11, and x11_atomnames.

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

void qt_x11_enforce_cursor

(

QWidget *

w

)

Definition at line 268 of file qwidget_x11.cpp.

References QApplication::overrideCursor(), w, Qt::WA_SetCursor, Qt::WA_WState_Created, X11, and XNone.

Referenced by QWidgetPrivate::create_sys(), QApplication::restoreOverrideCursor(), QWidgetPrivate::setCursor_sys(), QWidgetPrivate::setEnabled_helper(), QApplication::setOverrideCursor(), and QWidgetPrivate::unsetCursor_sys().

{
    if (!w->testAttribute(Qt::WA_WState_Created))
        return;
    if (w->testAttribute(Qt::WA_SetCursor)) {
        QCursor *oc = QApplication::overrideCursor();
        if (oc) {
            XDefineCursor(X11->display, w->internalWinId(), oc->handle());
        } else if (w->isEnabled()) {
            XDefineCursor(X11->display, w->internalWinId(), w->cursor().handle());
        } else {
            // enforce the windows behavior of clearing the cursor on
            // disabled widgets
            XDefineCursor(X11->display, w->internalWinId(), XNone);
        }
    } else {
        XDefineCursor(X11->display, w->internalWinId(), XNone);
    }
}

Here is the call graph for this function:

static bool qt_x11EventFilter

(

XEvent *

ev

)

[static]

Definition at line 322 of file qapplication_x11.cpp.

References qApp.

Referenced by QETWidget::translateConfigEvent(), QETWidget::translateMouseEvent(), and QETWidget::translatePaintEvent().

{
    long unused;
    if (qApp->filterEvent(ev, &unused))
        return true;
    return qApp->x11EventFilter(ev);
}

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

Definition at line 394 of file qapplication_x11.cpp.

References buffer, QByteArray::qsnprintf(), qWarning(), and X11.

{
    if (err->error_code == BadWindow) {
        X11->seen_badwindow = true;
        if (err->request_code == 25 /* X_SendEvent */ && X11->xdndHandleBadwindow())
            return 0;
        if (X11->ignore_badwindow)
            return 0;
    } else if (err->request_code == X11->xinput_major
                && err->error_code == (X11->xinput_errorbase + XI_BadDevice)
                && err->minor_code == 3 /* X_OpenDevice */) {
        return 0;
    } else if (err->error_code == BadMatch && err->request_code == 42 /* X_SetInputFocus */) {
        return 0;
    }

    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";

        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;
}

Here is the call graph for this function:

static int qt_xio_errhandler

(

Display *

)

[static]

Definition at line 462 of file qapplication_x11.cpp.

References appName, and qWarning().

{
    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;
}

Here is the call graph for this function:

static void resetSmState

(

)

[static]

Definition at line 4604 of file qapplication_x11.cpp.

References qt_sm_blockUserInput.

Referenced by QSessionManager::QSessionManager(), sm_dieCallback(), sm_saveCompleteCallback(), sm_saveYourselfCallback(), and sm_shutdownCancelledCallback().

{
//    sm_waitingForPhase2 = false; ### never used?!?
    sm_waitingForInteraction = false;
    sm_interactionActive = false;
    sm_interactStyle = SmInteractStyleNone;
    sm_smActive = false;
    qt_sm_blockUserInput = false;
    sm_isshutdown = false;
//    sm_shouldbefast = false; ### never used?!?
    sm_phase2 = false;
    sm_in_phase2 = false;
}

static void sm_dieCallback	(	SmcConn	smcConn,
		SmPointer	clientData
	)			[static]

Definition at line 4786 of file qapplication_x11.cpp.

References qApp, QEvent::Quit, resetSmState(), and QCoreApplication::sendEvent().

Referenced by QSessionManager::QSessionManager().

{
    if (smcConn != smcConnection)
        return;
    resetSmState();
    QEvent quitEvent(QEvent::Quit);
    QApplication::sendEvent(qApp, &quitEvent);
}

Here is the call graph for this function:

static void sm_interactCallback	(	SmcConn	smcConn,
		SmPointer	clientData
	)			[static]

Definition at line 4811 of file qapplication_x11.cpp.

Referenced by QSessionManager::allowsErrorInteraction(), and QSessionManager::allowsInteraction().

{
    if (smcConn != smcConnection)
        return;
    if (sm_waitingForInteraction)
        ((QSessionManagerPrivate *) clientData)->eventLoop->exit();
}

static void sm_performSaveYourself

(

QSessionManagerPrivate *

)

[static]

Definition at line 4696 of file qapplication_x11.cpp.

References QSessionManager::allowsErrorInteraction(), QX11Info::appClass(), QList< T >::at(), buf, QSessionManager::discardCommand(), QString::fromLatin1(), int, QList< T >::isEmpty(), QString::number(), qApp, qAppName(), QByteArray::qstricmp(), qt_sm_blockUserInput, QSessionManager::restartCommand(), QSessionManager::restartHint(), QSessionManagerPrivate::sessionId, QSessionManagerPrivate::sessionKey, QSessionManager::setDiscardCommand(), QSessionManager::setRestartCommand(), QSessionManagerPrivate::sm, sm_saveYourselfPhase2Callback(), sm_setProperty(), and value.

Referenced by sm_saveYourselfCallback(), and sm_saveYourselfPhase2Callback().

{
    if (sm_isshutdown)
        qt_sm_blockUserInput = true;

    QSessionManager* sm = smd->sm;

    // generate a new session key
    timeval tv;
    gettimeofday(&tv, 0);
    smd->sessionKey  = QString::number(qulonglong(tv.tv_sec)) + QLatin1Char('_') + QString::number(qulonglong(tv.tv_usec));

    QStringList arguments = qApp->arguments();
    QString argument0 = arguments.isEmpty() ? qApp->applicationFilePath() : arguments.at(0);

    // tell the session manager about our program in best POSIX style
    sm_setProperty(QString::fromLatin1(SmProgram), argument0);
    // tell the session manager about our user as well.
    struct passwd *entryPtr = 0;
#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
    QVarLengthArray<char, 1024> buf(sysconf(_SC_GETPW_R_SIZE_MAX));
    struct passwd entry;
    getpwuid_r(geteuid(), &entry, buf.data(), buf.size(), &entryPtr);
#else
    entryPtr = getpwuid(geteuid());
#endif
    if (entryPtr)
        sm_setProperty(QString::fromLatin1(SmUserID), QString::fromLatin1(entryPtr->pw_name));

    // generate a restart and discard command that makes sense
    QStringList restart;
    restart  << argument0 << QLatin1String("-session")
             << smd->sessionId + QLatin1Char('_') + smd->sessionKey;
    if (qstricmp(appName, QX11Info::appClass()) != 0)
        restart << QLatin1String("-name") << qAppName();
    sm->setRestartCommand(restart);
    QStringList discard;
    sm->setDiscardCommand(discard);

    switch (sm_saveType) {
    case SmSaveBoth:
        qApp->commitData(*sm);
        if (sm_isshutdown && sm_cancel)
            break; // we cancelled the shutdown, no need to save state
    // fall through
    case SmSaveLocal:
        qApp->saveState(*sm);
        break;
    case SmSaveGlobal:
        qApp->commitData(*sm);
        break;
    default:
        break;
    }

    if (sm_phase2 && !sm_in_phase2) {
        SmcRequestSaveYourselfPhase2(smcConnection, sm_saveYourselfPhase2Callback, (SmPointer*) smd);
        qt_sm_blockUserInput = false;
    }
    else {
        // close eventual interaction monitors and cancel the
        // shutdown, if required. Note that we can only cancel when
        // performing a shutdown, it does not work for checkpoints
        if (sm_interactionActive) {
            SmcInteractDone(smcConnection, sm_isshutdown && sm_cancel);
            sm_interactionActive = false;
        }
        else if (sm_cancel && sm_isshutdown) {
            if (sm->allowsErrorInteraction()) {
                SmcInteractDone(smcConnection, True);
                sm_interactionActive = false;
            }
        }

        // set restart and discard command in session manager
        sm_setProperty(QString::fromLatin1(SmRestartCommand), sm->restartCommand());
        sm_setProperty(QString::fromLatin1(SmDiscardCommand), sm->discardCommand());

        // set the restart hint
        SmPropValue prop;
        prop.length = sizeof(int);
        int value = sm->restartHint();
        prop.value = (SmPointer) &value;
        sm_setProperty(SmRestartStyleHint, SmCARD8, 1, &prop);

        // we are done
        SmcSaveYourselfDone(smcConnection, !sm_cancel);
    }
}

Here is the call graph for this function:

static void sm_saveCompleteCallback	(	SmcConn	smcConn,
		SmPointer	clientData
	)			[static]

Definition at line 4804 of file qapplication_x11.cpp.

References resetSmState().

Referenced by QSessionManager::QSessionManager().

{
    if (smcConn != smcConnection)
        return;
    resetSmState();
}

Here is the call graph for this function:

static void sm_saveYourselfCallback	(	SmcConn	smcConn,
		SmPointer	clientData,
		int	saveType,
		Bool	shutdown,
		int	interactStyle,
		Bool	fast
	)			[static]

Definition at line 4673 of file qapplication_x11.cpp.

References resetSmState(), and sm_performSaveYourself().

Referenced by QSessionManager::QSessionManager().

{
    if (smcConn != smcConnection)
        return;
    sm_cancel = false;
    sm_smActive = true;
    sm_isshutdown = shutdown;
    sm_saveType = saveType;
    sm_interactStyle = interactStyle;
//    sm_shouldbefast = fast; ### never used?!?

    // ugly workaround for broken libSM. libSM should do that _before_
    // actually invoking the callback in sm_process.c
    ((QT_smcConn*)smcConn)->save_yourself_in_progress = true;
    if (sm_isshutdown)
        ((QT_smcConn*)smcConn)->shutdown_in_progress = true;

    sm_performSaveYourself((QSessionManagerPrivate*) clientData);
    if (!sm_isshutdown) // we cannot expect a confirmation message in that case
        resetSmState();
}

Here is the call graph for this function:

static void sm_saveYourselfPhase2Callback	(	SmcConn	smcConn,
		SmPointer	clientData
	)			[static]

Definition at line 4819 of file qapplication_x11.cpp.

References sm_performSaveYourself().

Referenced by sm_performSaveYourself().

{
    if (smcConn != smcConnection)
        return;
    sm_in_phase2 = true;
    sm_performSaveYourself((QSessionManagerPrivate*) clientData);
}

Here is the call graph for this function:

static void sm_setProperty	(	const QString &	name,
		const QStringList &	value
	)			[static]

Definition at line 4651 of file qapplication_x11.cpp.

References QList< T >::append(), QByteArray::data(), QList< T >::last(), name, sm_setProperty(), and value.

{
    SmPropValue *prop = new SmPropValue[value.count()];
    int count = 0;
    QList<QByteArray> vl;
    for (QStringList::ConstIterator it = value.begin(); it != value.end(); ++it) {
      prop[count].length = (*it).length();
      vl.append((*it).toUtf8());
      prop[count].value = (char*)vl.last().data();
      ++count;
    }
    sm_setProperty(name.toLatin1().data(), SmLISTofARRAY8, count, prop);
    delete [] prop;
}

Here is the call graph for this function:

static void sm_setProperty	(	const QString &	name,
		const QString &	value
	)			[static]

Definition at line 4642 of file qapplication_x11.cpp.

References QByteArray::constData(), QByteArray::length(), name, sm_setProperty(), and value.

{
    QByteArray v = value.toUtf8();
    SmPropValue prop;
    prop.length = v.length();
    prop.value = (SmPointer) v.constData();
    sm_setProperty(name.toLatin1().data(), SmARRAY8, 1, &prop);
}

Here is the call graph for this function:

static void sm_setProperty	(	const char *	name,
		const char *	type,
		int	num_vals,
		SmPropValue *	vals
	)			[static]

Definition at line 4621 of file qapplication_x11.cpp.

References props.

Referenced by QSessionManager::setManagerProperty(), sm_performSaveYourself(), and sm_setProperty().

{
    if (num_vals) {
      SmProp prop;
      prop.name = (char*)name;
      prop.type = (char*)type;
      prop.num_vals = num_vals;
      prop.vals = vals;

      SmProp* props[1];
      props[0] = ∝
      SmcSetProperties(smcConnection, 1, props);
    }
    else {
      char* names[1];
      names[0] = (char*) name;
      SmcDeleteProperties(smcConnection, 1, names);
    }
}

static void sm_shutdownCancelledCallback	(	SmcConn	smcConn,
		SmPointer	clientData
	)			[static]

Definition at line 4795 of file qapplication_x11.cpp.

References resetSmState().

Referenced by QSessionManager::QSessionManager().

{
    if (smcConn != smcConnection)
        return;
    if (sm_waitingForInteraction)
        ((QSessionManagerPrivate *) clientData)->eventLoop->exit();
    resetSmState();
}

Here is the call graph for this function:

static bool translateBySips	(	QWidget *	that,
		QRect &	paintRect
	)			[static]

Definition at line 4164 of file qapplication_x11.cpp.

References QRect::translate(), and X11.

Referenced by QETWidget::translatePaintEvent().

{
    int dx=0, dy=0;
    int sips=0;
    for (int i = 0; i < X11->sip_list.size(); ++i) {
        const QX11Data::ScrollInProgress &sip = X11->sip_list.at(i);
        if (sip.scrolled_widget == that) {
            if (sips) {
                dx += sip.dx;
                dy += sip.dy;
            }
            sips++;
        }
    }
    if (sips > 1) {
        paintRect.translate(dx, dy);
        return true;
    }
    return false;
}

Here is the call graph for this function:

static Qt::MouseButtons translateMouseButtons

(

int

s

)

[static]

Definition at line 3323 of file qapplication_x11.cpp.

References Qt::LeftButton, Qt::MidButton, and Qt::RightButton.

Referenced by QETWidget::translateMouseEvent().

{
    Qt::MouseButtons ret = 0;
    if (s & Button1Mask)
        ret |= Qt::LeftButton;
    if (s & Button2Mask)
        ret |= Qt::MidButton;
    if (s & Button3Mask)
        ret |= Qt::RightButton;
    return ret;
}

---

Variable Documentation

bool app_do_modal = false [static]

Definition at line 267 of file qapplication_x11.cpp.

Referenced by QApplicationPrivate::enterModal_sys(), QApplicationPrivate::leaveModal_sys(), and QApplicationPrivate::modalState().

bool app_save_rootinfo = false [static]

Definition at line 266 of file qapplication_x11.cpp.

Referenced by qt_cleanup(), and qt_updated_rootinfo().

const char* appBGCol = 0 [static]

Definition at line 252 of file qapplication_x11.cpp.

const char* appBTNCol = 0 [static]

Definition at line 254 of file qapplication_x11.cpp.

const char* appClass = 0 [static]

Definition at line 250 of file qapplication_x11.cpp.

Referenced by QX11Info::appClass(), qt_cleanup(), qt_init(), and qt_set_x11_resources().

const char* appFGCol = 0 [static]

Definition at line 253 of file qapplication_x11.cpp.

const char* appFont = 0 [static]

Definition at line 251 of file qapplication_x11.cpp.

const char* appName = 0 [static]

Definition at line 249 of file qapplication_x11.cpp.

Referenced by QWidgetPrivate::create_sys(), qt_init(), qt_set_x11_resources(), qt_xio_errhandler(), and Main::updateStatus().

bool appSync = false [static]

Definition at line 261 of file qapplication_x11.cpp.

Window curWin = 0 [static]

Definition at line 268 of file qapplication_x11.cpp.

Referenced by QApplicationPrivate::enterModal_sys(), and QApplicationPrivate::leaveModal_sys().

Window mouseActWindow = 0 [static]

Definition at line 290 of file qapplication_x11.cpp.

Referenced by QETWidget::translateMouseEvent().

Qt::MouseButton mouseButtonPressed = Qt::NoButton [static]

Definition at line 291 of file qapplication_x11.cpp.

Referenced by QETWidget::translateMouseEvent().

Time mouseButtonPressTime = 0 [static]

Definition at line 293 of file qapplication_x11.cpp.

Referenced by QApplicationPrivate::closePopup(), and QETWidget::translateMouseEvent().

Qt::MouseButtons mouseButtonState = Qt::NoButton [static]

Definition at line 292 of file qapplication_x11.cpp.

Referenced by QETWidget::translateMouseEvent().

short mouseGlobalXPos [static]

Definition at line 295 of file qapplication_x11.cpp.

Referenced by QApplicationPrivate::closePopup(), and QETWidget::translateMouseEvent().

short mouseGlobalYPos [static]

Definition at line 295 of file qapplication_x11.cpp.

Referenced by QApplicationPrivate::closePopup(), and QETWidget::translateMouseEvent().

short mouseXPos [static]

Definition at line 294 of file qapplication_x11.cpp.

Referenced by QETWidget::translateMouseEvent().

short mouseYPos [static]

Definition at line 294 of file qapplication_x11.cpp.

Referenced by QETWidget::translateMouseEvent().

const char* mwGeometry = 0 [static]

Definition at line 255 of file qapplication_x11.cpp.

const char* mwTitle = 0 [static]

Definition at line 256 of file qapplication_x11.cpp.

int openPopupCount = 0 [static]

Definition at line 3211 of file qapplication_x11.cpp.

int(*) original_x_errhandler(Display *dpy, XErrorEvent *) [static]

Definition at line 391 of file qapplication_x11.cpp.

Referenced by qt_cleanup().

int(*) original_xio_errhandler(Display *dpy) [static]

Definition at line 392 of file qapplication_x11.cpp.

Referenced by qt_cleanup().

bool popupGrabOk [static]

Definition at line 304 of file qapplication_x11.cpp.

Referenced by QApplicationPrivate::closePopup(), and QApplicationPrivate::openPopup().

Window pressed_window = XNone [static]

Definition at line 300 of file qapplication_x11.cpp.

uchar qt_alt_mask = 0

Definition at line 281 of file qapplication_x11.cpp.

Referenced by QKeyMapperPrivate::clearMappings(), and QX11Data::translateModifiers().

bool qt_app_has_font

Definition at line 363 of file qapplication.cpp.

Referenced by qt_set_x11_resources(), QApplication::setFont(), and QApplication::~QApplication().

bool qt_broken_wm = false

Definition at line 271 of file qapplication_x11.cpp.

Referenced by qt_detect_broken_window_manager(), and QWidgetPrivate::setGeometry_sys().

QWidget* qt_button_down = 0

Definition at line 342 of file qapplication_x11.cpp.

Referenced by QApplicationPrivate::closePopup(), QWidgetPrivate::deactivateWidgetCleanup(), qt_try_modal(), and QETWidget::translateMouseEvent().

uchar qt_hyper_mask = 0

Definition at line 284 of file qapplication_x11.cpp.

Referenced by QKeyMapperPrivate::clearMappings(), and translateKeySym().

QTextCodec* qt_input_mapper = 0

Definition at line 334 of file qapplication_x11.cpp.

Referenced by qt_set_input_encoding(), translateKeySym(), and QXIMInputContext::x11FilterEvent().

bool qt_is_gui_used

Definition at line 375 of file qapplication.cpp.

uchar qt_meta_mask = 0

Definition at line 282 of file qapplication_x11.cpp.

Referenced by QKeyMapperPrivate::clearMappings(), translateKeySym(), and QX11Data::translateModifiers().

QWidgetList* qt_modal_stack

Definition at line 423 of file qapplication.cpp.

Referenced by QApplication::activeModalWidget(), QApplicationPrivate::enterModal_sys(), QApplicationPrivate::isBlockedByModal(), and QApplicationPrivate::leaveModal_sys().

uchar qt_mode_switch_mask = 0

Definition at line 285 of file qapplication_x11.cpp.

Referenced by QKeyMapperPrivate::clearMappings(), and QX11Data::translateModifiers().

QWidget* qt_popup_down = 0 [static]

Definition at line 343 of file qapplication_x11.cpp.

Referenced by QApplicationPrivate::closePopup(), and QETWidget::translateMouseEvent().

bool qt_reuse_double_buffer = true

Definition at line 308 of file qapplication_x11.cpp.

bool qt_sm_blockUserInput = false

Definition at line 306 of file qapplication_x11.cpp.

Referenced by QSessionManager::allowsErrorInteraction(), QSessionManager::allowsInteraction(), QSessionManager::release(), resetSmState(), sm_performSaveYourself(), and QETWidget::translateMouseEvent().

uchar qt_super_mask = 0

Definition at line 283 of file qapplication_x11.cpp.

Referenced by QKeyMapperPrivate::clearMappings(), and translateKeySym().

bool qt_tabletChokeMouse

Definition at line 397 of file qapplication.cpp.

Referenced by QApplication::notify(), and QETWidget::translateMouseEvent().

bool qt_use_rtl_extensions = false

Definition at line 288 of file qapplication_x11.cpp.

Referenced by QLineEdit::createStandardContextMenu(), and QKeyMapperPrivate::translateKeyEventInternal().

Q_GUI_EXPORT QX11Data* qt_x11Data = 0

Definition at line 244 of file qapplication_x11.cpp.

Referenced by QX11Data::badwindow(), QX11Data::ignoreBadwindow(), and x11Time().

bool qt_xdnd_dragging

Definition at line 209 of file qdnd_x11.cpp.

Referenced by QDragManager::cancel(), QDragManager::drag(), QDragManager::drop(), qt_try_modal(), and QETWidget::translateMouseEvent().

Q_GUI_EXPORT int qt_xfocusout_grab_counter = 0

Definition at line 310 of file qapplication_x11.cpp.

int qt_ximComposingKeycode = 0

Definition at line 333 of file qapplication_x11.cpp.

Referenced by QKeyMapperPrivate::translateKeyEventInternal(), and QXIMInputContext::x11FilterEvent().

char* qt_ximServer = 0

Definition at line 257 of file qapplication_x11.cpp.

Referenced by QXIMInputContext::QXIMInputContext().

bool replayPopupMouseEvent = false [static]

Definition at line 303 of file qapplication_x11.cpp.

Referenced by QApplicationPrivate::closePopup(), and QETWidget::translateMouseEvent().

bool sm_cancel [static]

Definition at line 4582 of file qapplication_x11.cpp.

bool sm_in_phase2 [static]

Definition at line 4588 of file qapplication_x11.cpp.

bool sm_interactionActive [static]

Definition at line 4578 of file qapplication_x11.cpp.

int sm_interactStyle [static]

Definition at line 4580 of file qapplication_x11.cpp.

bool sm_isshutdown [static]

Definition at line 4585 of file qapplication_x11.cpp.

bool sm_phase2 [static]

Definition at line 4587 of file qapplication_x11.cpp.

QSmSocketReceiver* sm_receiver = 0 [static]

Definition at line 4590 of file qapplication_x11.cpp.

Referenced by QSessionManager::QSessionManager(), and QSessionManager::~QSessionManager().

int sm_saveType [static]

Definition at line 4581 of file qapplication_x11.cpp.

bool sm_smActive [static]

Definition at line 4579 of file qapplication_x11.cpp.

bool sm_waitingForInteraction [static]

Definition at line 4584 of file qapplication_x11.cpp.

SmcConn smcConnection = 0 [static]

Definition at line 4577 of file qapplication_x11.cpp.

QWidgetMapper* wPRmapper = 0 [static]

Definition at line 2417 of file qapplication_x11.cpp.

Referenced by qPRCleanup(), qPRCreate(), and qPRFindWidget().

const char* x11_atomnames [static]

Definition at line 120 of file qapplication_x11.cpp.

Referenced by qt_x11_create_intern_atoms().

---