QX11GLWindowSurface Class Reference

#include <qwindowsurface_x11gl_p.h>

Inheritance diagram for QX11GLWindowSurface:

Public Functions
void	flush (QWidget *widget, const QRegion &region, const QPoint &offset)
	Flushes the given region from the specified widget onto the screen. More...
QPixmap	grabWidget (const QWidget *widget, const QRect &rectangle=QRect()) const
	Returns a QPixmap generated from the part of the backing store corresponding to widget. More...
QPaintDevice *	paintDevice ()
	Implement this function to return the appropriate paint device. More...
	QX11GLWindowSurface (QWidget *window)
bool	scroll (const QRegion &area, int dx, int dy)
	Scrolls the given area dx pixels to the right and dy downward; both dx and dy may be negative. More...
void	setGeometry (const QRect &rect)
	Sets the currently allocated area to be the given rect. More...
virtual	~QX11GLWindowSurface ()
Public Functions inherited from QWindowSurface
virtual void	beginPaint (const QRegion &)
	This function is called before painting onto the surface begins, with the region in which the painting will occur. More...
virtual QImage *	buffer (const QWidget *widget)
	Returns a QImage pointer which represents the actual buffer the widget is drawn into or 0 if this is unavailable. More...
virtual void	endPaint (const QRegion &)
	This function is called after painting onto the surface has ended, with the region in which the painting was performed. More...
virtual WindowSurfaceFeatures	features () const
QRect	geometry () const
	Returns the currently allocated area on the screen. More...
bool	hasFeature (WindowSurfaceFeature feature) const
virtual QPoint	offset (const QWidget *widget) const
	Returns the offset of widget in the coordinates of this window surface. More...
	QWindowSurface (QWidget *window, bool setDefaultSurface=true)
	Constructs an empty surface for the given top-level window. More...
QRect	rect (const QWidget *widget) const
	Returns the rectangle for widget in the coordinates of this window surface. More...
void	setStaticContents (const QRegion &region)
QRegion	staticContents () const
QWidget *	window () const
	Returns a pointer to the top-level window associated with this surface. More...
virtual	~QWindowSurface ()
	Destroys this surface. More...

Properties
QPixmap	m_backBuffer
GC	m_pixmapGC
QWidget *	m_window
GC	m_windowGC

Additional Inherited Members
Public Types inherited from QWindowSurface
enum	WindowSurfaceFeature { PartialUpdates = 0x00000001, PreservedContents = 0x00000002, StaticContents = 0x00000004, AllFeatures = 0xffffffff }
Protected Functions inherited from QWindowSurface
bool	hasStaticContents () const

Detailed Description

Definition at line 60 of file qwindowsurface_x11gl_p.h.

Constructors and Destructors

QX11GLWindowSurface()

QX11GLWindowSurface::QX11GLWindowSurface

(

QWidget *

window

)

Definition at line 53 of file qwindowsurface_x11gl.cpp.

    : QWindowSurface(window), m_windowGC(0), m_pixmapGC(0), m_window(window)
{
}

~QX11GLWindowSurface()

QX11GLWindowSurface::~QX11GLWindowSurface ( )

virtual

Definition at line 58 of file qwindowsurface_x11gl.cpp.

{
    if (m_windowGC)
        XFree(m_windowGC);
    if (m_pixmapGC)
        XFree(m_pixmapGC);
}

Functions

flush()

void QX11GLWindowSurface::flush ( QWidget *  widget, const QRegion &  region, const QPoint &  offset  )

virtual

Flushes the given region from the specified widget onto the screen.

Note that the offset parameter is currently unused.

Implements QWindowSurface.

Definition at line 73 of file qwindowsurface_x11gl.cpp.

{
    // We don't need to know the widget which initiated the flush. Instead we just use the offset
    // to translate the widgetRegion:
    Q_UNUSED(widget);

    if (m_backBuffer.isNull()) {
        qDebug("QX11GLWindowSurface::flush() - backBuffer is null, not flushing anything");
        return;
    }

    Q_ASSERT(window()->size() != m_backBuffer.size());

    // Wait for all GL rendering to the back buffer pixmap to complete before trying to
    // copy it to the window. We do this by making sure the pixmap's context is current
    // and then call eglWaitClient. The EGL 1.4 spec says eglWaitClient doesn't have to
    // block, just that "All rendering calls...are guaranteed to be executed before native
    // rendering calls". This makes it potentially less expensive than glFinish.
    QGLContext* ctx = static_cast<QX11GLPixmapData*>(m_backBuffer.data_ptr().data())->context();
    if (QGLContext::currentContext() != ctx && ctx && ctx->isValid())
        ctx->makeCurrent();
    eglWaitClient();

    if (m_windowGC == 0) {
        XGCValues attribs;
        attribs.graphics_exposures = False;
        m_windowGC = XCreateGC(X11->display, m_window->handle(), GCGraphicsExposures, &attribs);
    }

    int rectCount;
    XRectangle *rects = (XRectangle *)qt_getClipRects(widgetRegion, rectCount);
    if (rectCount <= 0)
        return;

    XSetClipRectangles(X11->display, m_windowGC, 0, 0, rects, rectCount, YXBanded);

    QRect dirtyRect = widgetRegion.boundingRect().translated(-offset);
    XCopyArea(X11->display, m_backBuffer.handle(), m_window->handle(), m_windowGC,
              dirtyRect.x(), dirtyRect.y(), dirtyRect.width(), dirtyRect.height(),
              dirtyRect.x(), dirtyRect.y());

    // Make sure the blit of the update from the back buffer to the window completes
    // before allowing rendering to start again to the back buffer. Otherwise the GPU
    // might start rendering to the back buffer again while the blit takes place.
    eglWaitNative(EGL_CORE_NATIVE_ENGINE);
}

grabWidget()

QPixmap QX11GLWindowSurface::grabWidget ( const QWidget *  widget, const QRect &  rectangle = QRect()  ) const

virtual

Returns a QPixmap generated from the part of the backing store corresponding to widget.

Returns a null QPixmap if an error occurs. The contents of the pixmap are only defined for the regions of widget that have received paint events since the last resize of the backing store.

If rectangle is a null rectangle (the default), the entire widget is grabbed. Otherwise, the grabbed area is limited to rectangle.

The default implementation uses QWindowSurface::buffer().

See also

QPixmap::grabWidget()

Reimplemented from QWindowSurface.

Definition at line 167 of file qwindowsurface_x11gl.cpp.

{
    if (!widget || m_backBuffer.isNull())
        return QPixmap();

    QRect srcRect;

    // make sure the rect is inside the widget & clip to widget's rect
    if (!rect.isEmpty())
        srcRect = rect & widget->rect();
    else
        srcRect = widget->rect();

    if (srcRect.isEmpty())
        return QPixmap();

    // If it's a child widget we have to translate the coordinates
    if (widget != window())
        srcRect.translate(widget->mapTo(window(), QPoint(0, 0)));

    QPixmap::x11SetDefaultScreen(widget->x11Info().screen());

    QX11PixmapData *pmd = new QX11PixmapData(QPixmapData::PixmapType);
    pmd->resize(srcRect.width(), srcRect.height());
    QPixmap px(pmd);

    GC tmpGc = XCreateGC(X11->display, m_backBuffer.handle(), 0, 0);

    // Make sure all GL rendering is complete before copying the window
    QGLContext* ctx = static_cast<QX11GLPixmapData*>(m_backBuffer.pixmapData())->context();
    if (QGLContext::currentContext() != ctx && ctx && ctx->isValid())
        ctx->makeCurrent();
    eglWaitClient();

    // Copy srcRect from the backing store to the new pixmap
    XSetGraphicsExposures(X11->display, tmpGc, False);
    XCopyArea(X11->display, m_backBuffer.handle(), px.handle(), tmpGc,
              srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height(), 0, 0);
    XFreeGC(X11->display, tmpGc);

    // Wait until the copy has finised before allowing more rendering into the back buffer
    eglWaitNative(EGL_CORE_NATIVE_ENGINE);

    return px;
}

paintDevice()

QPaintDevice * QX11GLWindowSurface::paintDevice ( )

virtual

Implement this function to return the appropriate paint device.

Implements QWindowSurface.

Definition at line 66 of file qwindowsurface_x11gl.cpp.

{
    return &m_backBuffer;
}

scroll()

bool QX11GLWindowSurface::scroll ( const QRegion &  area, int  dx, int  dy  )

virtual

Scrolls the given area dx pixels to the right and dy downward; both dx and dy may be negative.

Returns true if the area was scrolled successfully; false otherwise.

Reimplemented from QWindowSurface.

Definition at line 138 of file qwindowsurface_x11gl.cpp.

{
    if (m_backBuffer.isNull())
        return false;

    Q_ASSERT(m_backBuffer.data_ptr()->classId() == QPixmapData::X11Class);

    // Make sure all GL rendering is complete before starting the scroll operation:
    QGLContext* ctx = static_cast<QX11GLPixmapData*>(m_backBuffer.data_ptr().data())->context();
    if (QGLContext::currentContext() != ctx && ctx && ctx->isValid())
        ctx->makeCurrent();
    eglWaitClient();

    if (!m_pixmapGC)
        m_pixmapGC = XCreateGC(X11->display, m_backBuffer.handle(), 0, 0);

    foreach (const QRect& rect, area.rects()) {
        XCopyArea(X11->display, m_backBuffer.handle(), m_backBuffer.handle(), m_pixmapGC,
                  rect.x(), rect.y(), rect.width(), rect.height(),
                  rect.x()+dx, rect.y()+dy);
    }

    // Make sure the scroll operation is complete before allowing GL rendering to resume
    eglWaitNative(EGL_CORE_NATIVE_ENGINE);

    return true;
}

setGeometry()

void QX11GLWindowSurface::setGeometry ( const QRect &  rect )

virtual

Sets the currently allocated area to be the given rect.

This function is called whenever area covered by the top-level window changes.

See also

geometry()

Reimplemented from QWindowSurface.

Definition at line 120 of file qwindowsurface_x11gl.cpp.

{
    if (rect.width() > m_backBuffer.size().width() || rect.height() > m_backBuffer.size().height()) {
        QX11GLPixmapData *pd = new QX11GLPixmapData;
        QSize newSize = rect.size();
        pd->resize(newSize.width(), newSize.height());
        m_backBuffer = QPixmap(pd);
        if (window()->testAttribute(Qt::WA_TranslucentBackground))
            m_backBuffer.fill(Qt::transparent);
        if (m_pixmapGC) {
            XFreeGC(X11->display, m_pixmapGC);
            m_pixmapGC = 0;
        }
    }

    QWindowSurface::setGeometry(rect);
}

Properties

m_backBuffer

QPixmap QX11GLWindowSurface::m_backBuffer

private

Definition at line 76 of file qwindowsurface_x11gl_p.h.

Referenced by flush(), grabWidget(), paintDevice(), scroll(), and setGeometry().

m_pixmapGC

GC QX11GLWindowSurface::m_pixmapGC

private

Definition at line 75 of file qwindowsurface_x11gl_p.h.

Referenced by scroll(), setGeometry(), and ~QX11GLWindowSurface().

m_window

QWidget* QX11GLWindowSurface::m_window

private

Definition at line 77 of file qwindowsurface_x11gl_p.h.

Referenced by flush().

m_windowGC

GC QX11GLWindowSurface::m_windowGC

private

Definition at line 74 of file qwindowsurface_x11gl_p.h.

Referenced by flush(), and ~QX11GLWindowSurface().

---

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

• /src/opengl/qwindowsurface_x11gl_p.h
• /src/opengl/qwindowsurface_x11gl.cpp