QX11Info Class Reference

The QX11Info class provides information about the X display configuration. More...

#include <qx11info_x11.h>

Public Functions
int	cells () const
	Returns the number of cells. More...
Qt::HANDLE	colormap () const
	Returns a handle for the color map. More...
bool	defaultColormap () const
	Returns true if there is a default color map; otherwise returns false. More...
bool	defaultVisual () const
	Returns true if there is a default visual; otherwise returns false. More...
int	depth () const
	Returns the color depth (bits per pixel) of the X display. More...
QX11Info &	operator= (const QX11Info &other)
	Assigns other to this object and returns a reference to this object. More...
	QX11Info ()
	Constructs an empty QX11Info object. More...
	QX11Info (const QX11Info &other)
	Constructs a copy of other. More...
int	screen () const
	Returns the number of the screen currently in use. More...
void *	visual () const
	Returns the current visual. More...
	~QX11Info ()
	Destroys the QX11Info object. More...

Static Public Functions
static int	appCells (int screen=-1)
	Returns the number of cells used by the application on the given screen. More...
static const char *	appClass ()
	Returns the X11 application class. More...
static Qt::HANDLE	appColormap (int screen=-1)
	Returns a handle for the application's color map on the given screen. More...
static bool	appDefaultColormap (int screen=-1)
	Returns true if the application has a default color map on the given screen; otherwise returns false. More...
static bool	appDefaultVisual (int screen=-1)
	Returns true if the application has a default visual on the given screen; otherwise returns false. More...
static int	appDepth (int screen=-1)
	Returns the color depth (bits per pixel) used by the application on the given screen. More...
static int	appDpiX (int screen=-1)
	Returns the horizontal resolution of the given screen in terms of the number of dots per inch. More...
static int	appDpiY (int screen=-1)
	Returns the vertical resolution of the given screen in terms of the number of dots per inch. More...
static Qt::HANDLE	appRootWindow (int screen=-1)
	Returns a handle for the applications root window on the given screen. More...
static int	appScreen ()
	Returns the number of the screen where the application is being displayed. More...
static unsigned long	appTime ()
	Returns the X11 time. More...
static unsigned long	appUserTime ()
	Returns the X11 user time. More...
static void *	appVisual (int screen=-1)
	Returns the current visual used by the application on the given screen. More...
static Display *	display ()
	Returns the default display for the application. More...
static bool	isCompositingManagerRunning ()
	Returns true if there is a compositing manager running. More...
static void	setAppDpiX (int screen, int dpi)
	Sets the horizontal resolution of the given screen to the number of dots per inch specified by xdpi. More...
static void	setAppDpiY (int screen, int dpi)
	Sets the vertical resolution of the given screen to the number of dots per inch specified by ydpi. More...
static void	setAppTime (unsigned long time)
	Sets the X11 time to the value specified by time. More...
static void	setAppUserTime (unsigned long time)
	Sets the X11 user time as specified by time. More...

Protected Functions
void	cloneX11Data (const QPaintDevice *)
	Makes a deep copy of the X11-specific data of fromDevice, if it is not null. More...
void	copyX11Data (const QPaintDevice *)
	Makes a shallow copy of the X11-specific data of fromDevice, if it is not null. More...
QX11InfoData *	getX11Data (bool def=false) const
void	setX11Data (const QX11InfoData *)
	Makes a shallow copy of the X11-specific data d and assigns it to this class. More...

Protected Variables
QX11InfoData *	x11data

Friends
class	QGLWidget
class	QPixmap
void	qt_cleanup ()
void	qt_init (QApplicationPrivate *priv, int, Display *display, Qt::HANDLE visual, Qt::HANDLE colormap)
void	qt_x11_getX11InfoForWindow (QX11Info *xinfo, const QX11WindowAttributes &a)
class	QWidget
class	QWidgetPrivate
class	QX11PaintEngine
class	QX11PixmapData

Detailed Description

The QX11Info class provides information about the X display configuration.

The class provides two APIs: a set of non-static functions that provide information about a specific widget or pixmap, and a set of static functions that provide the default information for the application.

Warning

This class is only available on X11. For querying per-screen information in a portable way, use QDesktopWidget.

See also

QWidget::x11Info(), QPixmap::x11Info(), QDesktopWidget

Definition at line 63 of file qx11info_x11.h.

Constructors and Destructors

QX11Info() [1/2]

QX11Info::QX11Info

(

)

Constructs an empty QX11Info object.

Definition at line 73 of file qx11info_x11.cpp.

    : x11data(0)
{
}

~QX11Info()

QX11Info::~QX11Info

(

)

Destroys the QX11Info object.

Definition at line 105 of file qx11info_x11.cpp.

{
    if (x11data && !--x11data->ref)
        delete x11data;
}

QX11Info() [2/2]

QX11Info::QX11Info

(

const QX11Info &

other

)

Constructs a copy of other.

Definition at line 81 of file qx11info_x11.cpp.

{
    x11data = other.x11data;
    if (x11data)
        ++x11data->ref;
}

Functions

appCells()

int QX11Info::appCells ( int  screen = -1 )

static

Returns the number of cells used by the application on the given screen.

The screen argument is an X screen number. Be aware that if the user's system uses Xinerama (as opposed to traditional X11 multiscreen), there is only one X screen. Use QDesktopWidget to query for information about Xinerama screens.

See also

cells()

Definition at line 450 of file qx11info_x11.cpp.

Referenced by cells(), QX11PixmapData::convertToARGB32(), QX11PixmapData::fromImage(), getX11Data(), QPaintDevice::qt_x11Info(), QX11PixmapData::resize(), and QX11PixmapData::transformed().

{ return X11 ? X11->screens[screen == -1 ? X11->defaultScreen : screen].cells : 0; }

appClass()

const char * QX11Info::appClass ( )

static

Returns the X11 application class.

See also

display()

Definition at line 2820 of file qapplication_x11.cpp.

Referenced by getNetWmState(), and sm_performSaveYourself().

{
    return QT_PREPEND_NAMESPACE(appClass);
}

appColormap()

Qt::HANDLE QX11Info::appColormap ( int  screen = -1 )

static

Returns a handle for the application's color map on the given screen.

The screen argument is an X screen number. Be aware that if the user's system uses Xinerama (as opposed to traditional X11 multiscreen), there is only one X screen. Use QDesktopWidget to query for information about Xinerama screens.

See also

colormap(), defaultColormap()

Definition at line 385 of file qx11info_x11.cpp.

Referenced by colormap(), QX11PixmapData::convertToARGB32(), QX11PixmapData::fromImage(), qt_gl_choose_cmap(), qt_x11_getX11InfoForWindow(), QPaintDevice::qt_x11Info(), QX11PixmapData::resize(), QColor::setColorFromString(), and QX11PixmapData::transformed().

{
    return X11 ? X11->screens[screen == -1 ? X11->defaultScreen : screen].colormap : 0;
}

appDefaultColormap()

bool QX11Info::appDefaultColormap ( int  screen = -1 )

static

Returns true if the application has a default color map on the given screen; otherwise returns false.

The screen argument is an X screen number. Be aware that if the user's system uses Xinerama (as opposed to traditional X11 multiscreen), there is only one X screen. Use QDesktopWidget to query for information about Xinerama screens.

Definition at line 462 of file qx11info_x11.cpp.

Referenced by QX11PixmapData::convertToARGB32(), defaultColormap(), QX11PixmapData::fromImage(), getX11Data(), qstring_to_xtp(), QPaintDevice::qt_x11Info(), QX11PixmapData::resize(), and QX11PixmapData::transformed().

{ return X11 ? X11->screens[screen == -1 ? X11->defaultScreen : screen].defaultColormap : true; }

appDefaultVisual()

bool QX11Info::appDefaultVisual ( int  screen = -1 )

static

Returns true if the application has a default visual on the given screen; otherwise returns false.

The screen argument is an X screen number. Be aware that if the user's system uses Xinerama (as opposed to traditional X11 multiscreen), there is only one X screen. Use QDesktopWidget to query for information about Xinerama screens.

Definition at line 474 of file qx11info_x11.cpp.

Referenced by QX11PixmapData::convertToARGB32(), defaultVisual(), QX11PixmapData::fromImage(), getX11Data(), qstring_to_xtp(), QPaintDevice::qt_x11Info(), QX11PixmapData::resize(), and QX11PixmapData::transformed().

{ return X11 ? X11->screens[screen == -1 ? X11->defaultScreen : screen].defaultVisual : true; }

appDepth()

int QX11Info::appDepth ( int  screen = -1 )

static

Returns the color depth (bits per pixel) used by the application on the given screen.

The screen argument is an X screen number. Be aware that if the user's system uses Xinerama (as opposed to traditional X11 multiscreen), there is only one X screen. Use QDesktopWidget to query for information about Xinerama screens.

See also

depth()

Definition at line 434 of file qx11info_x11.cpp.

Referenced by QX11PixmapData::convertToARGB32(), QPixmap::defaultDepth(), depth(), QX11PixmapData::fromImage(), getX11Data(), qt_addPatternProps(), QPaintDevice::qt_x11Info(), QX11PixmapData::resize(), QStyle::standardPalette(), QMotifStyle::standardPalette(), QNativeImage::systemFormat(), QX11PixmapData::transformed(), and QX11PixmapData::x11ConvertToDefaultDepth().

{
    return X11 ? X11->screens[screen == -1 ? X11->defaultScreen : screen].depth : 32;
}

appDpiX()

int QX11Info::appDpiX ( int  screen = -1 )

static

Returns the horizontal resolution of the given screen in terms of the number of dots per inch.

The screen argument is an X screen number. Be aware that if the user's system uses Xinerama (as opposed to traditional X11 multiscreen), there is only one X screen. Use QDesktopWidget to query for information about Xinerama screens.

See also

setAppDpiX(), appDpiY()

Definition at line 221 of file qx11info_x11.cpp.

Referenced by do_size_hints(), QX11PixmapData::metric(), qt_defaultDpiX(), and QPaintDevice::qt_x11Info().

{
    if (!X11)
        return 75;
    if (screen < 0)
        screen = X11->defaultScreen;
    if (screen > X11->screenCount)
        return 0;
    return X11->screens[screen].dpiX;
}

appDpiY()

int QX11Info::appDpiY ( int  screen = -1 )

static

Returns the vertical resolution of the given screen in terms of the number of dots per inch.

The screen argument is an X screen number. Be aware that if the user's system uses Xinerama (as opposed to traditional X11 multiscreen), there is only one X screen. Use QDesktopWidget to query for information about Xinerama screens.

See also

setAppDpiY(), appDpiX()

Definition at line 267 of file qx11info_x11.cpp.

Referenced by do_size_hints(), QFontDatabase::loadXlfd(), QX11PixmapData::metric(), QFontDatabase::pointSizes(), qt_defaultDpiY(), qt_FcPatternToQFontDef(), qt_set_x11_resources(), QPaintDevice::qt_x11Info(), and QFontDatabase::smoothSizes().

{
    if (!X11)
        return 75;
    if (screen < 0)
        screen = X11->defaultScreen;
    if (screen > X11->screenCount)
        return 0;
    return X11->screens[screen].dpiY;
}

appRootWindow()

Qt::HANDLE QX11Info::appRootWindow ( int  screen = -1 )

static

Returns a handle for the applications root window on the given screen.

The screen argument is an X screen number. Be aware that if the user's system uses Xinerama (as opposed to traditional X11 multiscreen), there is only one X screen. Use QDesktopWidget to query for information about Xinerama screens.

See also

QApplication::desktop()

Definition at line 417 of file qx11info_x11.cpp.

Referenced by create_wm_client_leader(), QX11PixmapData::createBitmapFromImage(), QX11Data::findClientWindow(), findRealWindow(), QDesktopWidgetPrivate::init(), QSizeGrip::mousePressEvent(), QCursor::QCursor(), qt_get_net_supported(), qt_get_net_virtual_roots(), qt_save_rootinfo(), qt_set_input_encoding(), qt_set_x11_resources(), qt_x11_apply_settings_in_all_apps(), QPaintDevice::qt_x11Info(), QX11EmbedContainerPrivate::rejectClient(), QApplication::syncX(), QSystemTrayIconSys::sysTrayTracker(), QETWidget::translateConfigEvent(), QX11EmbedWidget::x11Event(), and QApplication::x11ProcessEvent().

{
    return X11 ? RootWindow(X11->display, screen == -1 ? X11->defaultScreen : screen) : 0;
}

appScreen()

int QX11Info::appScreen ( )

static

Returns the number of the screen where the application is being displayed.

See also

display(), screen()

Definition at line 370 of file qx11info_x11.cpp.

Referenced by QX11PixmapData::fromImage(), getX11Data(), QSystemTrayIconSys::locateSystemTray(), QFontPrivate::QFontPrivate(), qt_x11_getX11InfoForWindow(), qt_x11_set_fallback_font_family(), QPaintDevice::qt_x11Info(), screen(), and QX11PixmapData::transformed().

{
    return X11 ? X11->defaultScreen : 0;
}

appTime()

unsigned long QX11Info::appTime ( )

static

Returns the X11 time.

See also

setAppTime(), appUserTime()

Definition at line 305 of file qx11info_x11.cpp.

{
    return X11 ? X11->time : 0;
}

appUserTime()

unsigned long QX11Info::appUserTime ( )

static

Returns the X11 user time.

See also

setAppUserTime(), appTime()

Definition at line 327 of file qx11info_x11.cpp.

Referenced by QGtkStylePrivate::setupGtkFileChooser().

{
    return X11 ? X11->userTime : 0;
}

appVisual()

void * QX11Info::appVisual ( int  screen = -1 )

static

Returns the current visual used by the application on the given screen.

The screen argument is an X screen number. Be aware that if the user's system uses Xinerama (as opposed to traditional X11 multiscreen), there is only one X screen. Use QDesktopWidget to query for information about Xinerama screens.

See also

visual(), defaultVisual()

Definition at line 402 of file qx11info_x11.cpp.

Referenced by QX11PixmapData::convertToARGB32(), QX11PixmapData::fromImage(), getX11Data(), qt_gl_choose_cmap(), qt_init(), qt_transparent_pixel(), qt_x11_getX11InfoForWindow(), QPaintDevice::qt_x11Info(), QX11PixmapData::resize(), QX11PixmapData::transformed(), and visual().

{
    return X11 ? X11->screens[screen == -1 ? X11->defaultScreen : screen].visual : 0;
}

cells()

int QX11Info::cells

(

)

const

Returns the number of cells.

See also

appCells()

Definition at line 505 of file qx11info_x11.cpp.

Referenced by QPaintDevice::qt_x11Info().

{ return x11data ? x11data->cells : QX11Info::appCells(); }

cloneX11Data()

void QX11Info::cloneX11Data ( const QPaintDevice *  fromDevice )

protected

Makes a deep copy of the X11-specific data of fromDevice, if it is not null.

Warning

This function is not part of the public interface. Otherwise this function sets it to null.

Definition at line 141 of file qx11info_x11.cpp.

{
    QX11InfoData *d = 0;
    if (fromDevice) {
        QX11InfoData *xd;
        if (fromDevice->devType() == QInternal::Widget) {
            xd = static_cast<const QWidget *>(fromDevice)->x11Info().x11data;
    } else {
        Q_ASSERT(fromDevice->devType() == QInternal::Pixmap);
            xd = static_cast<const QPixmap *>(fromDevice)->x11Info().x11data;
    }
        d = new QX11InfoData(*xd);
        d->ref = 0;
    }
    setX11Data(d);
}

colormap()

Qt::HANDLE QX11Info::colormap

(

)

const

Returns a handle for the color map.

See also

defaultColormap()

Definition at line 514 of file qx11info_x11.cpp.

Referenced by getX11Data(), and QPaintDevice::qt_x11Info().

{ return x11data ? x11data->colormap : QX11Info::appColormap(); }

copyX11Data()

void QX11Info::copyX11Data ( const QPaintDevice *  fromDevice )

protected

Makes a shallow copy of the X11-specific data of fromDevice, if it is not null.

Warning

This function is not part of the public interface. Otherwise this function sets it to null.

Definition at line 120 of file qx11info_x11.cpp.

{
    QX11InfoData *xd = 0;
    if (fromDevice) {
        if (fromDevice->devType() == QInternal::Widget)
            xd = static_cast<const QWidget *>(fromDevice)->x11Info().x11data;
        else if (fromDevice->devType() == QInternal::Pixmap)
            xd = static_cast<const QPixmap *>(fromDevice)->x11Info().x11data;
    }
    setX11Data(xd);
}

defaultColormap()

bool QX11Info::defaultColormap

(

)

const

Returns true if there is a default color map; otherwise returns false.

See also

colormap()

Definition at line 523 of file qx11info_x11.cpp.

Referenced by QPaintDevice::qt_x11Info().

{ return x11data ? x11data->defaultColormap : QX11Info::appDefaultColormap(); }

defaultVisual()

bool QX11Info::defaultVisual

(

)

const

Returns true if there is a default visual; otherwise returns false.

See also

visual(), appVisual()

Definition at line 541 of file qx11info_x11.cpp.

Referenced by QPaintDevice::qt_x11Info().

{ return x11data ? x11data->defaultVisual : QX11Info::appDefaultVisual(); }

depth()

int QX11Info::depth

(

)

const

Returns the color depth (bits per pixel) of the X display.

See also

appDepth()

Definition at line 496 of file qx11info_x11.cpp.

Referenced by buildSpec(), QRasterWindowSurface::flush(), QX11PixmapData::fromImage(), QRasterWindowSurface::QRasterWindowSurface(), QPaintDevice::qt_x11Info(), QX11WindowSurface::QX11WindowSurface(), QX11PixmapData::resize(), and QNativeImage::systemFormat().

{ return x11data ? x11data->depth : QX11Info::appDepth(); }

display()

Display * QX11Info::display ( )

static

Returns the default display for the application.

See also

appScreen()

Definition at line 359 of file qx11info_x11.cpp.

Referenced by QSystemTrayIconSys::addToTray(), QGLContextPrivate::bindTextureFromNativePixmap(), buildSpec(), QEgl::createSurface(), QPixmap::depth(), QGLContextPrivate::destroyGlSurfaceForPixmap(), do_size_hints(), ShivaVGWindowSurfacePrivate::ensureContext(), QX11EmbedWidget::eventFilter(), QX11EmbedContainer::eventFilter(), fontExists(), QSystemTrayIconSys::getSysTrayVisualInfo(), init_gray(), init_indexed(), loadRaw(), QFontDatabase::loadXlfd(), loadXlfds(), QSystemTrayIconSys::locateSystemTray(), QSystemTrayIconSys::paintEvent(), QGLOverlayWidget::paintGL(), QFontPrivate::QFontPrivate(), qgl_use_font(), qglx_getProcAddress(), qt_fillFontDef(), qt_fixXLFD(), qt_format_to_attrib_list(), qt_transparent_pixel(), qt_x11_apply_settings_in_all_apps(), QPaintDevice::qt_x11Info(), query_colormap(), QX11PixmapData::release(), QColor::setColorFromString(), QEglProperties::setVisualFormat(), QSystemTrayIconSys::sysTrayTracker(), QGLContext::tryVisual(), QGLContextPrivate::unbindPixmapFromTexture(), windowInteractsWithPosition(), QX11PixmapData::x11ConvertToDefaultDepth(), QX11EmbedContainer::x11Event(), and QFontEngineXLFD::~QFontEngineXLFD().

{
    return X11 ? X11->display : 0;
}

getX11Data()

QX11InfoData * QX11Info::getX11Data ( bool  def = false ) const

protected

Warning

This function is not part of the public interface. If def is false, returns a deep copy of the x11Data, or 0 if x11Data is 0. If def is true, makes a QX11Data struct filled with the default values.

In either case the caller is responsible for deleting the returned struct. But notice that the struct is a shared class, so other classes might also have a reference to it. The reference count of the returned QX11Data* is 0.

Definition at line 189 of file qx11info_x11.cpp.

Referenced by QX11PixmapData::convertToARGB32(), QX11PixmapData::fromImage(), qt_x11_getX11InfoForWindow(), QX11PixmapData::resize(), and QX11PixmapData::transformed().

{
    QX11InfoData* res = 0;
    if (def) {
        res = new QX11InfoData;
        res->ref = 0;
        res->screen = appScreen();
        res->depth = appDepth();
        res->cells = appCells();
        res->colormap = colormap();
        res->defaultColormap = appDefaultColormap();
        res->visual = (Visual*) appVisual();
        res->defaultVisual = appDefaultVisual();
    } else if (x11data) {
        res = new QX11InfoData;
        *res = *x11data;
        res->ref = 0;
    }
    return res;
}

isCompositingManagerRunning()

bool QX11Info::isCompositingManagerRunning ( )

static

Returns true if there is a compositing manager running.

Since

4.4

Definition at line 553 of file qx11info_x11.cpp.

Referenced by QWidgetPrivate::mapFromGlobal().

{
    return X11 ? X11->compositingManagerRunning : false;
}

operator=()

QX11Info & QX11Info::operator=

(

const QX11Info &

other

)

Assigns other to this object and returns a reference to this object.

Definition at line 92 of file qx11info_x11.cpp.

{
    if (other.x11data)
        ++other.x11data->ref;
    if (x11data && !--x11data->ref)
        delete x11data;
    x11data = other.x11data;
    return *this;
}

screen()

int QX11Info::screen

(

)

const

Returns the number of the screen currently in use.

The return value is an X screen number. Be aware that if the user's system uses Xinerama (as opposed to traditional X11 multiscreen), there is only one X screen. Use QDesktopWidget to query for information about Xinerama screens.

See also

appScreen()

Definition at line 487 of file qx11info_x11.cpp.

Referenced by appCells(), appColormap(), appDefaultColormap(), appDefaultVisual(), appDepth(), appDpiX(), appDpiY(), appVisual(), QGLContextPrivate::bindTextureFromNativePixmap(), buildSpec(), QX11PixmapData::convertToARGB32(), QX11PixmapData::copy(), QEgl::createSurface(), QPixmap::depth(), ShivaVGWindowSurfacePrivate::ensureContext(), QX11PixmapData::fill(), QX11PixmapData::fromImage(), getNetWmState(), QX11GLWindowSurface::grabWidget(), QX11WindowSurface::grabWidget(), QDesktopWidgetPrivate::init(), QWidgetPrivate::isBackgroundInherited(), QX11PixmapData::mask(), QX11PixmapData::metric(), QX11PixmapData::paintEngine(), qCanAllocColors(), QFont::QFont(), QFontMetrics::QFontMetrics(), QFontMetricsF::QFontMetricsF(), qstring_to_xtp(), qt_change_net_wm_state(), qt_format_to_attrib_list(), qt_x11_getX11InfoForWindow(), QPaintDevice::qt_x11Info(), QX11PixmapData::resize(), QWhatsThisPrivate::say(), setAppDpiX(), setAppDpiY(), QX11WindowSurface::setGeometry(), QX11PixmapData::setMask(), QX11PixmapData::toImage(), QX11PixmapData::transformed(), QGLContext::tryVisual(), QApplication::x11ClientMessage(), and QApplication::x11ProcessEvent().

{ return x11data ? x11data->screen : QX11Info::appScreen(); }

setAppDpiX()

void QX11Info::setAppDpiX ( int  screen, int  xdpi  )

static

Sets the horizontal resolution of the given screen to the number of dots per inch specified by xdpi.

The screen argument is an X screen number. Be aware that if the user's system uses Xinerama (as opposed to traditional X11 multiscreen), there is only one X screen. Use QDesktopWidget to query for information about Xinerama screens.

See also

appDpiX(), setAppDpiY()

Definition at line 244 of file qx11info_x11.cpp.

Referenced by QPaintDevice::qt_x11Info().

{
    if (!X11)
        return;
    if (screen < 0)
        screen = X11->defaultScreen;
    if (screen > X11->screenCount)
        return;
    X11->screens[screen].dpiX = xdpi;
}

setAppDpiY()

void QX11Info::setAppDpiY ( int  screen, int  ydpi  )

static

Sets the vertical resolution of the given screen to the number of dots per inch specified by ydpi.

The screen argument is an X screen number. Be aware that if the user's system uses Xinerama (as opposed to traditional X11 multiscreen), there is only one X screen. Use QDesktopWidget to query for information about Xinerama screens.

See also

appDpiY(), setAppDpiX()

Definition at line 289 of file qx11info_x11.cpp.

Referenced by QPaintDevice::qt_x11Info().

{
    if (!X11)
        return;
    if (screen < 0)
        screen = X11->defaultScreen;
    if (screen > X11->screenCount)
        return;
    X11->screens[screen].dpiY = ydpi;
}

setAppTime()

void QX11Info::setAppTime ( unsigned long  time )

static

Sets the X11 time to the value specified by time.

See also

appTime(), setAppUserTime()

Definition at line 315 of file qx11info_x11.cpp.

{
    if (X11) {
        X11->time = time;
    }
}

setAppUserTime()

void QX11Info::setAppUserTime ( unsigned long  time )

static

Sets the X11 user time as specified by time.

See also

appUserTime(), setAppTime()

Definition at line 337 of file qx11info_x11.cpp.

{
    if (X11) {
        X11->userTime = time;
    }
}

setX11Data()

void QX11Info::setX11Data ( const QX11InfoData *  d )

protected

Makes a shallow copy of the X11-specific data d and assigns it to this class.

Warning

This function is not part of the public interface. This function increments the reference code of d.

Definition at line 167 of file qx11info_x11.cpp.

Referenced by cloneX11Data(), QX11PixmapData::convertToARGB32(), copyX11Data(), QX11PixmapData::fromImage(), qt_x11_getX11InfoForWindow(), QX11PixmapData::resize(), and QX11PixmapData::transformed().

{
    if (x11data && !--x11data->ref)
        delete x11data;
    x11data = (QX11InfoData *)d;
    if (x11data)
        ++x11data->ref;
}

visual()

void * QX11Info::visual

(

)

const

Returns the current visual.

See also

appVisual(), defaultVisual()

Definition at line 532 of file qx11info_x11.cpp.

Referenced by buildSpec(), QX11PixmapData::canTakeQImageFromXImage(), QX11PixmapData::copy(), QEgl::createSurface(), QRasterWindowSurface::flush(), QX11PixmapData::fromImage(), getNetWmState(), qCanAllocColors(), qt_renderformat_for_depth(), QPaintDevice::qt_x11Info(), QX11PixmapData::resize(), QEglProperties::setVisualFormat(), QNativeImage::systemFormat(), QX11PixmapData::toImage(), QX11PixmapData::transformed(), and QX11PixmapData::x11ConvertToDefaultDepth().

{ return x11data ? x11data->visual : QX11Info::appVisual(); }

Friends and Related Functions

QGLWidget

friend class QGLWidget

friend

Definition at line 112 of file qx11info_x11.h.

QPixmap

friend class QPixmap

friend

Definition at line 108 of file qx11info_x11.h.

qt_cleanup

void qt_cleanup ( )

friend

Definition at line 1328 of file qapplication_mac.mm.

{
    CGDisplayRemoveReconfigurationCallback(qt_mac_display_change_callbk, 0);
    CFNotificationCenterRef center = CFNotificationCenterGetDistributedCenter();
    CFNotificationCenterRemoveObserver(center, qApp, kCMDeviceUnregisteredNotification, 0);
    CFNotificationCenterRemoveObserver(center, qApp, kCMDefaultDeviceNotification, 0);
    CFNotificationCenterRemoveObserver(center, qApp, kCMDeviceProfilesNotification, 0);
    CFNotificationCenterRemoveObserver(center, qApp, kCMDefaultDeviceProfileNotification, 0);

#ifndef QT_MAC_USE_COCOA
    qt_release_app_proc_handler();
    if (app_proc_handlerUPP) {
        DisposeEventHandlerUPP(app_proc_handlerUPP);
        app_proc_handlerUPP = 0;
    }
#endif
    qt_release_apple_event_handler();

#ifdef QT_MAC_USE_COCOA
    qt_resetNSApplicationSendEvent();
#endif

    qt_release_tablet_proximity_handler();
    if (tablet_proximity_UPP)
        DisposeEventHandlerUPP(tablet_proximity_UPP);

    QPixmapCache::clear();
    if (qt_is_gui_used) {
#ifndef QT_NO_ACCESSIBILITY
        QAccessible::cleanup();
#endif
#ifndef QT_NO_IM
        QMacInputContext::cleanup();
#endif
        QCursorData::cleanup();
        QFont::cleanup();
        QColormap::cleanup();
        if (qt_mac_safe_pdev) {
            delete qt_mac_safe_pdev;
            qt_mac_safe_pdev = 0;
        }
        extern void qt_mac_unregister_widget(); // qapplication_mac.cpp
        qt_mac_unregister_widget();
    }
}

qt_init

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

friend

Definition at line 1666 of file qapplication_x11.cpp.

{
    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->use_xkb = false;
    X11->xkb_major = 0;
    X11->xkb_eventbase = 0;
    X11->xkb_errorbase = 0;

    // MIT-SHM
    X11->use_mitshm = false;
    X11->use_mitshm_pixmaps = false;
    X11->mitshm_major = 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->argbVisuals = 0;
    X11->argbColormaps = 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;

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

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

        if (QApplication::testAttribute(Qt::AA_X11InitThreads))
            XInitThreads();

        // 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];
        } 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;
        }
        else if (arg == "-sync")
            appSync = !appSync;
#if defined(QT_DEBUG)
        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 && runningUnderDebugger()) {
        appNoGrab = true;
        qDebug("Qt: gdb: -nograb added to command-line options.\n"
               "\t Use the -dograb option to enforce grabbing.");
    }
#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);

        int formatCount = 0;
        XPixmapFormatValues *values = XListPixmapFormats(X11->display, &formatCount);
        for (int i = 0; i < formatCount; ++i)
            X11->bppForDepth[values[i].depth] = values[i].bits_per_pixel;
        XFree(values);

        X11->screens = new QX11InfoData[X11->screenCount];
        X11->argbVisuals = new Visual *[X11->screenCount];
        X11->argbColormaps = new Colormap[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;

            int widthMM = DisplayWidthMM(X11->display, s);
            if (widthMM != 0) {
                screen->dpiX = (DisplayWidth(X11->display, s) * 254 + widthMM * 5) / (widthMM * 10);
            } else {
                screen->dpiX = 72;
            }

            int heightMM = DisplayHeightMM(X11->display, s);
            if (heightMM != 0) {
                screen->dpiY = (DisplayHeight(X11->display, s) * 254 + heightMM * 5) / (heightMM * 10);
            } else {
                screen->dpiY = 72;
            }

            X11->argbVisuals[s] = 0;
            X11->argbColormaps[s] = 0;
        }


#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)) {
            // 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()) {
                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_MITSHM
        int mitshm_minor;
        int mitshm_major;
        int mitshm_eventbase;
        int mitshm_errorbase;
        int mitshm_pixmaps;
        if (XQueryExtension(X11->display, "MIT-SHM", &X11->mitshm_major,
                            &mitshm_eventbase, &mitshm_errorbase)
            && XShmQueryVersion(X11->display, &mitshm_major, &mitshm_minor,
                                &mitshm_pixmaps))
        {
            QString displayName = QLatin1String(XDisplayName(NULL));

            // MITSHM only works for local displays, so do a quick check here
            // to determine whether the display is local or not (not 100 % accurate).
            // BGR server layouts are not supported either, since it requires the raster
            // engine to work on a QImage with BGR layout.
            bool local = displayName.isEmpty() || displayName.lastIndexOf(QLatin1Char(':')) == 0;
            if (local && (qgetenv("QT_X11_NO_MITSHM").toInt() == 0)) {
                Visual *defaultVisual = DefaultVisual(X11->display, DefaultScreen(X11->display));
                X11->use_mitshm = ((defaultVisual->red_mask == 0xff0000
                                    || defaultVisual->red_mask == 0xf800)
                                   && (defaultVisual->green_mask == 0xff00
                                       || defaultVisual->green_mask == 0x7e0)
                                   && (defaultVisual->blue_mask == 0xff
                                       || defaultVisual->blue_mask == 0x1f));
                X11->use_mitshm_pixmaps = X11->use_mitshm && mitshm_pixmaps;
            }
        }
#endif // QT_NO_MITSHM

        // initialize the graphics system - order is imporant here - it must be done before
        // the QColormap::initialize() call
        QApplicationPrivate::graphics_system = QGraphicsSystemFactory::create(QApplicationPrivate::graphics_system_name);
        QColormap::initialize();

        // Support protocols
        X11->xdndSetup();

        // Finally create all atoms
        qt_x11_create_intern_atoms();

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

#  ifdef QT_RUNTIME_XRANDR
            X11->ptrXRRSelectInput = 0;
            X11->ptrXRRUpdateConfiguration = 0;
            X11->ptrXRRRootToScreen = 0;
            X11->ptrXRRQueryExtension = 0;
            QLibrary xrandrLib(QLatin1String("Xrandr"), 2);
            xrandrLib.setLoadHints(QLibrary::ImprovedSearchHeuristics);
            if (!xrandrLib.load()) { // try without the version number
                xrandrLib.setFileName(QLatin1String("Xrandr"));
                xrandrLib.load();
            }
            if (xrandrLib.isLoaded()) {
                X11->ptrXRRSelectInput =
                    (PtrXRRSelectInput) xrandrLib.resolve("XRRSelectInput");
                X11->ptrXRRUpdateConfiguration =
                    (PtrXRRUpdateConfiguration) xrandrLib.resolve("XRRUpdateConfiguration");
                X11->ptrXRRRootToScreen =
                    (PtrXRRRootToScreen) xrandrLib.resolve("XRRRootToScreen");
                X11->ptrXRRQueryExtension =
                    (PtrXRRQueryExtension) xrandrLib.resolve("XRRQueryExtension");
            }
#  else
            X11->ptrXRRSelectInput = XRRSelectInput;
            X11->ptrXRRUpdateConfiguration = XRRUpdateConfiguration;
            X11->ptrXRRRootToScreen = XRRRootToScreen;
            X11->ptrXRRQueryExtension = XRRQueryExtension;
#  endif

            if (X11->ptrXRRQueryExtension
                && X11->ptrXRRQueryExtension(X11->display, &X11->xrandr_eventbase, &X11->xrandr_errorbase)) {
                // XRandR is supported
                X11->use_xrandr = true;
            }
        }
#endif // QT_NO_XRANDR

#ifndef QT_NO_XRENDER
        if (X11->use_xrender) {
            // 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));

            if (!format) {
                X11->use_xrender = false;
            }
        }
#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)) {
            X11->ptrXFixesQueryExtension  = XFIXES_LOAD_V1(XFixesQueryExtension);
            X11->ptrXFixesQueryVersion    = XFIXES_LOAD_V1(XFixesQueryVersion);
            X11->ptrXFixesSetCursorName   = XFIXES_LOAD_V2(XFixesSetCursorName);
            X11->ptrXFixesSelectSelectionInput = XFIXES_LOAD_V2(XFixesSelectSelectionInput);

            if(X11->ptrXFixesQueryExtension && X11->ptrXFixesQueryVersion
               && X11->ptrXFixesQueryExtension(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;
                X11->ptrXFixesQueryVersion(X11->display, &major, &minor);
                X11->use_xfixes = (major >= 1);
                X11->xfixes_major = major;
            }
        } else {
            X11->ptrXFixesQueryExtension  = 0;
            X11->ptrXFixesQueryVersion    = 0;
            X11->ptrXFixesSetCursorName   = 0;
            X11->ptrXFixesSelectSelectionInput = 0;
        }
#endif // QT_NO_XFIXES

#ifndef QT_NO_XCURSOR
#ifdef QT_RUNTIME_XCURSOR
        X11->ptrXcursorLibraryLoadCursor = 0;
        QLibrary xcursorLib(QLatin1String("Xcursor"), 1);
        xcursorLib.setLoadHints(QLibrary::ImprovedSearchHeuristics);
        bool xcursorFound = xcursorLib.load();
        if (!xcursorFound) { //try without the version number
            xcursorLib.setFileName(QLatin1String("Xcursor"));
            xcursorFound = xcursorLib.load();
        }
        if (xcursorFound) {
            X11->ptrXcursorLibraryLoadCursor =
                (PtrXcursorLibraryLoadCursor) xcursorLib.resolve("XcursorLibraryLoadCursor");
        }
#else
        X11->ptrXcursorLibraryLoadCursor = XcursorLibraryLoadCursor;
#endif // QT_RUNTIME_XCURSOR
#endif // QT_NO_XCURSOR

#ifndef QT_NO_XSYNC
        int xsync_evbase, xsync_errbase;
        int major, minor;
        if (XSyncQueryExtension(X11->display, &xsync_evbase, &xsync_errbase))
            XSyncInitialize(X11->display, &major, &minor);
#endif // QT_NO_XSYNC

#ifndef QT_NO_XINERAMA
#ifdef QT_RUNTIME_XINERAMA
        X11->ptrXineramaQueryExtension = 0;
        X11->ptrXineramaIsActive = 0;
        X11->ptrXineramaQueryScreens = 0;
        QLibrary xineramaLib(QLatin1String("Xinerama"), 1);
        xineramaLib.setLoadHints(QLibrary::ImprovedSearchHeuristics);
        bool xineramaFound = xineramaLib.load();
        if (!xineramaFound) { //try without the version number
            xineramaLib.setFileName(QLatin1String("Xinerama"));
            xineramaFound = xineramaLib.load();
        }
        if (xineramaFound) {
            X11->ptrXineramaQueryExtension =
                (PtrXineramaQueryExtension) xineramaLib.resolve("XineramaQueryExtension");
            X11->ptrXineramaIsActive =
                (PtrXineramaIsActive) xineramaLib.resolve("XineramaIsActive");
            X11->ptrXineramaQueryScreens =
                (PtrXineramaQueryScreens) xineramaLib.resolve("XineramaQueryScreens");
        }
#else
        X11->ptrXineramaQueryScreens = XineramaQueryScreens;
        X11->ptrXineramaIsActive = XineramaIsActive;
        X11->ptrXineramaQueryExtension = XineramaQueryExtension;
#endif // QT_RUNTIME_XINERAMA
#endif // QT_NO_XINERAMA

#ifndef QT_NO_XINPUT
        // See if Xinput is supported on the connected display
        X11->ptrXCloseDevice = 0;
        X11->ptrXListInputDevices = 0;
        X11->ptrXOpenDevice = 0;
        X11->ptrXFreeDeviceList = 0;
        X11->ptrXSelectExtensionEvent = 0;
        X11->use_xinput = XQueryExtension(X11->display, "XInputExtension", &X11->xinput_major,
                                          &X11->xinput_eventbase, &X11->xinput_errorbase);
        if (X11->use_xinput) {
            X11->ptrXCloseDevice = XINPUT_LOAD(XCloseDevice);
            X11->ptrXListInputDevices = XINPUT_LOAD(XListInputDevices);
            X11->ptrXOpenDevice = XINPUT_LOAD(XOpenDevice);
            X11->ptrXFreeDeviceList = XINPUT_LOAD(XFreeDeviceList);
            X11->ptrXSelectExtensionEvent = XINPUT_LOAD(XSelectExtensionEvent);
        }
#endif // QT_NO_XINPUT

#ifndef QT_NO_XKB
        int xkblibMajor = XkbMajorVersion;
        int xkblibMinor = XkbMinorVersion;
        X11->use_xkb = XkbQueryExtension(X11->display,
                                         &X11->xkb_major,
                                         &X11->xkb_eventbase,
                                         &X11->xkb_errorbase,
                                         &xkblibMajor,
                                         &xkblibMinor);
        if (X11->use_xkb) {
            // If XKB is detected, set the GrabsUseXKBState option so input method
            // compositions continue to work (ie. deadkeys)
            unsigned int state = XkbPCF_GrabsUseXKBStateMask;
            (void) XkbSetPerClientControls(X11->display, state, &state);

            // select for group change events
            XkbSelectEventDetails(X11->display,
                                  XkbUseCoreKbd,
                                  XkbStateNotify,
                                  XkbAllStateComponentsMask,
                                  XkbGroupStateMask);

            // current group state is queried when creating the keymapper, no need to do it here
        }
#endif


#if !defined(QT_NO_FONTCONFIG)
        int dpi = 0;
        getXDefault("Xft", FC_DPI, &dpi);
        if (dpi) {
            for (int s = 0; s < ScreenCount(X11->display); ++s) {
                QX11Info::setAppDpiX(s, dpi);
                QX11Info::setAppDpiY(s, dpi);
            }
        }
        double fc_scale = 1.;
        getXDefault("Xft", FC_SCALE, &fc_scale);
        X11->fc_scale = fc_scale;
        for (int s = 0; s < ScreenCount(X11->display); ++s) {
            int subpixel = FC_RGBA_UNKNOWN;
#if !defined(QT_NO_XRENDER) && (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

            char *rgba = XGetDefault(X11->display, "Xft", FC_RGBA);
            if (rgba) {
                char *end = 0;
                int v = strtol(rgba, &end, 0);
                if (rgba != end) {
                    subpixel = v;
                } else if (qstrncmp(rgba, "unknown", 7) == 0) {
                    subpixel = FC_RGBA_UNKNOWN;
                } else if (qstrncmp(rgba, "rgb", 3) == 0) {
                    subpixel = FC_RGBA_RGB;
                } else if (qstrncmp(rgba, "bgr", 3) == 0) {
                    subpixel = FC_RGBA_BGR;
                } else if (qstrncmp(rgba, "vrgb", 4) == 0) {
                    subpixel = FC_RGBA_VRGB;
                } else if (qstrncmp(rgba, "vbgr", 4) == 0) {
                    subpixel = FC_RGBA_VBGR;
                } else if (qstrncmp(rgba, "none", 4) == 0) {
                    subpixel = FC_RGBA_NONE;
                }
            }
            X11->screens[s].subpixel = subpixel;
        }
        getXDefault("Xft", FC_ANTIALIAS, &X11->fc_antialias);
#ifdef FC_HINT_STYLE
        X11->fc_hint_style = -1;
        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();

        // Misc. initialization
#if 0 //disabled for now..
        QSegfaultHandler::initialize(priv->argv, priv->argc);
#endif
        QCursorData::initialize();
    }
    QFont::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)
                X11->ptrXRRSelectInput(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

#ifndef QT_NO_XFIXES
        if (X11->ptrXFixesSelectSelectionInput)
            X11->ptrXFixesSelectSelectionInput(X11->display, QX11Info::appRootWindow(), ATOM(_NET_WM_CM_S0),
                                       XFixesSetSelectionOwnerNotifyMask
                                       | XFixesSelectionWindowDestroyNotifyMask
                                       | XFixesSelectionClientCloseNotifyMask);
#endif // QT_NO_XFIXES
        X11->compositingManagerRunning = XGetSelectionOwner(X11->display,
                                                            ATOM(_NET_WM_CM_S0));
        X11->desktopEnvironment = DE_UNKNOWN;
        X11->desktopVersion = 0;

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

        do {
            if (!qgetenv("KDE_FULL_SESSION").isEmpty()) {
                X11->desktopEnvironment = DE_KDE;
                X11->desktopVersion = qgetenv("KDE_SESSION_VERSION").toInt();
                break;
            }

            if (qgetenv("DESKTOP_SESSION") == "gnome") {
                X11->desktopEnvironment = DE_GNOME;
                break;
            }

            // GNOME_DESKTOP_SESSION_ID is deprecated for some reason, but still check it
            if (!qgetenv("GNOME_DESKTOP_SESSION_ID").isEmpty()) {
                X11->desktopEnvironment = DE_GNOME;
                break;
            }

            rc = XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(_DT_SAVE_MODE),
                                    0, 2, False, XA_STRING, &type, &format, &length,
                                    &after, &data);
            if (rc == Success && length) {
                if (!strcmp(reinterpret_cast<char *>(data), "xfce4")) {
                    // Pretend that xfce4 is gnome, as it uses the same libraries.
                    // The detection above is stolen from xdg-open.
                    X11->desktopEnvironment = DE_GNOME;
                    break;
                }

                // We got the property but it wasn't xfce4. Free data before it gets overwritten.
                XFree(data);
                data = 0;
            }

            rc = XGetWindowProperty(X11->display, QX11Info::appRootWindow(), ATOM(DTWM_IS_RUNNING),
                                    0, 1, False, AnyPropertyType, &type, &format, &length,
                                    &after, &data);
            if (rc == Success && length) {
                // DTWM is running, meaning most likely CDE is running...
                X11->desktopEnvironment = DE_CDE;
                break;
            }

            rc = XGetWindowProperty(X11->display, QX11Info::appRootWindow(),
                                    ATOM(_SGI_DESKS_MANAGER), 0, 1, False, XA_WINDOW,
                                    &type, &format, &length, &after, &data);
            if (rc == Success && length) {
                X11->desktopEnvironment = DE_4DWM;
                break;
            }

            if (XGetWindowProperty(X11->display, QX11Info::appRootWindow(),
                               ATOM(_NET_SUPPORTING_WM_CHECK),
                               0, 1024, False, XA_WINDOW, &type,
                               &format, &length, &after, &data) == Success) {
                if (type == XA_WINDOW && format == 32) {
                    Window windowManagerWindow = *((Window*) data);
                    XFree(data);
                    data = 0;

                    if (windowManagerWindow != XNone) {
                        Atom utf8atom = ATOM(UTF8_STRING);
                        if (XGetWindowProperty(QX11Info::display(), windowManagerWindow, ATOM(_NET_WM_NAME),
                                               0, 1024, False, utf8atom, &type,
                                               &format, &length, &after, &data) == Success) {
                            if (type == utf8atom && format == 8) {
                                if (qstrcmp((const char *)data, "MCompositor") == 0)
                                    X11->desktopEnvironment = DE_MEEGO_COMPOSITOR;
                            }
                        }
                    }
                }
            }

        } while(0);

        if (data)
            XFree((char *)data);

#if !defined(QT_NO_STYLE_GTK)
        if (X11->desktopEnvironment == DE_GNOME) {
            static bool menusHaveIcons = QGtkStyle::getGConfBool(QLatin1String("/desktop/gnome/interface/menus_have_icons"), true);
            QApplication::setAttribute(Qt::AA_DontShowIconsInMenus, !menusHaveIcons);
        }
#endif
        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 (!QApplicationPrivate::sys_font) {
            // no font from settings or RESOURCE_MANAGER, provide a fallback
            QFont f(X11->has_fontconfig ? QLatin1String("Sans Serif") : QLatin1String("Helvetica"),
                    ptsz);
            QApplicationPrivate::setSystemFont(f);
        }

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

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

#if defined(Q_OS_IRIX)
                QString devName = QString::fromLocal8Bit(devs->name).toLower();
                if (devName == QLatin1String(WACOM_NAME)) {
                    deviceType = QTabletEvent::Stylus;
                    gotStylus = true;
                }
#else
                // qDebug() << "found input device" << devs->name << "type" << devs->type << XGetAtomName(X11->display, devs->type);
                if (devs->type == ATOM(XWacomStylus) || devs->type == ATOM(XTabletStylus) || devs->type == ATOM(XTablet)) {
                    deviceType = QTabletEvent::Stylus;
                    if (wacomDeviceName()->isEmpty())
                        wacomDeviceName()->append(devs->name);
                    gotStylus = true;
                } else if (devs->type == ATOM(XWacomEraser) || devs->type == ATOM(XTabletEraser)) {
                    deviceType = QTabletEvent::XFreeEraser;
                    gotEraser = true;
                }
#endif
                if (deviceType == QTabletEvent::NoDevice)
                    continue;

                if (gotStylus || gotEraser) {
                    if (X11->ptrXOpenDevice)
                        dev = X11->ptrXOpenDevice(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;
                    device_data.widgetToGetPress = 0;

                    if (dev->num_classes > 0) {
                        for (ip = dev->classes, j = 0; j < dev->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)
            }
            if (X11->ptrXFreeDeviceList)
                X11->ptrXFreeDeviceList(devices);
        }
#endif // QT_NO_TABLET

        X11->startupId = getenv("DESKTOP_STARTUP_ID");
        if (X11->startupId) {
#ifndef QT_NO_UNSETENV
            unsetenv("DESKTOP_STARTUP_ID");
#else
            // it's a small memory leak, however we won't crash if Qt is
            // unloaded and someones tries to use the envoriment.
            putenv(strdup("DESKTOP_STARTUP_ID="));
#endif
        }
   } 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::fromLatin1("%1.%2/libraryPath")
                                 .arg(QT_VERSION >> 16)
                                 .arg((QT_VERSION & 0xff00) >> 8);
            QStringList pathlist =
                settings.value(libpathkey).toString().split(QLatin1Char(':'));
            if (! pathlist.isEmpty()) {
                QStringList::ConstIterator it = pathlist.constBegin();
                while (it != pathlist.constEnd())
                    QApplication::addLibraryPath(*it++);
            }

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

#if !defined (Q_OS_IRIX) && !defined (QT_NO_TABLET)
    QLibrary wacom(QString::fromLatin1("wacomcfg"), 0); // version 0 is the latest release at time of writing this.
    wacom.setLoadHints(QLibrary::ImprovedSearchHeuristics);
    // NOTE: C casts instead of reinterpret_cast for GCC 3.3.x
    ptrWacomConfigInit = (PtrWacomConfigInit)wacom.resolve("WacomConfigInit");
    ptrWacomConfigOpenDevice = (PtrWacomConfigOpenDevice)wacom.resolve("WacomConfigOpenDevice");
    ptrWacomConfigGetRawParam  = (PtrWacomConfigGetRawParam)wacom.resolve("WacomConfigGetRawParam");
    ptrWacomConfigCloseDevice = (PtrWacomConfigCloseDevice)wacom.resolve("WacomConfigCloseDevice");
    ptrWacomConfigTerm = (PtrWacomConfigTerm)wacom.resolve("WacomConfigTerm");

    if (ptrWacomConfigInit == 0 || ptrWacomConfigOpenDevice == 0 || ptrWacomConfigGetRawParam == 0
        || ptrWacomConfigCloseDevice == 0 || ptrWacomConfigTerm == 0) { // either we have all, or we have none.
            ptrWacomConfigInit = 0;
            ptrWacomConfigOpenDevice = 0;
            ptrWacomConfigGetRawParam  = 0;
            ptrWacomConfigCloseDevice = 0;
            ptrWacomConfigTerm = 0;
    }
#endif
}

qt_x11_getX11InfoForWindow

void qt_x11_getX11InfoForWindow ( QX11Info *  xinfo, const QX11WindowAttributes &  a  )

friend

Definition at line 3114 of file qwidget_x11.cpp.

{
    QX11InfoData* xd = xinfo->getX11Data(true);
    const XWindowAttributes &a = *(att.att);
    // find which screen the window is on...
    xd->screen = QX11Info::appScreen(); // by default, use the default :)
    int i;
    for (i = 0; i < ScreenCount(X11->display); i++) {
        if (RootWindow(X11->display, i) == a.root) {
            xd->screen = i;
            break;
        }
    }

    xd->depth = a.depth;
    xd->cells = DisplayCells(X11->display, xd->screen);
    xd->visual = a.visual;
    xd->defaultVisual = (XVisualIDFromVisual((Visual *) a.visual) ==
                         XVisualIDFromVisual((Visual *) QX11Info::appVisual(xinfo->screen())));
    xd->colormap = a.colormap;
    xd->defaultColormap = (a.colormap == QX11Info::appColormap(xinfo->screen()));
    xinfo->setX11Data(xd);
}

QWidget

friend class QWidget

friend

Definition at line 110 of file qx11info_x11.h.

QWidgetPrivate

friend class QWidgetPrivate

friend

Definition at line 111 of file qx11info_x11.h.

QX11PaintEngine

friend class QX11PaintEngine

friend

Definition at line 107 of file qx11info_x11.h.

QX11PixmapData

friend class QX11PixmapData

friend

Definition at line 109 of file qx11info_x11.h.

Properties

x11data

QX11InfoData* QX11Info::x11data

protected

Definition at line 105 of file qx11info_x11.h.

Referenced by cells(), colormap(), defaultColormap(), defaultVisual(), depth(), QX11PixmapData::fromImage(), getX11Data(), operator=(), QX11Info(), screen(), setX11Data(), visual(), and ~QX11Info().

---

The documentation for this class was generated from the following files:

• /src/gui/kernel/qx11info_x11.h
• /src/gui/kernel/qapplication_x11.cpp
• /src/gui/kernel/qx11info_x11.cpp