QXlibWindow Class Reference

#include <qxlibwindow.h>

Inheritance diagram for QXlibWindow:

Public Functions
uint	depth () const
QImage::Format	format () const
QPlatformGLContext *	glContext () const
	Reimplement to return the glContext associated with the window. More...
GC	graphicsContext () const
void	handleCloseEvent ()
void	handleEnterEvent ()
void	handleFocusInEvent ()
void	handleFocusOutEvent ()
void	handleLeaveEvent ()
void	handleMouseEvent (QEvent::Type, XButtonEvent *ev)
void	lower ()
	Reimplement to be able to let Qt lower windows to the bottom of the desktop. More...
void	mousePressEvent (XButtonEvent *)
void	paintEvent ()
	QXlibWindow (QWidget *window)
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	resizeEvent (XConfigureEvent *configure_event)
void	setCursor (const Cursor &cursor)
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 type)
	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...
Visual *	visual () const
Qt::WindowFlags	windowFlags () const
	Returns the effective window flags for this surface. More...
WId	winId () const
	Reimplement in subclasses to return a handle to the native window. More...
Window	xWindow () const
	~QXlibWindow ()
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	~QPlatformWindow ()
	Virtual destructor does not delete its top level widget. More...

Protected Functions
void	doSizeHints ()
QXlibMWMHints	getMWMHints () const
QVector< Atom >	getNetWmState () const
void	setMWMHints (const QXlibMWMHints &mwmhints)

Private Functions
QPlatformWindowFormat	correctColorBuffers (const QPlatformWindowFormat &windowFormat) const
GC	createGC ()

Properties
GC	gc
uint	mDepth
QImage::Format	mFormat
QPlatformGLContext *	mGLContext
QXlibScreen *	mScreen
Visual *	mVisual
Qt::WindowFlags	mWindowFlags
Window	x_window

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

Detailed Description

Definition at line 86 of file qxlibwindow.h.

Constructors and Destructors

QXlibWindow()

QXlibWindow::QXlibWindow

(

QWidget *

window

)

defined(QT_OPENGL_ES_2)

defined(QT_NO_OPENGL)

Definition at line 74 of file qxlibwindow.cpp.

    : QPlatformWindow(window)
    , mGLContext(0)
    , mScreen(QXlibScreen::testLiteScreenForWidget(window))
{
    int x = window->x();
    int y = window->y();
    int w = window->width();
    int h = window->height();

#if !defined(QT_NO_OPENGL)
    if(window->platformWindowFormat().windowApi() == QPlatformWindowFormat::OpenGL
            && QApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::OpenGL)
            || window->platformWindowFormat().alpha()) {
#if !defined(QT_OPENGL_ES_2)
        XVisualInfo *visualInfo = qglx_findVisualInfo(mScreen->display()->nativeDisplay(),mScreen->xScreenNumber(),window->platformWindowFormat());
#else
        QPlatformWindowFormat windowFormat = correctColorBuffers(window->platformWindowFormat());

        EGLDisplay eglDisplay = mScreen->eglDisplay();
        EGLConfig eglConfig = q_configFromQPlatformWindowFormat(eglDisplay,windowFormat);
        VisualID id = QXlibEglIntegration::getCompatibleVisualId(mScreen->display()->nativeDisplay(), eglDisplay, eglConfig);

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

        XVisualInfo *visualInfo;
        int matchingCount = 0;
        visualInfo = XGetVisualInfo(mScreen->display()->nativeDisplay(), VisualIDMask, &visualInfoTemplate, &matchingCount);
#endif 
        if (visualInfo) {
            mDepth = visualInfo->depth;
            mFormat = (mDepth == 32) ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32;
            mVisual = visualInfo->visual;
            Colormap cmap = XCreateColormap(mScreen->display()->nativeDisplay(), mScreen->rootWindow(), visualInfo->visual, AllocNone);

            XSetWindowAttributes a;
            a.background_pixel = WhitePixel(mScreen->display()->nativeDisplay(), mScreen->xScreenNumber());
            a.border_pixel = BlackPixel(mScreen->display()->nativeDisplay(), mScreen->xScreenNumber());
            a.colormap = cmap;
            x_window = XCreateWindow(mScreen->display()->nativeDisplay(), mScreen->rootWindow(),x, y, w, h,
                                     0, visualInfo->depth, InputOutput, visualInfo->visual,
                                     CWBackPixel|CWBorderPixel|CWColormap, &a);
        } else {
            qFatal("no window!");
        }
    } else
#endif 
    {
        mDepth = mScreen->depth();
        mFormat = (mDepth == 32) ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32;
        mVisual = mScreen->defaultVisual();

        x_window = XCreateSimpleWindow(mScreen->display()->nativeDisplay(), mScreen->rootWindow(),
                                       x, y, w, h, 0 /*border_width*/,
                                       mScreen->blackPixel(), mScreen->whitePixel());
    }

#ifdef MYX11_DEBUG
    qDebug() << "QTestLiteWindow::QTestLiteWindow creating" << hex << x_window << window;
#endif

    XSetWindowBackgroundPixmap(mScreen->display()->nativeDisplay(), x_window, XNone);

    XSelectInput(mScreen->display()->nativeDisplay(), x_window,
                 ExposureMask | KeyPressMask | KeyReleaseMask |
                 EnterWindowMask | LeaveWindowMask | FocusChangeMask |
                 PointerMotionMask | ButtonPressMask |  ButtonReleaseMask |
                 ButtonMotionMask | PropertyChangeMask |
                 StructureNotifyMask);

    gc = createGC();

    Atom protocols[5];
    int n = 0;
    protocols[n++] = QXlibStatic::atom(QXlibStatic::WM_DELETE_WINDOW);        // support del window protocol
    protocols[n++] = QXlibStatic::atom(QXlibStatic::WM_TAKE_FOCUS);                // support take focus window protocol
//    protocols[n++] = QXlibStatic::atom(QXlibStatic::_NET_WM_PING);                // support _NET_WM_PING protocol
#ifndef QT_NO_XSYNC
    protocols[n++] = QXlibStatic::atom(QXlibStatic::_NET_WM_SYNC_REQUEST);        // support _NET_WM_SYNC_REQUEST protocol
#endif // QT_NO_XSYNC
    if (window->windowFlags() & Qt::WindowContextHelpButtonHint)
        protocols[n++] = QXlibStatic::atom(QXlibStatic::_NET_WM_CONTEXT_HELP);
    XSetWMProtocols(mScreen->display()->nativeDisplay(), x_window, protocols, n);
}

~QXlibWindow()

QXlibWindow::~QXlibWindow

(

)

Definition at line 163 of file qxlibwindow.cpp.

{
#ifdef MYX11_DEBUG
    qDebug() << "~QTestLiteWindow" << hex << x_window;
#endif
    delete mGLContext;
    XFreeGC(mScreen->display()->nativeDisplay(), gc);
    XDestroyWindow(mScreen->display()->nativeDisplay(), x_window);
}

Functions

correctColorBuffers()

QPlatformWindowFormat QXlibWindow::correctColorBuffers ( const QPlatformWindowFormat &  windowFormat ) const

private

Definition at line 726 of file qxlibwindow.cpp.

Referenced by glContext(), and QXlibWindow().

{
    // I have only tested this setup on a dodgy intel setup, where I didn't use standard libs,
    // so this might be not what we want to do :)
    if ( !(platformWindowFormat.redBufferSize() == -1   &&
           platformWindowFormat.greenBufferSize() == -1 &&
           platformWindowFormat.blueBufferSize() == -1))
        return platformWindowFormat;

    QPlatformWindowFormat windowFormat = platformWindowFormat;
    if (mScreen->depth() == 16) {
        windowFormat.setRedBufferSize(5);
        windowFormat.setGreenBufferSize(6);
        windowFormat.setBlueBufferSize(5);
    } else {
        windowFormat.setRedBufferSize(8);
        windowFormat.setGreenBufferSize(8);
        windowFormat.setBlueBufferSize(8);
    }

    return windowFormat;
}

createGC()

GC QXlibWindow::createGC ( )

private

Definition at line 305 of file qxlibwindow.cpp.

Referenced by QXlibWindow().

{
    GC gc;

    gc = XCreateGC(mScreen->display()->nativeDisplay(), x_window, 0, 0);
    if (gc < 0) {
        qWarning("QTestLiteWindow::createGC() could not create GC");
    }
    return gc;
}

depth()

uint QXlibWindow::depth ( ) const

inline

Definition at line 125 of file qxlibwindow.h.

Referenced by QXlibWindowSurface::flush(), and QXlibWindowSurface::resizeShmImage().

{ return mDepth; }

doSizeHints()

void QXlibWindow::doSizeHints ( )

protected

Definition at line 707 of file qxlibwindow.cpp.

Referenced by setVisible().

{
    Q_ASSERT(widget()->testAttribute(Qt::WA_WState_Created));
    XSizeHints s;
    s.flags = 0;
    QRect g = geometry();
    s.x = g.x();
    s.y = g.y();
    s.width = g.width();
    s.height = g.height();
    s.flags |= USPosition;
    s.flags |= PPosition;
    s.flags |= USSize;
    s.flags |= PSize;
    s.flags |= PWinGravity;
    s.win_gravity = QApplication::isRightToLeft() ? NorthEastGravity : NorthWestGravity;
    XSetWMNormalHints(mScreen->display()->nativeDisplay(), x_window, &s);
}

format()

QImage::Format QXlibWindow::format ( ) const

inline

Definition at line 126 of file qxlibwindow.h.

Referenced by getMWMHints(), and QXlibWindowSurface::resizeShmImage().

{ return mFormat; }

getMWMHints()

QXlibMWMHints QXlibWindow::getMWMHints ( ) const

protected

Definition at line 373 of file qxlibwindow.cpp.

{
    QXlibMWMHints mwmhints;

    Atom type;
    int format;
    ulong nitems, bytesLeft;
    uchar *data = 0;
    Atom atomForMotifWmHints = QXlibStatic::atom(QXlibStatic::_MOTIF_WM_HINTS);
    if ((XGetWindowProperty(mScreen->display()->nativeDisplay(), x_window, atomForMotifWmHints, 0, 5, false,
                            atomForMotifWmHints, &type, &format, &nitems, &bytesLeft,
                            &data) == Success)
        && (type == atomForMotifWmHints
            && format == 32
            && nitems >= 5)) {
        mwmhints = *(reinterpret_cast<QXlibMWMHints *>(data));
    } else {
        mwmhints.flags = 0L;
        mwmhints.functions = MWM_FUNC_ALL;
        mwmhints.decorations = MWM_DECOR_ALL;
        mwmhints.input_mode = 0L;
        mwmhints.status = 0L;
    }

    if (data)
        XFree(data);

    return mwmhints;
}

getNetWmState()

QVector< Atom > QXlibWindow::getNetWmState ( ) const

protected

Definition at line 428 of file qxlibwindow.cpp.

Referenced by setWindowFlags().

{
    QVector<Atom> returnValue;

    // Don't read anything, just get the size of the property data
    Atom actualType;
    int actualFormat;
    ulong propertyLength;
    ulong bytesLeft;
    uchar *propertyData = 0;
    if (XGetWindowProperty(mScreen->display()->nativeDisplay(), x_window, QXlibStatic::atom(QXlibStatic::_NET_WM_STATE), 0, 0,
                           False, XA_ATOM, &actualType, &actualFormat,
                           &propertyLength, &bytesLeft, &propertyData) == Success
        && actualType == XA_ATOM && actualFormat == 32) {
        returnValue.resize(bytesLeft / 4);
        XFree((char*) propertyData);

        // fetch all data
        if (XGetWindowProperty(mScreen->display()->nativeDisplay(), x_window, QXlibStatic::atom(QXlibStatic::_NET_WM_STATE), 0,
                               returnValue.size(), False, XA_ATOM, &actualType, &actualFormat,
                               &propertyLength, &bytesLeft, &propertyData) != Success) {
            returnValue.clear();
        } else if (propertyLength != (ulong)returnValue.size()) {
            returnValue.resize(propertyLength);
        }

        // put it into netWmState
        if (!returnValue.isEmpty()) {
            memcpy(returnValue.data(), propertyData, returnValue.size() * sizeof(Atom));
        }
        XFree((char*) propertyData);
    }

    return returnValue;
}

glContext()

QPlatformGLContext * QXlibWindow::glContext ( ) const

virtual

Reimplement to return the glContext associated with the window.

Reimplemented from QPlatformWindow.

Definition at line 669 of file qxlibwindow.cpp.

{
    if (!QApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::OpenGL))
        return 0;
    if (!mGLContext) {
        QXlibWindow *that = const_cast<QXlibWindow *>(this);
#if !defined(QT_NO_OPENGL)
#if !defined(QT_OPENGL_ES_2)
        that->mGLContext = new QGLXContext(x_window, mScreen,widget()->platformWindowFormat());
#else
        EGLDisplay display = mScreen->eglDisplay();

        QPlatformWindowFormat windowFormat = correctColorBuffers(widget()->platformWindowFormat());

        EGLConfig config = q_configFromQPlatformWindowFormat(display,windowFormat);
        QVector<EGLint> eglContextAttrs;
        eglContextAttrs.append(EGL_CONTEXT_CLIENT_VERSION);
        eglContextAttrs.append(2);
        eglContextAttrs.append(EGL_NONE);

        EGLSurface eglSurface = eglCreateWindowSurface(display,config,(EGLNativeWindowType)x_window,0);
        that->mGLContext = new QEGLPlatformContext(display, config, eglContextAttrs.data(), eglSurface, EGL_OPENGL_ES_API, static_cast<QEGLPlatformContext *>(windowFormat.sharedGLContext()));
#endif
#endif
    }
    return mGLContext;
}

graphicsContext()

GC QXlibWindow::graphicsContext

(

)

const

Definition at line 702 of file qxlibwindow.cpp.

Referenced by QXlibWindowSurface::flush().

{
    return gc;
}

handleCloseEvent()

void QXlibWindow::handleCloseEvent

(

)

Definition at line 232 of file qxlibwindow.cpp.

Referenced by QXlibScreen::handleEvent().

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

handleEnterEvent()

void QXlibWindow::handleEnterEvent

(

)

Definition at line 238 of file qxlibwindow.cpp.

Referenced by QXlibScreen::handleEvent().

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

handleFocusInEvent()

void QXlibWindow::handleFocusInEvent

(

)

Definition at line 248 of file qxlibwindow.cpp.

Referenced by QXlibScreen::handleEvent().

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

handleFocusOutEvent()

void QXlibWindow::handleFocusOutEvent

(

)

Definition at line 253 of file qxlibwindow.cpp.

Referenced by QXlibScreen::handleEvent().

{
    QWindowSystemInterface::handleWindowActivated(0);
}

handleLeaveEvent()

void QXlibWindow::handleLeaveEvent

(

)

Definition at line 243 of file qxlibwindow.cpp.

Referenced by QXlibScreen::handleEvent().

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

handleMouseEvent()

void QXlibWindow::handleMouseEvent	(	QEvent::Type	type,
		XButtonEvent *	ev
	)

Definition at line 189 of file qxlibwindow.cpp.

Referenced by QXlibScreen::handleEvent(), and mousePressEvent().

{
    static QPoint mousePoint;

    Qt::MouseButton button = Qt::NoButton;
    Qt::MouseButtons buttons = translateMouseButtons(e->state);
    Qt::KeyboardModifiers modifiers = mScreen->keyboard()->translateModifiers(e->state);
    if (type != QEvent::MouseMove) {
        switch (e->button) {
        case Button1: button = Qt::LeftButton; break;
        case Button2: button = Qt::MidButton; break;
        case Button3: button = Qt::RightButton; break;
        case Button4:
        case Button5:
        case 6:
        case 7: {
            //mouse wheel
            if (type == QEvent::MouseButtonPress) {
                //logic borrowed from qapplication_x11.cpp
                int delta = 120 * ((e->button == Button4 || e->button == 6) ? 1 : -1);
                bool hor = (((e->button == Button4 || e->button == Button5)
                             && (modifiers & Qt::AltModifier))
                            || (e->button == 6 || e->button == 7));
                QWindowSystemInterface::handleWheelEvent(widget(), e->time,
                                                      QPoint(e->x, e->y),
                                                      QPoint(e->x_root, e->y_root),
                                                      delta, hor ? Qt::Horizontal : Qt::Vertical);
            }
            return;
        }
        default: break;
        }
    }

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

    QWindowSystemInterface::handleMouseEvent(widget(), e->time, QPoint(e->x, e->y),
                                          QPoint(e->x_root, e->y_root),
                                          buttons);

    mousePoint = QPoint(e->x_root, e->y_root);
}

lower()

void QXlibWindow::lower ( )

virtual

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

Reimplemented from QPlatformWindow.

Definition at line 288 of file qxlibwindow.cpp.

{
    XLowerWindow(mScreen->display()->nativeDisplay(), x_window);
}

mousePressEvent()

void QXlibWindow::mousePressEvent

(

XButtonEvent *

e

)

Definition at line 350 of file qxlibwindow.cpp.

Referenced by QXlibScreen::handleEvent().

{
    static long prevTime = 0;
    static Window prevWindow;
    static int prevX = -999;
    static int prevY = -999;

    QEvent::Type type = QEvent::MouseButtonPress;

    if (e->window == prevWindow && long(e->time) - prevTime < QApplication::doubleClickInterval()
        && qAbs(e->x - prevX) < 5 && qAbs(e->y - prevY) < 5) {
        type = QEvent::MouseButtonDblClick;
        prevTime = e->time - QApplication::doubleClickInterval(); //no double click next time
    } else {
        prevTime = e->time;
    }
    prevWindow = e->window;
    prevX = e->x;
    prevY = e->y;

    handleMouseEvent(type, e);
}

paintEvent()

void QXlibWindow::paintEvent

(

)

Definition at line 316 of file qxlibwindow.cpp.

Referenced by QXlibScreen::handleEvent().

{
#ifdef MYX11_DEBUG
//    qDebug() << "QTestLiteWindow::paintEvent" << shm_img.size() << painted;
#endif

    if (QWindowSurface *surface = widget()->windowSurface())
        surface->flush(widget(), widget()->geometry(), QPoint());
}

raise()

void QXlibWindow::raise ( )

virtual

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

Reimplemented from QPlatformWindow.

Definition at line 283 of file qxlibwindow.cpp.

{
    XRaiseWindow(mScreen->display()->nativeDisplay(), x_window);
}

requestActivateWindow()

void QXlibWindow::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 326 of file qxlibwindow.cpp.

{
    XSetInputFocus(mScreen->display()->nativeDisplay(), x_window, XRevertToParent, CurrentTime);
}

resizeEvent()

void QXlibWindow::resizeEvent

(

XConfigureEvent *

configure_event

)

Definition at line 331 of file qxlibwindow.cpp.

Referenced by QXlibScreen::handleEvent().

{
    int xpos = geometry().x();
    int ypos = geometry().y();
    if ((e->width != geometry().width() || e->height != geometry().height()) && e->x == 0 && e->y == 0) {
        //qDebug() << "resize with bogus pos" << e->x << e->y << e->width << e->height << "window"<< hex << window;
    } else {
        //qDebug() << "geometry change" << e->x << e->y << e->width << e->height << "window"<< hex << window;
        xpos = e->x;
        ypos = e->y;
    }
#ifdef MYX11_DEBUG
    qDebug() << hex << x_window << dec << "ConfigureNotify" << e->x << e->y << e->width << e->height << "geometry" << xpos << ypos << width << height;
#endif

    QRect newRect(xpos, ypos, e->width, e->height);
    QWindowSystemInterface::handleGeometryChange(widget(), newRect);
}

setCursor()

void QXlibWindow::setCursor

(

const Cursor &

cursor

)

Definition at line 663 of file qxlibwindow.cpp.

Referenced by QXlibCursor::changeCursor().

{
    XDefineCursor(mScreen->display()->nativeDisplay(), x_window, cursor);
    mScreen->display()->flush();
}

setGeometry()

void QXlibWindow::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 260 of file qxlibwindow.cpp.

{
    XMoveResizeWindow(mScreen->display()->nativeDisplay(), x_window, rect.x(), rect.y(), rect.width(), rect.height());
    QPlatformWindow::setGeometry(rect);
}

setMWMHints()

void QXlibWindow::setMWMHints ( const QXlibMWMHints &  mwmhints )

protected

Definition at line 403 of file qxlibwindow.cpp.

Referenced by setWindowFlags().

{
    Atom atomForMotifWmHints = QXlibStatic::atom(QXlibStatic::_MOTIF_WM_HINTS);
    if (mwmhints.flags != 0l) {
        XChangeProperty(mScreen->display()->nativeDisplay(), x_window,
                        atomForMotifWmHints, atomForMotifWmHints, 32,
                        PropModeReplace, (unsigned char *) &mwmhints, 5);
    } else {
        XDeleteProperty(mScreen->display()->nativeDisplay(), x_window, atomForMotifWmHints);
    }
}

setParent()

void QXlibWindow::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 277 of file qxlibwindow.cpp.

{
    QPoint topLeft = geometry().topLeft();
    XReparentWindow(mScreen->display()->nativeDisplay(),x_window,window->winId(),topLeft.x(),topLeft.y());
}

setVisible()

void QXlibWindow::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 637 of file qxlibwindow.cpp.

{
#ifdef MYX11_DEBUG
    qDebug() << "QTestLiteWindow::setVisible" << visible << hex << x_window;
#endif
    if (isTransient(widget())) {
        Window parentXWindow = x_window;
        if (widget()->parentWidget()) {
            QWidget *widgetParent = widget()->parentWidget()->window();
            if (widgetParent && widgetParent->platformWindow()) {
                QXlibWindow *parentWidnow = static_cast<QXlibWindow *>(widgetParent->platformWindow());
                parentXWindow = parentWidnow->x_window;
            }
        }
        XSetTransientForHint(mScreen->display()->nativeDisplay(),x_window,parentXWindow);
    }

    if (visible) {
        //ensure that the window is viewed in correct position.
        doSizeHints();
        XMapWindow(mScreen->display()->nativeDisplay(), x_window);
    } else {
        XUnmapWindow(mScreen->display()->nativeDisplay(), x_window);
    }
}

setWindowFlags()

Qt::WindowFlags QXlibWindow::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 464 of file qxlibwindow.cpp.

{
//    Q_ASSERT(flags & Qt::Window);
    mWindowFlags = flags;

#ifdef MYX11_DEBUG
    qDebug() << "QTestLiteWindow::setWindowFlags" << hex << x_window << "flags" << flags;
#endif
    Qt::WindowType type = static_cast<Qt::WindowType>(int(flags & Qt::WindowType_Mask));

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

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

    XSetWindowAttributes wsa;

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


    ulong wsa_mask = 0;
    if (type != Qt::SplashScreen) { // && customize) {
        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 (tool) {
        wsa.save_under = True;
        wsa_mask |= CWSaveUnder;
    }

    if (flags & Qt::X11BypassWindowManagerHint) {
        wsa.override_redirect = True;
        wsa_mask |= CWOverrideRedirect;
    }
#if 0
    if (wsa_mask && initializeWindow) {
        Q_ASSERT(id);
        XChangeWindowAttributes(dpy, id, wsa_mask, &wsa);
    }
#endif
    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 (widget()->windowModality() == Qt::WindowModal) {
        mwmhints.input_mode = MWM_INPUT_PRIMARY_APPLICATION_MODAL;
    } else if (widget()->windowModality() == Qt::ApplicationModal) {
        mwmhints.input_mode = MWM_INPUT_FULL_APPLICATION_MODAL;
    }

    setMWMHints(mwmhints);

    QVector<Atom> netWmState = getNetWmState();

    if (flags & Qt::WindowStaysOnTopHint) {
        if (flags & Qt::WindowStaysOnBottomHint)
            qWarning() << "QWidget: Incompatible window flags: the window can't be on top and on bottom at the same time";
        if (!netWmState.contains(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_ABOVE)))
            netWmState.append(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_ABOVE));
        if (!netWmState.contains(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_STAYS_ON_TOP)))
            netWmState.append(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_STAYS_ON_TOP));
    } else if (flags & Qt::WindowStaysOnBottomHint) {
        if (!netWmState.contains(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_BELOW)))
            netWmState.append(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_BELOW));
    }
    if (widget()->isFullScreen()) {
        if (!netWmState.contains(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_FULLSCREEN)))
            netWmState.append(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_FULLSCREEN));
    }
    if (widget()->isMaximized()) {
        if (!netWmState.contains(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_MAXIMIZED_HORZ)))
            netWmState.append(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_MAXIMIZED_HORZ));
        if (!netWmState.contains(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_MAXIMIZED_VERT)))
            netWmState.append(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_MAXIMIZED_VERT));
    }
    if (widget()->windowModality() != Qt::NonModal) {
        if (!netWmState.contains(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_MODAL)))
            netWmState.append(QXlibStatic::atom(QXlibStatic::_NET_WM_STATE_MODAL));
    }

    if (!netWmState.isEmpty()) {
        XChangeProperty(mScreen->display()->nativeDisplay(), x_window,
                        QXlibStatic::atom(QXlibStatic::_NET_WM_STATE), XA_ATOM, 32, PropModeReplace,
                        (unsigned char *) netWmState.data(), netWmState.size());
    } else {
        XDeleteProperty(mScreen->display()->nativeDisplay(), x_window, QXlibStatic::atom(QXlibStatic::_NET_WM_STATE));
    }

//##### only if initializeWindow???

    if (popup || tooltip) {                        // popup widget
#ifdef MYX11_DEBUG
        qDebug() << "Doing XChangeWindowAttributes for popup" << wsa.override_redirect;
#endif
        // set EWMH window types
        // setNetWmWindowTypes();

        wsa.override_redirect = True;
        wsa.save_under = True;
        XChangeWindowAttributes(mScreen->display()->nativeDisplay(), x_window, CWOverrideRedirect | CWSaveUnder,
                                &wsa);
    } else {
#ifdef MYX11_DEBUG
        qDebug() << "Doing XChangeWindowAttributes for non-popup";
#endif
    }

    return flags;
}

setWindowTitle()

void QXlibWindow::setWindowTitle ( const QString &  title )

virtual

Reimplement to set the window title to title.

Reimplemented from QPlatformWindow.

Definition at line 293 of file qxlibwindow.cpp.

{
    QByteArray ba = title.toLatin1(); //We're not making a general solution here...
    XTextProperty windowName;
    windowName.value    = (unsigned char *)ba.constData();
    windowName.encoding = XA_STRING;
    windowName.format   = 8;
    windowName.nitems   = ba.length();

    XSetWMName(mScreen->display()->nativeDisplay(), x_window, &windowName);
}

visual()

Visual* QXlibWindow::visual ( ) const

inline

Definition at line 127 of file qxlibwindow.h.

Referenced by QXlibWindowSurface::flush(), and QXlibWindowSurface::resizeShmImage().

{ return mVisual; }

windowFlags()

Qt::WindowFlags QXlibWindow::windowFlags ( ) const

virtual

Returns the effective window flags for this surface.

Reimplemented from QPlatformWindow.

Definition at line 267 of file qxlibwindow.cpp.

{
    return mWindowFlags;
}

winId()

WId QXlibWindow::winId ( ) const

virtual

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

Reimplemented from QPlatformWindow.

Definition at line 272 of file qxlibwindow.cpp.

{
    return x_window;
}

xWindow()

Window QXlibWindow::xWindow

(

)

const

Definition at line 697 of file qxlibwindow.cpp.

Referenced by QXlibWindowSurface::flush().

{
    return x_window;
}

Properties

gc

GC QXlibWindow::gc

private

Definition at line 140 of file qxlibwindow.h.

Referenced by createGC(), graphicsContext(), QXlibWindow(), and ~QXlibWindow().

mDepth

uint QXlibWindow::mDepth

private

Definition at line 142 of file qxlibwindow.h.

Referenced by QXlibWindow().

mFormat

QImage::Format QXlibWindow::mFormat

private

Definition at line 143 of file qxlibwindow.h.

Referenced by QXlibWindow().

mGLContext

QPlatformGLContext* QXlibWindow::mGLContext

private

Definition at line 148 of file qxlibwindow.h.

Referenced by glContext(), and ~QXlibWindow().

mScreen

QXlibScreen* QXlibWindow::mScreen

private

Definition at line 149 of file qxlibwindow.h.

Referenced by correctColorBuffers(), createGC(), doSizeHints(), getMWMHints(), getNetWmState(), glContext(), handleMouseEvent(), lower(), QXlibWindow(), raise(), requestActivateWindow(), setCursor(), setGeometry(), setMWMHints(), setParent(), setVisible(), setWindowFlags(), setWindowTitle(), and ~QXlibWindow().

mVisual

Visual* QXlibWindow::mVisual

private

Definition at line 144 of file qxlibwindow.h.

Referenced by QXlibWindow().

mWindowFlags

Qt::WindowFlags QXlibWindow::mWindowFlags

private

Definition at line 150 of file qxlibwindow.h.

Referenced by setWindowFlags(), and windowFlags().

x_window

Window QXlibWindow::x_window

private

Definition at line 139 of file qxlibwindow.h.

Referenced by createGC(), doSizeHints(), getMWMHints(), getNetWmState(), glContext(), lower(), QXlibWindow(), raise(), requestActivateWindow(), resizeEvent(), setCursor(), setGeometry(), setMWMHints(), setParent(), setVisible(), setWindowFlags(), setWindowTitle(), winId(), xWindow(), and ~QXlibWindow().

---

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

• /src/plugins/platforms/xlib/qxlibwindow.h
• /src/plugins/platforms/xlib/qxlibwindow.cpp