#include <qwindowsurface_vgegl_p.h>

Inheritance diagram for QVGEGLWindowSurfaceDirect:

Public Functions
void	beginPaint (QWidget *widget)

void	endPaint (QWidget widget, const QRegion &region, QImage image)

QEglContext *	ensureContext (QWidget *widget)

	QVGEGLWindowSurfaceDirect (QWindowSurface *win)

bool	scroll (QWidget *widget, const QRegion &area, int dx, int dy)

bool	supportsStaticContents () const

QSize	surfaceSize () const

virtual	~QVGEGLWindowSurfaceDirect ()

Public Functions inherited from QVGEGLWindowSurfacePrivate
QVGPaintEngine *	paintEngine ()

	QVGEGLWindowSurfacePrivate (QWindowSurface *win)

virtual VGImage	surfaceImage () const

virtual	~QVGEGLWindowSurfacePrivate ()

Protected Variables
QEglContext *	context

bool	isPaintingActive

bool	needToSwap

QSize	size

EGLSurface	windowSurface

Protected Variables inherited from QVGEGLWindowSurfacePrivate
QVGPaintEngine *	engine

QWindowSurface *	winSurface

Additional Inherited Members
Protected Functions inherited from QVGEGLWindowSurfacePrivate
void	destroyPaintEngine ()

QSize	windowSurfaceSize (QWidget *widget) const

Detailed Description

Definition at line 121 of file qwindowsurface_vgegl_p.h.

Constructors and Destructors

◆ QVGEGLWindowSurfaceDirect()

QVGEGLWindowSurfaceDirect::QVGEGLWindowSurfaceDirect ( QWindowSurface * win )

Definition at line 608 of file qwindowsurface_vgegl.cpp.

     : QVGEGLWindowSurfacePrivate(win)
     , context(0)
     , isPaintingActive(false)
     , needToSwap(false)
     , windowSurface(EGL_NO_SURFACE)
 {
 }

◆ ~QVGEGLWindowSurfaceDirect()

QVGEGLWindowSurfaceDirect::~QVGEGLWindowSurfaceDirect ( )

virtual

Definition at line 617 of file qwindowsurface_vgegl.cpp.

 {
     destroyPaintEngine();
     if (context) {
         if (windowSurface != EGL_NO_SURFACE)
             context->destroySurface(windowSurface);
         qt_vg_destroy_context(context, QInternal::Widget);
     }
 }

Functions

◆ beginPaint()

void QVGEGLWindowSurfaceDirect::beginPaint ( QWidget * widget )

virtual

Implements QVGEGLWindowSurfacePrivate.

Definition at line 722 of file qwindowsurface_vgegl.cpp.

 {
     QEglContext *context = ensureContext(widget);
     if (context) {
         context->makeCurrent(windowSurface);
         isPaintingActive = true;
     }
 }

◆ endPaint()

void QVGEGLWindowSurfaceDirect::endPaint	(	QWidget *	widget,
		const QRegion &	region,
		QImage *	image
	)

virtual

Implements QVGEGLWindowSurfacePrivate.

Definition at line 732 of file qwindowsurface_vgegl.cpp.

Referenced by beginPaint().

 {
     Q_UNUSED(region);
     Q_UNUSED(image);
     QEglContext *context = ensureContext(widget);
     if (context) {
         if (needToSwap) {
             if (!isPaintingActive)
                 context->makeCurrent(windowSurface);
             context->swapBuffers(windowSurface);
             context->lazyDoneCurrent();
         } else if (isPaintingActive) {
             vgFlush();
             context->lazyDoneCurrent();
         }
         isPaintingActive = false;
     }
 }

◆ ensureContext()

QEglContext * QVGEGLWindowSurfaceDirect::ensureContext ( QWidget * widget )

virtual

Implements QVGEGLWindowSurfacePrivate.

Definition at line 627 of file qwindowsurface_vgegl.cpp.

Referenced by beginPaint(), endPaint(), and scroll().

 {
     QSize newSize = windowSurfaceSize(widget);
     QEglProperties surfaceProps;
 
 #if defined(QVG_RECREATE_ON_SIZE_CHANGE)
 #if !defined(QVG_NO_SINGLE_CONTEXT)
     if (context && size != newSize) {
         // The surface size has changed, so we need to recreate it.
         // We can keep the same context and paint engine.
         size = newSize;
         if (isPaintingActive)
             context->doneCurrent();
         context->destroySurface(windowSurface);
 #if defined(EGL_VG_ALPHA_FORMAT_PRE_BIT)
         if (isPremultipliedContext(context)) {
             surfaceProps.setValue
                 (EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_PRE);
         } else {
             surfaceProps.removeValue(EGL_VG_ALPHA_FORMAT);
         }
 #endif
         windowSurface = context->createSurface(widget, &surfaceProps);
         isPaintingActive = false;
         needToSwap = true;
     }
 #else
     if (context && size != newSize) {
         // The surface size has changed, so we need to recreate
         // the EGL context for the widget.  We also need to recreate
         // the surface's paint engine if context sharing is not
         // enabled because we cannot reuse the existing paint objects
         // in the new context.
         qt_vg_destroy_paint_engine(engine);
         engine = 0;
         context->destroySurface(windowSurface);
         qt_vg_destroy_context(context, QInternal::Widget);
         context = 0;
         windowSurface = EGL_NO_SURFACE;
     }
 #endif
 #endif
     if (!context) {
         // Create a new EGL context and bind it to the widget surface.
         size = newSize;
         context = qt_vg_create_context(widget, QInternal::Widget);
         if (!context)
             return 0;
         // We want a direct to window rendering surface if possible.
 #if defined(QVG_DIRECT_TO_WINDOW)
         surfaceProps.setValue(EGL_RENDER_BUFFER, EGL_SINGLE_BUFFER);
 #endif
 #if defined(EGL_VG_ALPHA_FORMAT_PRE_BIT)
         if (isPremultipliedContext(context)) {
             surfaceProps.setValue
                 (EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_PRE);
         } else {
             surfaceProps.removeValue(EGL_VG_ALPHA_FORMAT);
         }
 #endif
         EGLSurface surface = context->createSurface(widget, &surfaceProps);
         if (surface == EGL_NO_SURFACE) {
             qt_vg_destroy_paint_engine(engine);
             engine = 0;
             qt_vg_destroy_context(context, QInternal::Widget);
             context = 0;
             return 0;
         }
         needToSwap = true;
 #if defined(QVG_DIRECT_TO_WINDOW)
         // Did we get a direct to window rendering surface?
         EGLint buffer = 0;
         if (eglQueryContext(QEgl::display(), context->context(),
                             EGL_RENDER_BUFFER, &buffer) &&
                 buffer == EGL_SINGLE_BUFFER) {
             needToSwap = false;
         }
 #endif
         windowSurface = surface;
         isPaintingActive = false;
     }
 
 #if !defined(QVG_NO_PRESERVED_SWAP)
     // Try to force the surface back buffer to preserve its contents.
     if (needToSwap) {
         bool succeeded = eglSurfaceAttrib(QEgl::display(), windowSurface,
                 EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
         if (!succeeded && eglGetError() != EGL_SUCCESS) {
             qWarning("QVG: could not enable preserved swap");
         }
     }
 #endif
     return context;
 }

◆ scroll()

bool QVGEGLWindowSurfaceDirect::scroll	(	QWidget *	widget,
		const QRegion &	area,
		int	dx,
		int	dy
	)

virtual

Reimplemented from QVGEGLWindowSurfacePrivate.

Definition at line 760 of file qwindowsurface_vgegl.cpp.

 {
 #ifdef QVG_BUFFER_SCROLLING
     QEglContext *context = ensureContext(widget);
     if (context) {
         context->makeCurrent(windowSurface);
         QRect scrollRect = area.boundingRect();
         int sx = scrollRect.x();
         int sy = size.height() - scrollRect.y() - scrollRect.height();
         vgSeti(VG_SCISSORING, VG_FALSE);
         vgCopyPixels(sx + dx, sy - dy, sx, sy, scrollRect.width(), scrollRect.height());
         context->lazyDoneCurrent();
         return true;
     }
 #else
     Q_UNUSED(widget);
     Q_UNUSED(area);
     Q_UNUSED(dx);
     Q_UNUSED(dy);
 #endif
     return false;
 }

◆ supportsStaticContents()

bool QVGEGLWindowSurfaceDirect::supportsStaticContents ( ) const

virtual

Reimplemented from QVGEGLWindowSurfacePrivate.

Definition at line 751 of file qwindowsurface_vgegl.cpp.

 {
 #if defined(QVG_BUFFER_SCROLLING) && !defined(QVG_NO_PRESERVED_SWAP)
     return true;
 #else
     return QVGEGLWindowSurfacePrivate::supportsStaticContents();
 #endif
 }