QTestLiteStaticInfoPrivate Class Reference

Public Functions
Atom	atom (QXlibStatic::X11Atom atom)
bool	isSupportedByWM (Atom atom)
QImage	qimageFromXImage (XImage *xi)
	QTestLiteStaticInfoPrivate ()
bool	useXFixes () const
int	xFixesEventBase () const
PtrXFixesSelectSelectionInput	xFixesSelectSelectionInput () const

Private Functions
void	initializeAllAtoms (QXlibScreen *screen)
void	initializeSupportedAtoms (QXlibScreen *screen)
void	resolveXFixes (QXlibScreen *screen)

Properties
Atom	m_allAtoms [QXlibStatic::NAtoms]
Atom *	m_supportedAtoms
PtrXFixesQueryExtension	ptrXFixesQueryExtension
PtrXFixesQueryVersion	ptrXFixesQueryVersion
PtrXFixesSelectSelectionInput	ptrXFixesSelectSelectionInput
PtrXFixesSetCursorName	ptrXFixesSetCursorName
bool	use_xfixes
int	xfixes_errorbase
int	xfixes_eventbase
int	xfixes_major

Detailed Description

Definition at line 255 of file qxlibstatic.cpp.

Constructors and Destructors

QTestLiteStaticInfoPrivate()

QTestLiteStaticInfoPrivate::QTestLiteStaticInfoPrivate ( )

inline

Definition at line 258 of file qxlibstatic.cpp.

        : use_xfixes(false)
        , xfixes_major(0)
        , xfixes_eventbase(0)
        , xfixes_errorbase(0)
    {
        QXlibScreen *screen = qobject_cast<QXlibScreen *> (QApplicationPrivate::platformIntegration()->screens().at(0));
        Q_ASSERT(screen);

        initializeAllAtoms(screen);
        initializeSupportedAtoms(screen);

        resolveXFixes(screen);
    }

Functions

atom()

Atom QTestLiteStaticInfoPrivate::atom ( QXlibStatic::X11Atom  atom )

inline

Definition at line 290 of file qxlibstatic.cpp.

Referenced by initializeSupportedAtoms().

    {
        return m_allAtoms[atom];
    }

initializeAllAtoms()

void QTestLiteStaticInfoPrivate::initializeAllAtoms ( QXlibScreen *  screen )

inlineprivate

Definition at line 354 of file qxlibstatic.cpp.

Referenced by QTestLiteStaticInfoPrivate().

                                                 {
        const char *names[QXlibStatic::NAtoms];
        const char *ptr = x11_atomnames;

        int i = 0;
        while (*ptr) {
            names[i++] = ptr;
            while (*ptr)
                ++ptr;
            ++ptr;
        }

        Q_ASSERT(i == QXlibStatic::NPredefinedAtoms);

        QByteArray settings_atom_name("_QT_SETTINGS_TIMESTAMP_");
        settings_atom_name += XDisplayName(qPrintable(screen->display()->displayName()));
        names[i++] = settings_atom_name;

        Q_ASSERT(i == QXlibStatic::NAtoms);
    #if 0//defined(XlibSpecificationRelease) && (XlibSpecificationRelease >= 6)
        XInternAtoms(screen->display(), (char **)names, i, False, m_allAtoms);
    #else
        for (i = 0; i < QXlibStatic::NAtoms; ++i)
            m_allAtoms[i] = XInternAtom(screen->display()->nativeDisplay(), (char *)names[i], False);
    #endif
    }

initializeSupportedAtoms()

void QTestLiteStaticInfoPrivate::initializeSupportedAtoms ( QXlibScreen *  screen )

inlineprivate

Definition at line 381 of file qxlibstatic.cpp.

Referenced by QTestLiteStaticInfoPrivate().

    {
        Atom type;
        int format;
        long offset = 0;
        unsigned long nitems, after;
        unsigned char *data = 0;

        int e = XGetWindowProperty(screen->display()->nativeDisplay(), screen->rootWindow(),
                                   this->atom(QXlibStatic::_NET_SUPPORTED), 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(screen->display()->nativeDisplay(), screen->rootWindow(),
                                   this->atom(QXlibStatic::_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);
            m_supportedAtoms = new Atom[nitems + 1];
            Atom *a = (Atom *) buffer.data();
            uint i;
            for (i = 0; i < nitems; i++)
                m_supportedAtoms[i] = a[i];
            m_supportedAtoms[nitems] = 0;

        }
    }

isSupportedByWM()

bool QTestLiteStaticInfoPrivate::isSupportedByWM ( Atom  atom )

inline

Definition at line 273 of file qxlibstatic.cpp.

    {
        if (!m_supportedAtoms)
            return false;

        bool supported = false;
        int i = 0;
        while (m_supportedAtoms[i] != 0) {
            if (m_supportedAtoms[i++] == atom) {
                supported = true;
                break;
            }
        }

        return supported;
    }

qimageFromXImage()

QImage QTestLiteStaticInfoPrivate::qimageFromXImage ( XImage *  xi )

inline

Definition at line 304 of file qxlibstatic.cpp.

    {
        QImage::Format format = QImage::Format_ARGB32_Premultiplied;
        if (xi->depth == 24)
            format = QImage::Format_RGB32;
        else if (xi->depth == 16)
            format = QImage::Format_RGB16;

        QImage image = QImage((uchar *)xi->data, xi->width, xi->height, xi->bytes_per_line, format).copy();

        // we may have to swap the byte order
        if ((QSysInfo::ByteOrder == QSysInfo::LittleEndian && xi->byte_order == MSBFirst)
            || (QSysInfo::ByteOrder == QSysInfo::BigEndian && xi->byte_order == LSBFirst))
        {
            for (int i=0; i < image.height(); i++) {
                if (xi->depth == 16) {
                    ushort *p = (ushort*)image.scanLine(i);
                    ushort *end = p + image.width();
                    while (p < end) {
                        *p = ((*p << 8) & 0xff00) | ((*p >> 8) & 0x00ff);
                        p++;
                    }
                } else {
                    uint *p = (uint*)image.scanLine(i);
                    uint *end = p + image.width();
                    while (p < end) {
                        *p = ((*p << 24) & 0xff000000) | ((*p << 8) & 0x00ff0000)
                             | ((*p >> 8) & 0x0000ff00) | ((*p >> 24) & 0x000000ff);
                        p++;
                    }
                }
            }
        }

        // fix-up alpha channel
        if (format == QImage::Format_RGB32) {
            QRgb *p = (QRgb *)image.bits();
            for (int y = 0; y < xi->height; ++y) {
                for (int x = 0; x < xi->width; ++x)
                    p[x] |= 0xff000000;
                p += xi->bytes_per_line / 4;
            }
        }

        return image;
    }

resolveXFixes()

void QTestLiteStaticInfoPrivate::resolveXFixes ( QXlibScreen *  screen )

inlineprivate

Definition at line 426 of file qxlibstatic.cpp.

Referenced by QTestLiteStaticInfoPrivate().

    {
#ifndef QT_NO_XFIXES
        // See if Xfixes is supported on the connected display
        if (XQueryExtension(screen->display()->nativeDisplay(), "XFIXES", &xfixes_major,
                            &xfixes_eventbase, &xfixes_errorbase)) {
            ptrXFixesQueryExtension  = XFIXES_LOAD_V1(XFixesQueryExtension);
            ptrXFixesQueryVersion    = XFIXES_LOAD_V1(XFixesQueryVersion);
            ptrXFixesSetCursorName   = XFIXES_LOAD_V2(XFixesSetCursorName);
            ptrXFixesSelectSelectionInput = XFIXES_LOAD_V2(XFixesSelectSelectionInput);

            if(ptrXFixesQueryExtension && ptrXFixesQueryVersion
               && ptrXFixesQueryExtension(screen->display()->nativeDisplay(), &xfixes_eventbase,
                                               &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;
                ptrXFixesQueryVersion(screen->display()->nativeDisplay(), &major, &minor);
                use_xfixes = (major >= 1);
                xfixes_major = major;
            }
        }
#endif // QT_NO_XFIXES

    }

useXFixes()

bool QTestLiteStaticInfoPrivate::useXFixes ( ) const

inline

Definition at line 295 of file qxlibstatic.cpp.

Referenced by QXlibStatic::xFixesSelectSelectionInput().

{ return use_xfixes; }

xFixesEventBase()

int QTestLiteStaticInfoPrivate::xFixesEventBase ( ) const

inline

Definition at line 297 of file qxlibstatic.cpp.

{return xfixes_eventbase; }

xFixesSelectSelectionInput()

PtrXFixesSelectSelectionInput QTestLiteStaticInfoPrivate::xFixesSelectSelectionInput ( ) const

inline

Definition at line 299 of file qxlibstatic.cpp.

    {
        return ptrXFixesSelectSelectionInput;
    }

Properties

m_allAtoms

Atom QTestLiteStaticInfoPrivate::m_allAtoms[QXlibStatic::NAtoms]

private

Definition at line 459 of file qxlibstatic.cpp.

Referenced by atom(), and initializeAllAtoms().

m_supportedAtoms

Atom* QTestLiteStaticInfoPrivate::m_supportedAtoms

private

Definition at line 458 of file qxlibstatic.cpp.

Referenced by initializeSupportedAtoms(), and isSupportedByWM().

ptrXFixesQueryExtension

PtrXFixesQueryExtension QTestLiteStaticInfoPrivate::ptrXFixesQueryExtension

private

Definition at line 462 of file qxlibstatic.cpp.

Referenced by resolveXFixes().

ptrXFixesQueryVersion

PtrXFixesQueryVersion QTestLiteStaticInfoPrivate::ptrXFixesQueryVersion

private

Definition at line 463 of file qxlibstatic.cpp.

Referenced by resolveXFixes().

ptrXFixesSelectSelectionInput

PtrXFixesSelectSelectionInput QTestLiteStaticInfoPrivate::ptrXFixesSelectSelectionInput

private

Definition at line 465 of file qxlibstatic.cpp.

Referenced by resolveXFixes(), and xFixesSelectSelectionInput().

ptrXFixesSetCursorName

PtrXFixesSetCursorName QTestLiteStaticInfoPrivate::ptrXFixesSetCursorName

private

Definition at line 464 of file qxlibstatic.cpp.

Referenced by resolveXFixes().

use_xfixes

bool QTestLiteStaticInfoPrivate::use_xfixes

private

Definition at line 468 of file qxlibstatic.cpp.

Referenced by resolveXFixes(), and useXFixes().

xfixes_errorbase

int QTestLiteStaticInfoPrivate::xfixes_errorbase

private

Definition at line 471 of file qxlibstatic.cpp.

Referenced by resolveXFixes().

xfixes_eventbase

int QTestLiteStaticInfoPrivate::xfixes_eventbase

private

Definition at line 470 of file qxlibstatic.cpp.

Referenced by resolveXFixes(), and xFixesEventBase().

xfixes_major

int QTestLiteStaticInfoPrivate::xfixes_major

private

Definition at line 469 of file qxlibstatic.cpp.

Referenced by resolveXFixes().

---

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

• /src/plugins/platforms/xlib/qxlibstatic.cpp