QXcbWindow Class Reference

#include <qxcbwindow.h>

Inheritance diagram for QXcbWindow:

Public Functions
uint	depth () const
QImage::Format	format () const
QPlatformGLContext *	glContext () const
	Reimplement to return the glContext associated with the window. More...
void	handleButtonPressEvent (const xcb_button_press_event_t *event)
void	handleButtonReleaseEvent (const xcb_button_release_event_t *event)
void	handleClientMessageEvent (const xcb_client_message_event_t *event)
void	handleConfigureNotifyEvent (const xcb_configure_notify_event_t *event)
void	handleEnterNotifyEvent (const xcb_enter_notify_event_t *event)
void	handleExposeEvent (const xcb_expose_event_t *event)
void	handleFocusInEvent (const xcb_focus_in_event_t *event)
void	handleFocusOutEvent (const xcb_focus_out_event_t *event)
void	handleLeaveNotifyEvent (const xcb_leave_notify_event_t *event)
void	handleMotionNotifyEvent (const xcb_motion_notify_event_t *event)
void	handleMouseEvent (xcb_button_t detail, uint16_t state, xcb_timestamp_t time, const QPoint &local, const QPoint &global)
void	lower ()
	Reimplement to be able to let Qt lower windows to the bottom of the desktop. More...
	QXcbWindow (QWidget *tlw)
void	raise ()
	Reimplement to be able to let Qt rais windows to the top of the desktop. More...
void	requestActivateWindow ()
	Reimplement to let Qt be able to request activation/focus for a window. More...
void	setGeometry (const QRect &rect)
	This function is called by Qt whenever a window is moved or the window is resized. More...
void	setParent (const QPlatformWindow *window)
	This function is called to enable native child widgets in QPA. More...
void	setVisible (bool visible)
	Reimplemented in subclasses to show the surface if visible is true, and hide it if visible is false. More...
Qt::WindowFlags	setWindowFlags (Qt::WindowFlags flags)
	Requests setting the window flags of this surface to type. More...
void	setWindowTitle (const QString &title)
	Reimplement to set the window title to title. More...
void	updateSyncRequestCounter ()
xcb_window_t	window () const
WId	winId () const
	Reimplement in subclasses to return a handle to the native window. More...
	~QXcbWindow ()
Public Functions inherited from QXcbObject
xcb_atom_t	atom (QXcbAtom::Atom atom) const
QXcbConnection *	connection () const
	QXcbObject (QXcbConnection *connection=0)
void	setConnection (QXcbConnection *connection)
xcb_connection_t *	xcb_connection () const
Public Functions inherited from QPlatformWindow
virtual QRect	geometry () const
	Returnes the current geometry of a window. More...
	QPlatformWindow (QWidget *tlw)
	Constructs a platform window with the given top level widget. More...
virtual void	setOpacity (qreal level)
	Reimplement to be able to let Qt set the opacity level of a window. More...
QWidget *	widget () const
	Returnes the widget which belongs to the QPlatformWindow. More...
virtual Qt::WindowFlags	windowFlags () const
	Returns the effective window flags for this surface. More...
virtual	~QPlatformWindow ()
	Virtual destructor does not delete its top level widget. More...

Private Functions
void	setNetWmWindowTypes (Qt::WindowFlags flags)

Properties
QPlatformGLContext *	m_context
uint	m_depth
QImage::Format	m_format
bool	m_hasReceivedSyncRequest
QXcbScreen *	m_screen
xcb_sync_counter_t	m_syncCounter
xcb_sync_int64_t	m_syncValue
xcb_window_t	m_window

Additional Inherited Members
Protected Variables inherited from QPlatformWindow
QScopedPointer< QPlatformWindowPrivate >	d_ptr

Detailed Description

Definition at line 56 of file qxcbwindow.h.

Constructors and Destructors

QXcbWindow()

QXcbWindow::QXcbWindow

(

QWidget *

tlw

)

Definition at line 113 of file qxcbwindow.cpp.

    : QPlatformWindow(tlw)
    , m_context(0)
{
    m_screen = static_cast<QXcbScreen *>(QPlatformScreen::platformScreenForWidget(tlw));

    setConnection(m_screen->connection());

    const quint32 mask = XCB_CW_BACK_PIXMAP | XCB_CW_EVENT_MASK;
    const quint32 values[] = {
        // XCB_CW_BACK_PIXMAP
        XCB_NONE,
        // XCB_CW_EVENT_MASK
        XCB_EVENT_MASK_EXPOSURE
        | XCB_EVENT_MASK_STRUCTURE_NOTIFY
        | XCB_EVENT_MASK_KEY_PRESS
        | XCB_EVENT_MASK_KEY_RELEASE
        | XCB_EVENT_MASK_BUTTON_PRESS
        | XCB_EVENT_MASK_BUTTON_RELEASE
        | XCB_EVENT_MASK_BUTTON_MOTION
        | XCB_EVENT_MASK_ENTER_WINDOW
        | XCB_EVENT_MASK_LEAVE_WINDOW
        | XCB_EVENT_MASK_PROPERTY_CHANGE
        | XCB_EVENT_MASK_FOCUS_CHANGE
    };

#if defined(XCB_USE_GLX) || defined(XCB_USE_EGL)
    if (tlw->platformWindowFormat().windowApi() == QPlatformWindowFormat::OpenGL
        && QApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::OpenGL)
        || tlw->platformWindowFormat().alpha())
    {
#if defined(XCB_USE_GLX)
        XVisualInfo *visualInfo = qglx_findVisualInfo(DISPLAY_FROM_XCB(m_screen),m_screen->screenNumber(), tlw->platformWindowFormat());
#elif defined(XCB_USE_EGL)
        EGLDisplay eglDisplay = connection()->egl_display();
        EGLConfig eglConfig = q_configFromQPlatformWindowFormat(eglDisplay,tlw->platformWindowFormat(),true);
        VisualID id = QXlibEglIntegration::getCompatibleVisualId(DISPLAY_FROM_XCB(this), eglDisplay, eglConfig);

        XVisualInfo visualInfoTemplate;
        memset(&visualInfoTemplate, 0, sizeof(XVisualInfo));
        visualInfoTemplate.visualid = id;

        XVisualInfo *visualInfo;
        int matchingCount = 0;
        visualInfo = XGetVisualInfo(DISPLAY_FROM_XCB(this), VisualIDMask, &visualInfoTemplate, &matchingCount);
#endif //XCB_USE_GLX
        if (visualInfo) {
            m_depth = visualInfo->depth;
            m_format = (m_depth == 32) ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32;
            Colormap cmap = XCreateColormap(DISPLAY_FROM_XCB(this), m_screen->root(), visualInfo->visual, AllocNone);

            XSetWindowAttributes a;
            a.background_pixel = WhitePixel(DISPLAY_FROM_XCB(this), m_screen->screenNumber());
            a.border_pixel = BlackPixel(DISPLAY_FROM_XCB(this), m_screen->screenNumber());
            a.colormap = cmap;
            m_window = XCreateWindow(DISPLAY_FROM_XCB(this), m_screen->root(), tlw->x(), tlw->y(), tlw->width(), tlw->height(),
                                      0, visualInfo->depth, InputOutput, visualInfo->visual,
                                      CWBackPixel|CWBorderPixel|CWColormap, &a);

            printf("created GL window: %d\n", m_window);
        } else {
            qFatal("no window!");
        }
    } else
#endif //defined(XCB_USE_GLX) || defined(XCB_USE_EGL)
    {
        m_window = xcb_generate_id(xcb_connection());
        m_depth = m_screen->screen()->root_depth;
        m_format = (m_depth == 32) ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32;

        Q_XCB_CALL(xcb_create_window(xcb_connection(),
                                     XCB_COPY_FROM_PARENT,            // depth -- same as root
                                     m_window,                        // window id
                                     m_screen->root(),                // parent window id
                                     tlw->x(),
                                     tlw->y(),
                                     tlw->width(),
                                     tlw->height(),
                                     0,                               // border width
                                     XCB_WINDOW_CLASS_INPUT_OUTPUT,   // window class
                                     m_screen->screen()->root_visual, // visual
                                     0,                               // value mask
                                     0));                             // value list

        printf("created regular window: %d\n", m_window);
    }

    Q_XCB_CALL(xcb_change_window_attributes(xcb_connection(), m_window, mask, values));

    xcb_atom_t properties[4];
    int propertyCount = 0;
    properties[propertyCount++] = atom(QXcbAtom::WM_DELETE_WINDOW);
    properties[propertyCount++] = atom(QXcbAtom::WM_TAKE_FOCUS);
    properties[propertyCount++] = atom(QXcbAtom::_NET_WM_PING);

    if (m_screen->syncRequestSupported())
        properties[propertyCount++] = atom(QXcbAtom::_NET_WM_SYNC_REQUEST);

    if (tlw->windowFlags() & Qt::WindowContextHelpButtonHint)
        properties[propertyCount++] = atom(QXcbAtom::_NET_WM_CONTEXT_HELP);

    Q_XCB_CALL(xcb_change_property(xcb_connection(),
                                   XCB_PROP_MODE_REPLACE,
                                   m_window,
                                   atom(QXcbAtom::WM_PROTOCOLS),
                                   XCB_ATOM_ATOM,
                                   32,
                                   propertyCount,
                                   properties));
    m_syncValue.hi = 0;
    m_syncValue.lo = 0;

    if (m_screen->syncRequestSupported()) {
        m_syncCounter = xcb_generate_id(xcb_connection());
        Q_XCB_CALL(xcb_sync_create_counter(xcb_connection(), m_syncCounter, m_syncValue));

        Q_XCB_CALL(xcb_change_property(xcb_connection(),
                                       XCB_PROP_MODE_REPLACE,
                                       m_window,
                                       atom(QXcbAtom::_NET_WM_SYNC_REQUEST_COUNTER),
                                       XCB_ATOM_CARDINAL,
                                       32,
                                       1,
                                       &m_syncCounter));
    }

    if (isTransient(tlw) && tlw->parentWidget()) {
        // ICCCM 4.1.2.6
        QWidget *p = tlw->parentWidget()->window();
        xcb_window_t parentWindow = p->winId();
        Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
                                       XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, 32,
                                       1, &parentWindow));

    }

    // set the PID to let the WM kill the application if unresponsive
    long pid = getpid();
    Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
                                   atom(QXcbAtom::_NET_WM_PID), XCB_ATOM_CARDINAL, 32,
                                   1, &pid));
}

~QXcbWindow()

QXcbWindow::~QXcbWindow

(

)

Definition at line 256 of file qxcbwindow.cpp.

{
    delete m_context;
    if (m_screen->syncRequestSupported())
        Q_XCB_CALL(xcb_sync_destroy_counter(xcb_connection(), m_syncCounter));
    Q_XCB_CALL(xcb_destroy_window(xcb_connection(), m_window));
}

Functions

depth()

uint QXcbWindow::depth ( ) const

inline

Definition at line 78 of file qxcbwindow.h.

Referenced by QXcbWindowSurface::resize().

{ return m_depth; }

format()

QImage::Format QXcbWindow::format ( ) const

inline

Definition at line 79 of file qxcbwindow.h.

Referenced by QXcbWindowSurface::resize().

{ return m_format; }

glContext()

QPlatformGLContext * QXcbWindow::glContext ( ) const

virtual

Reimplement to return the glContext associated with the window.

Reimplemented from QPlatformWindow.

Definition at line 524 of file qxcbwindow.cpp.

{
    if (!QApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::OpenGL)) {
        printf("no opengl\n");
        return 0;
    }
    if (!m_context) {
#if defined(XCB_USE_GLX)
        QXcbWindow *that = const_cast<QXcbWindow *>(this);
        that->m_context = new QGLXContext(m_window, m_screen, widget()->platformWindowFormat());
#elif defined(XCB_USE_EGL)
        EGLDisplay display = connection()->egl_display();
        EGLConfig config = q_configFromQPlatformWindowFormat(display,widget()->platformWindowFormat(),true);
        QVector<EGLint> eglContextAttrs;
        eglContextAttrs.append(EGL_CONTEXT_CLIENT_VERSION);
        eglContextAttrs.append(2);
        eglContextAttrs.append(EGL_NONE);

        EGLSurface eglSurface = eglCreateWindowSurface(display,config,(EGLNativeWindowType)m_window,0);
        QXcbWindow *that = const_cast<QXcbWindow *>(this);
        that->m_context = new QEGLPlatformContext(display, config, eglContextAttrs.data(), eglSurface, EGL_OPENGL_ES_API, static_cast<QEGLPlatformContext *>(widget()->platformWindowFormat().sharedGLContext()));
#elif defined(XCB_USE_DRI2)
        QXcbWindow *that = const_cast<QXcbWindow *>(this);
        that->m_context = new QDri2Context(that);
#endif
    }
    return m_context;
}

handleButtonPressEvent()

void QXcbWindow::handleButtonPressEvent

(

const xcb_button_press_event_t *

event

)

Definition at line 637 of file qxcbwindow.cpp.

Referenced by format().

{
    QPoint local(event->event_x, event->event_y);
    QPoint global(event->root_x, event->root_y);

    Qt::KeyboardModifiers modifiers = Qt::NoModifier;

    if (event->detail >= 4 && event->detail <= 7) {
        //logic borrowed from qapplication_x11.cpp
        int delta = 120 * ((event->detail == 4 || event->detail == 6) ? 1 : -1);
        bool hor = (((event->detail == 4 || event->detail == 5)
                     && (modifiers & Qt::AltModifier))
                    || (event->detail == 6 || event->detail == 7));

        QWindowSystemInterface::handleWheelEvent(widget(), event->time,
                                                 local, global, delta, hor ? Qt::Horizontal : Qt::Vertical);
        return;
    }

    handleMouseEvent(event->detail, event->state, event->time, local, global);
}

handleButtonReleaseEvent()

void QXcbWindow::handleButtonReleaseEvent

(

const xcb_button_release_event_t *

event

)

Definition at line 659 of file qxcbwindow.cpp.

Referenced by format().

{
    QPoint local(event->event_x, event->event_y);
    QPoint global(event->root_x, event->root_y);

    handleMouseEvent(event->detail, event->state, event->time, local, global);
}

handleClientMessageEvent()

void QXcbWindow::handleClientMessageEvent

(

const xcb_client_message_event_t *

event

)

Definition at line 563 of file qxcbwindow.cpp.

Referenced by format().

{
    if (event->format == 32 && event->type == atom(QXcbAtom::WM_PROTOCOLS)) {
        if (event->data.data32[0] == atom(QXcbAtom::WM_DELETE_WINDOW)) {
            QWindowSystemInterface::handleCloseEvent(widget());
        } else if (event->data.data32[0] == atom(QXcbAtom::_NET_WM_PING)) {
            xcb_client_message_event_t reply = *event;

            reply.response_type = XCB_CLIENT_MESSAGE;
            reply.window = m_screen->root();

            xcb_send_event(xcb_connection(), 0, m_screen->root(), XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *)&reply);
            xcb_flush(xcb_connection());
        } else if (event->data.data32[0] == atom(QXcbAtom::_NET_WM_SYNC_REQUEST)) {
            if (!m_hasReceivedSyncRequest) {
                m_hasReceivedSyncRequest = true;
                printf("Window manager supports _NET_WM_SYNC_REQUEST, syncing resizes\n");
            }
            m_syncValue.lo = event->data.data32[2];
            m_syncValue.hi = event->data.data32[3];
        }
    }
}

handleConfigureNotifyEvent()

void QXcbWindow::handleConfigureNotifyEvent

(

const xcb_configure_notify_event_t *

event

)

Definition at line 587 of file qxcbwindow.cpp.

Referenced by format().

{
    int xpos = geometry().x();
    int ypos = geometry().y();

    if ((event->width == geometry().width() && event->height == geometry().height()) || event->x != 0 || event->y != 0) {
        xpos = event->x;
        ypos = event->y;
    }

    QRect rect(xpos, ypos, event->width, event->height);

    if (rect == geometry())
        return;

    QPlatformWindow::setGeometry(rect);
    QWindowSystemInterface::handleGeometryChange(widget(), rect);

#if XCB_USE_DRI2
    if (m_context)
        static_cast<QDri2Context *>(m_context)->resize(rect.size());
#endif
}

handleEnterNotifyEvent()

void QXcbWindow::handleEnterNotifyEvent

(

const xcb_enter_notify_event_t *

event

)

Definition at line 685 of file qxcbwindow.cpp.

Referenced by format().

{
    QWindowSystemInterface::handleEnterEvent(widget());
}

handleExposeEvent()

void QXcbWindow::handleExposeEvent

(

const xcb_expose_event_t *

event

)

Definition at line 553 of file qxcbwindow.cpp.

Referenced by format().

{
    QWindowSurface *surface = widget()->windowSurface();
    if (surface) {
        QRect rect(event->x, event->y, event->width, event->height);

        surface->flush(widget(), rect, QPoint());
    }
}

handleFocusInEvent()

void QXcbWindow::handleFocusInEvent

(

const xcb_focus_in_event_t *

event

)

Definition at line 695 of file qxcbwindow.cpp.

Referenced by format().

{
    QWindowSystemInterface::handleWindowActivated(widget());
}

handleFocusOutEvent()

void QXcbWindow::handleFocusOutEvent

(

const xcb_focus_out_event_t *

event

)

Definition at line 700 of file qxcbwindow.cpp.

Referenced by format().

{
    QWindowSystemInterface::handleWindowActivated(0);
}

handleLeaveNotifyEvent()

void QXcbWindow::handleLeaveNotifyEvent

(

const xcb_leave_notify_event_t *

event

)

Definition at line 690 of file qxcbwindow.cpp.

Referenced by format().

{
    QWindowSystemInterface::handleLeaveEvent(widget());
}

handleMotionNotifyEvent()

void QXcbWindow::handleMotionNotifyEvent

(

const xcb_motion_notify_event_t *

event

)

Definition at line 667 of file qxcbwindow.cpp.

Referenced by format().

{
    QPoint local(event->event_x, event->event_y);
    QPoint global(event->root_x, event->root_y);

    handleMouseEvent(event->detail, event->state, event->time, local, global);
}

handleMouseEvent()

void QXcbWindow::handleMouseEvent	(	xcb_button_t	detail,
		uint16_t	state,
		xcb_timestamp_t	time,
		const QPoint &	local,
		const QPoint &	global
	)

Definition at line 675 of file qxcbwindow.cpp.

Referenced by format(), handleButtonPressEvent(), handleButtonReleaseEvent(), and handleMotionNotifyEvent().

{
    Qt::MouseButtons buttons = translateMouseButtons(state);
    Qt::MouseButton button = translateMouseButton(detail);

    buttons ^= button; // X event uses state *before*, Qt uses state *after*

    QWindowSystemInterface::handleMouseEvent(widget(), time, local, global, buttons);
}

lower()

void QXcbWindow::lower ( )

virtual

Reimplement to be able to let Qt lower windows to the bottom of the desktop.

Reimplemented from QPlatformWindow.

Definition at line 511 of file qxcbwindow.cpp.

{
    const quint32 mask = XCB_CONFIG_WINDOW_STACK_MODE;
    const quint32 values[] = { XCB_STACK_MODE_BELOW };
    Q_XCB_CALL(xcb_configure_window(xcb_connection(), m_window, mask, values));
}

raise()

void QXcbWindow::raise ( )

virtual

Reimplement to be able to let Qt rais windows to the top of the desktop.

Reimplemented from QPlatformWindow.

Definition at line 504 of file qxcbwindow.cpp.

{
    const quint32 mask = XCB_CONFIG_WINDOW_STACK_MODE;
    const quint32 values[] = { XCB_STACK_MODE_ABOVE };
    Q_XCB_CALL(xcb_configure_window(xcb_connection(), m_window, mask, values));
}

requestActivateWindow()

void QXcbWindow::requestActivateWindow ( )

virtual

Reimplement to let Qt be able to request activation/focus for a window.

Some window systems will probably not have callbacks for this functionality, and then calling QWindowSystemInterface::handleWindowActivated(QWidget *w) would be sufficient.

If the window system has some event handling/callbacks then call QWindowSystemInterface::handleWindowActivated(QWidget *w) when the window system gives the notification.

Default implementation calls QWindowSystem::handleWindowActivated(QWidget *w)

Reimplemented from QPlatformWindow.

Definition at line 518 of file qxcbwindow.cpp.

{
    Q_XCB_CALL(xcb_set_input_focus(xcb_connection(), XCB_INPUT_FOCUS_PARENT, m_window, XCB_TIME_CURRENT_TIME));
    connection()->sync();
}

setGeometry()

void QXcbWindow::setGeometry ( const QRect &  rect )

virtual

This function is called by Qt whenever a window is moved or the window is resized.

The resize can happen programatically(from ie. user application) or by the window manager. This means that there is no need to call this function specifically from the window manager callback, instead call QWindowSystemInterface::handleGeometryChange(QWidget *w, const QRect &newRect);

Reimplemented from QPlatformWindow.

Definition at line 264 of file qxcbwindow.cpp.

{
    QPlatformWindow::setGeometry(rect);

    const quint32 mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
    const quint32 values[] = { rect.x(), rect.y(), rect.width(), rect.height() };

    Q_XCB_CALL(xcb_configure_window(xcb_connection(), m_window, mask, values));
}

setNetWmWindowTypes()

void QXcbWindow::setNetWmWindowTypes ( Qt::WindowFlags  flags )

private

Definition at line 444 of file qxcbwindow.cpp.

Referenced by format(), and setWindowFlags().

{
    // in order of decreasing priority
    QVector<uint> windowTypes;

    Qt::WindowType type = static_cast<Qt::WindowType>(int(flags & Qt::WindowType_Mask));

    switch (type) {
    case Qt::Dialog:
    case Qt::Sheet:
        windowTypes.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_DIALOG));
        break;
    case Qt::Tool:
    case Qt::Drawer:
        windowTypes.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_UTILITY));
        break;
    case Qt::ToolTip:
        windowTypes.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_TOOLTIP));
        break;
    case Qt::SplashScreen:
        windowTypes.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_SPLASH));
        break;
    default:
        break;
    }

    if (flags & Qt::FramelessWindowHint)
        windowTypes.append(atom(QXcbAtom::_KDE_NET_WM_WINDOW_TYPE_OVERRIDE));

    windowTypes.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_NORMAL));

    Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
                                   atom(QXcbAtom::_NET_WM_WINDOW_TYPE), XCB_ATOM_ATOM, 32,
                                   windowTypes.count(), windowTypes.constData()));
}

setParent()

void QXcbWindow::setParent ( const QPlatformWindow *  parent )

virtual

This function is called to enable native child widgets in QPA.

It is common not to support this feature in Window systems, but can be faked. When this function is called all geometry of this platform window will be relative to the parent.

Reimplemented from QPlatformWindow.

Definition at line 485 of file qxcbwindow.cpp.

{
    QPoint topLeft = geometry().topLeft();
    Q_XCB_CALL(xcb_reparent_window(xcb_connection(), window(), static_cast<const QXcbWindow *>(parent)->window(), topLeft.x(), topLeft.y()));
}

setVisible()

void QXcbWindow::setVisible ( bool  visible )

virtual

Reimplemented in subclasses to show the surface if visible is true, and hide it if visible is false.

Reimplemented from QPlatformWindow.

Definition at line 274 of file qxcbwindow.cpp.

{
    xcb_wm_hints_t hints;
    if (visible) {
        if (widget()->isMinimized())
            xcb_wm_hints_set_iconic(&hints);
        else
            xcb_wm_hints_set_normal(&hints);
        xcb_set_wm_hints(xcb_connection(), m_window, &hints);
        Q_XCB_CALL(xcb_map_window(xcb_connection(), m_window));
        connection()->sync();
    } else {
        Q_XCB_CALL(xcb_unmap_window(xcb_connection(), m_window));

        // send synthetic UnmapNotify event according to icccm 4.1.4
        xcb_unmap_notify_event_t event;
        event.response_type = XCB_UNMAP_NOTIFY;
        event.sequence = 0; // does this matter?
        event.event = m_screen->root();
        event.window = m_window;
        event.from_configure = false;
        Q_XCB_CALL(xcb_send_event(xcb_connection(), false, m_screen->root(),
                                  XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *)&event));

        xcb_flush(xcb_connection());
    }
}

setWindowFlags()

Qt::WindowFlags QXcbWindow::setWindowFlags ( Qt::WindowFlags  flags )

virtual

Requests setting the window flags of this surface to type.

Returns the actual flags set.

Reimplemented from QPlatformWindow.

Definition at line 335 of file qxcbwindow.cpp.

{
    Qt::WindowType type = static_cast<Qt::WindowType>(int(flags & Qt::WindowType_Mask));

    setNetWmWindowTypes(flags);

    if (type == Qt::ToolTip)
        flags |= Qt::WindowStaysOnTopHint | Qt::FramelessWindowHint | Qt::X11BypassWindowManagerHint;
    if (type == Qt::Popup)
        flags |= Qt::X11BypassWindowManagerHint;

    bool topLevel = (flags & Qt::Window);
    bool popup = (type == Qt::Popup);
    bool dialog = (type == Qt::Dialog
                   || type == Qt::Sheet);
    bool desktop = (type == Qt::Desktop);
    bool tool = (type == Qt::Tool || type == Qt::SplashScreen
                 || type == Qt::ToolTip || type == Qt::Drawer);

    Q_UNUSED(topLevel);
    Q_UNUSED(dialog);
    Q_UNUSED(desktop);
    Q_UNUSED(tool);

    bool tooltip = (type == Qt::ToolTip);

    QtMWMHints mwmhints;
    mwmhints.flags = 0L;
    mwmhints.functions = 0L;
    mwmhints.decorations = 0;
    mwmhints.input_mode = 0L;
    mwmhints.status = 0L;

    if (type != Qt::SplashScreen) {
        mwmhints.flags |= MWM_HINTS_DECORATIONS;

        bool customize = flags & Qt::CustomizeWindowHint;
        if (!(flags & Qt::FramelessWindowHint) && !(customize && !(flags & Qt::WindowTitleHint))) {
            mwmhints.decorations |= MWM_DECOR_BORDER;
            mwmhints.decorations |= MWM_DECOR_RESIZEH;

            if (flags & Qt::WindowTitleHint)
                mwmhints.decorations |= MWM_DECOR_TITLE;

            if (flags & Qt::WindowSystemMenuHint)
                mwmhints.decorations |= MWM_DECOR_MENU;

            if (flags & Qt::WindowMinimizeButtonHint) {
                mwmhints.decorations |= MWM_DECOR_MINIMIZE;
                mwmhints.functions |= MWM_FUNC_MINIMIZE;
            }

            if (flags & Qt::WindowMaximizeButtonHint) {
                mwmhints.decorations |= MWM_DECOR_MAXIMIZE;
                mwmhints.functions |= MWM_FUNC_MAXIMIZE;
            }

            if (flags & Qt::WindowCloseButtonHint)
                mwmhints.functions |= MWM_FUNC_CLOSE;
        }
    } else {
        // if type == Qt::SplashScreen
        mwmhints.decorations = MWM_DECOR_ALL;
    }

    if (mwmhints.functions != 0) {
        mwmhints.flags |= MWM_HINTS_FUNCTIONS;
        mwmhints.functions |= MWM_FUNC_MOVE | MWM_FUNC_RESIZE;
    } else {
        mwmhints.functions = MWM_FUNC_ALL;
    }

    if (!(flags & Qt::FramelessWindowHint)
        && flags & Qt::CustomizeWindowHint
        && flags & Qt::WindowTitleHint
        && !(flags &
             (Qt::WindowMinimizeButtonHint
              | Qt::WindowMaximizeButtonHint
              | Qt::WindowCloseButtonHint)))
    {
        // a special case - only the titlebar without any button
        mwmhints.flags = MWM_HINTS_FUNCTIONS;
        mwmhints.functions = MWM_FUNC_MOVE | MWM_FUNC_RESIZE;
        mwmhints.decorations = 0;
    }

    if (mwmhints.flags != 0l) {
        Q_XCB_CALL(xcb_change_property(xcb_connection(),
                                       XCB_PROP_MODE_REPLACE,
                                       m_window,
                                       atom(QXcbAtom::_MOTIF_WM_HINTS),
                                       atom(QXcbAtom::_MOTIF_WM_HINTS),
                                       32,
                                       5,
                                       &mwmhints));
    } else {
        Q_XCB_CALL(xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_MOTIF_WM_HINTS)));
    }

    if (popup || tooltip) {
        const quint32 mask = XCB_CW_OVERRIDE_REDIRECT | XCB_CW_SAVE_UNDER;
        const quint32 values[] = { true, true };

        Q_XCB_CALL(xcb_change_window_attributes(xcb_connection(), m_window, mask, values));
    }

    return QPlatformWindow::setWindowFlags(flags);
}

setWindowTitle()

void QXcbWindow::setWindowTitle ( const QString &  title )

virtual

Reimplement to set the window title to title.

Reimplemented from QPlatformWindow.

Definition at line 491 of file qxcbwindow.cpp.

{
    QByteArray ba = title.toUtf8();
    Q_XCB_CALL(xcb_change_property(xcb_connection(),
                                   XCB_PROP_MODE_REPLACE,
                                   m_window,
                                   atom(QXcbAtom::_NET_WM_NAME),
                                   atom(QXcbAtom::UTF8_STRING),
                                   8,
                                   ba.length(),
                                   ba.constData()));
}

updateSyncRequestCounter()

void QXcbWindow::updateSyncRequestCounter

(

)

Definition at line 705 of file qxcbwindow.cpp.

Referenced by QXcbWindowSurface::flush(), and format().

{
    if (m_screen->syncRequestSupported() && (m_syncValue.lo != 0 || m_syncValue.hi != 0)) {
        Q_XCB_CALL(xcb_sync_set_counter(xcb_connection(), m_syncCounter, m_syncValue));
        xcb_flush(xcb_connection());
        connection()->sync();

        m_syncValue.lo = 0;
        m_syncValue.hi = 0;
    }
}

window()

xcb_window_t QXcbWindow::window ( ) const

inline

Definition at line 77 of file qxcbwindow.h.

Referenced by QXcbWindowSurface::flush(), setParent(), and QDri2ContextPrivate::xcbWindow().

{ return m_window; }

winId()

WId QXcbWindow::winId ( ) const

virtual

Reimplement in subclasses to return a handle to the native window.

Reimplemented from QPlatformWindow.

Definition at line 480 of file qxcbwindow.cpp.

{
    return m_window;
}

Properties

m_context

QPlatformGLContext* QXcbWindow::m_context

private

Definition at line 103 of file qxcbwindow.h.

Referenced by glContext(), handleConfigureNotifyEvent(), and ~QXcbWindow().

m_depth

uint QXcbWindow::m_depth

private

Definition at line 105 of file qxcbwindow.h.

Referenced by depth(), and QXcbWindow().

m_format

QImage::Format QXcbWindow::m_format

private

Definition at line 106 of file qxcbwindow.h.

Referenced by format(), and QXcbWindow().

m_hasReceivedSyncRequest

bool QXcbWindow::m_hasReceivedSyncRequest

private

Definition at line 111 of file qxcbwindow.h.

Referenced by handleClientMessageEvent().

m_screen

QXcbScreen* QXcbWindow::m_screen

private

Definition at line 100 of file qxcbwindow.h.

Referenced by glContext(), handleClientMessageEvent(), QXcbWindow(), setVisible(), updateSyncRequestCounter(), and ~QXcbWindow().

m_syncCounter

xcb_sync_counter_t QXcbWindow::m_syncCounter

private

Definition at line 109 of file qxcbwindow.h.

Referenced by QXcbWindow(), updateSyncRequestCounter(), and ~QXcbWindow().

m_syncValue

xcb_sync_int64_t QXcbWindow::m_syncValue

private

Definition at line 108 of file qxcbwindow.h.

Referenced by handleClientMessageEvent(), QXcbWindow(), and updateSyncRequestCounter().

m_window

xcb_window_t QXcbWindow::m_window

private

Definition at line 102 of file qxcbwindow.h.

Referenced by glContext(), lower(), QXcbWindow(), raise(), requestActivateWindow(), setGeometry(), setNetWmWindowTypes(), setVisible(), setWindowFlags(), setWindowTitle(), window(), winId(), and ~QXcbWindow().

---

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

• /src/plugins/platforms/xcb/qxcbwindow.h
• /src/plugins/platforms/xcb/qxcbwindow.cpp