QPaintEngine* QX11GLPixmapData::paintEngine() const
{
// We need to create the context before beginPaint - do it here:
if (!ctx) {
ctx = new QGLContext(glFormat());
if (ctx->d_func()->eglContext == 0)
ctx->d_func()->eglContext = new QEglContext();
ctx->d_func()->eglContext->openDisplay(0); // ;-)
ctx->d_func()->eglContext->setApi(QEgl::OpenGL);
ctx->d_func()->eglContext->setContext(hasAlphaChannel() ? qPixmapARGBSharedEglContext
: qPixmapRGBSharedEglContext);
}
if (!qt_gl2_engine_for_pixmaps)
qt_gl2_engine_for_pixmaps = new QGL2PaintEngineEx();
// Support multiple painters on multiple pixmaps simultaniously
if (qt_gl2_engine_for_pixmaps->isActive()) {
qWarning("Pixmap paint engine already active");
QPaintEngine* engine = new QGL2PaintEngineEx();
engine->setAutoDestruct(true);
return engine;
}
return qt_gl2_engine_for_pixmaps;
}
void ProjectWidgetItemDelegate::paint ( QPainter * painter,
const QStyleOptionViewItem & option,
const QModelIndex & index ) const
{
if (index.isValid() && !index.parent().isValid())
{
QModelIndex modifiedIndex = index.sibling(index.row(), ProjectWidget::TAG_COLUMN);
QStyleOptionViewItemV4 modifiedOption(option);
modifiedOption.rect.setX(option.decorationSize.width());
int width = option.fontMetrics.width(modifiedIndex.data().toString())
+ option.decorationSize.width();
QPaintEngine* paintEngine = painter->paintEngine();
if (paintEngine != 0)
{
QPaintDevice* paintDevice = paintEngine->paintDevice();
width = paintDevice->width();
}
modifiedOption.rect.setWidth(width);
QItemDelegate::paint(painter, modifiedOption, modifiedIndex);
return;
}
QItemDelegate::paint(painter, option, index);
}
QImage ImageBufferDataPrivateUnaccelerated::toQImage() const
{
QPaintEngine* paintEngine = m_pixmap.paintEngine();
if (!paintEngine || paintEngine->type() != QPaintEngine::Raster)
return m_pixmap.toImage();
// QRasterPixmapData::toImage() will deep-copy the backing QImage if there's an active QPainter on it.
// For performance reasons, we don't want that here, so we temporarily redirect the paint engine.
QPaintDevice* currentPaintDevice = paintEngine->paintDevice();
paintEngine->setPaintDevice(0);
QImage image = m_pixmap.toImage();
paintEngine->setPaintDevice(currentPaintDevice);
return image;
}
bool tst_QStaticText::supportsTransformations() const
{
QPixmap pm(10, 10);
QPainter p(&pm);
QPaintEngine *engine = p.paintEngine();
QPaintEngine::Type type = engine->type();
if (type == QPaintEngine::OpenGL
#if !defined(Q_WS_WIN) && !defined(Q_WS_X11) && !defined(Q_WS_MAC)
|| type == QPaintEngine::Raster
#endif
)
return false;
return true;
}
void QSystemTrayIconSys::paintEvent(QPaintEvent*)
{
QPainter p(this);
if (!getSysTrayVisualInfo()) {
const QRegion oldSystemClip = p.paintEngine()->systemClip();
const QRect clearedRect = oldSystemClip.boundingRect();
XClearArea(QX11Info::display(), winId(), clearedRect.x(), clearedRect.y(),
clearedRect.width(), clearedRect.height(), False);
QPaintEngine *pe = p.paintEngine();
pe->setSystemClip(clearedRect);
q->icon().paint(&p, rect());
pe->setSystemClip(oldSystemClip);
} else {
p.setCompositionMode(QPainter::CompositionMode_Source);
p.fillRect(rect(), Qt::transparent);
p.setCompositionMode(QPainter::CompositionMode_SourceOver);
q->icon().paint(&p, rect());
}
}
/*! \reimp */
QPaintEngine *QGLFramebufferObject::paintEngine() const
{
Q_D(const QGLFramebufferObject);
if (d->engine)
return d->engine;
#if !defined(QT_OPENGL_ES_1)
#if !defined (QT_OPENGL_ES_2)
if (qt_gl_preferGL2Engine()) {
#endif
QPaintEngine *engine = qt_buffer_2_engine();
if (engine->isActive() && engine->paintDevice() != this) {
d->engine = new QGL2PaintEngineEx;
return d->engine;
}
return engine;
#if !defined (QT_OPENGL_ES_2)
}
#endif
#endif
#if !defined(QT_OPENGL_ES_2)
QPaintEngine *engine = qt_buffer_engine();
if (engine->isActive() && engine->paintDevice() != this) {
d->engine = new QOpenGLPaintEngine;
return d->engine;
}
return engine;
#endif
}
static void setAntialiasing(QPainter *painter, bool on)
{
QPaintEngine *engine = painter->paintEngine();
if ( engine && engine->hasFeature(QPaintEngine::Antialiasing) )
painter->setRenderHint(QPainter::Antialiasing, on);
}
QPixmap transition(const QPixmap &from, const QPixmap &to, qreal amount)
{
if (from.isNull() && to.isNull()) {
return from;
}
if (qFuzzyCompare(amount + 1, qreal(1.0))) {
return from;
}
QRect startRect(from.rect());
QRect targetRect(to.rect());
QSize pixmapSize = startRect.size().expandedTo(targetRect.size());
QRect toRect = QRect(QPoint(0,0), pixmapSize);
targetRect.moveCenter(toRect.center());
startRect.moveCenter(toRect.center());
//paint to in the center of from
QColor color;
color.setAlphaF(amount);
// If the native paint engine supports Porter/Duff compositing and CompositionMode_Plus
QPaintEngine *paintEngine = from.paintEngine();
if (paintEngine &&
paintEngine->hasFeature(QPaintEngine::PorterDuff) &&
paintEngine->hasFeature(QPaintEngine::BlendModes)) {
QPixmap startPixmap(pixmapSize);
startPixmap.fill(Qt::transparent);
QPixmap targetPixmap(pixmapSize);
targetPixmap.fill(Qt::transparent);
QPainter p;
p.begin(&targetPixmap);
p.drawPixmap(targetRect, to);
p.setCompositionMode(QPainter::CompositionMode_DestinationIn);
p.fillRect(targetRect, color);
p.end();
p.begin(&startPixmap);
p.drawPixmap(startRect, from);
p.setCompositionMode(QPainter::CompositionMode_DestinationOut);
p.fillRect(startRect, color);
p.setCompositionMode(QPainter::CompositionMode_Plus);
p.drawPixmap(targetRect, targetPixmap);
p.end();
return startPixmap;
}
#if defined(Q_WS_X11) && defined(HAVE_XRENDER)
// We have Xrender support
else if (paintEngine && paintEngine->hasFeature(QPaintEngine::PorterDuff)) {
// QX11PaintEngine doesn't implement CompositionMode_Plus in Qt 4.3,
// which we need to be able to do a transition from one pixmap to
// another.
//
// In order to avoid the overhead of converting the pixmaps to images
// and doing the operation entirely in software, this function has a
// specialized path for X11 that uses Xrender directly to do the
// transition. This operation can be fully accelerated in HW.
//
// This specialization can be removed when QX11PaintEngine supports
// CompositionMode_Plus.
QPixmap source(targetPixmap), destination(startPixmap);
source.detach();
destination.detach();
Display *dpy = QX11Info::display();
XRenderPictFormat *format = XRenderFindStandardFormat(dpy, PictStandardA8);
XRenderPictureAttributes pa;
pa.repeat = 1; // RepeatNormal
// Create a 1x1 8 bit repeating alpha picture
Pixmap pixmap = XCreatePixmap(dpy, destination.handle(), 1, 1, 8);
Picture alpha = XRenderCreatePicture(dpy, pixmap, format, CPRepeat, &pa);
XFreePixmap(dpy, pixmap);
// Fill the alpha picture with the opacity value
XRenderColor xcolor;
xcolor.alpha = quint16(0xffff * amount);
XRenderFillRectangle(dpy, PictOpSrc, alpha, &xcolor, 0, 0, 1, 1);
// Reduce the alpha of the destination with 1 - opacity
XRenderComposite(dpy, PictOpOutReverse, alpha, None, destination.x11PictureHandle(),
0, 0, 0, 0, 0, 0, destination.width(), destination.height());
// Add source * opacity to the destination
XRenderComposite(dpy, PictOpAdd, source.x11PictureHandle(), alpha,
destination.x11PictureHandle(),
toRect.x(), toRect.y(), 0, 0, 0, 0, destination.width(), destination.height());
XRenderFreePicture(dpy, alpha);
return destination;
}
#endif
else {
// Fall back to using QRasterPaintEngine to do the transition.
QImage under(pixmapSize, QImage::Format_ARGB32_Premultiplied);
under.fill(Qt::transparent);
QImage over(pixmapSize, QImage::Format_ARGB32_Premultiplied);
over.fill(Qt::transparent);
QPainter p;
p.begin(&over);
p.drawPixmap(targetRect, to);
p.setCompositionMode(QPainter::CompositionMode_DestinationIn);
p.fillRect(over.rect(), color);
p.end();
p.begin(&under);
p.drawPixmap(startRect, from);
p.setCompositionMode(QPainter::CompositionMode_DestinationOut);
p.fillRect(startRect, color);
p.setCompositionMode(QPainter::CompositionMode_Plus);
p.drawImage(toRect.topLeft(), over);
p.end();
return QPixmap::fromImage(under);
}
}
void WindowSurfaceImpl::updateSurfaceData()
{
// If painting is active, i.e. beginPaint has been called
// surface data is not updated
if(mPaintingStarted)
{
return;
}
QWindowSurface* surface = mMainSurface.widget->windowSurface();
// If window surface is null it means that the widget has been
// sent to background and widget's window surface has been deleted,
// in such case create own QImage as local surface in order to support
// rendering in background
if(surface == NULL)
{
// check if we already have local surface with valid size
if(!isLocalSurfaceValid())
{
// incase we have invalid surface delete the current one
// and create new
if(mMainSurface.localSurfaceInUse)
{
deleteLocalSurface();
}
createLocalSurface();
// set info
mMainSurface.qSurface = NULL;
mMainSurface.device = mMainSurface.localSurface;
mMainSurface.type = WsTypeQtImage;
mMainSurface.localSurfaceInUse = true;
return;
}
else
{
// We have valid local surface so make sure its active and return
mMainSurface.localSurfaceInUse = true;
return;
}
}
else
{
// We got Qt's window surface, so in case we had local surface in use
// delete it as it's not used anymore
if(mMainSurface.localSurfaceInUse)
{
// in case we have needed the local surface as temp
// buffer for a client, it is not deleted as we most likely
// will need it again. In any case the local surface
// stops to be the main surface and is atleast demoted to
// temp surface.
if(!mPreserveLocalSurface)
{
deleteLocalSurface();
}
}
}
// We got window surface so extract information
QPaintDevice* device = surface->paintDevice();
QPaintEngine* engine = NULL;
// If the device is active it means that some painter is attached to the widget,
// if not then we attach our own painter to do the job
if(device->paintingActive())
{
engine = device->paintEngine();
}
else
{
mPainter.begin(device);
engine = mPainter.paintEngine();
}
// determine the surface type based on the engine used
// as Qt does not provide exact info of the surface type
switch (engine->type())
{
case QPaintEngine::OpenVG:
// surface is EGL window surface
mMainSurface.type = WsTypeEglSurface;
break;
case QPaintEngine::Raster:
mMainSurface.type = WsTypeSymbianBitmap;
if(device->devType() == QInternal::Pixmap)
{
QPixmap* pixmap = static_cast<QPixmap*>(device);
mMainSurface.symbianBitmap = pixmap->toSymbianCFbsBitmap();
}
else
{
throw GfxException(EGfxErrorIllegalArgument, "Unsupported device type");
}
break;
default:
throw GfxException(EGfxErrorIllegalArgument, "Unsupported widget window surface type");
}
// release painter if its active
if(mPainter.isActive())
{
mPainter.end();
}
mMainSurface.qSurface = surface;
mMainSurface.device = device;
mMainSurface.localSurfaceInUse = false;
}
void QWidgetBackingStore::showYellowThing(QWidget *widget, const QRegion &toBePainted, int msec, bool unclipped)
{
QRegion paintRegion = toBePainted;
QRect widgetRect = widget->rect();
if (!widget->internalWinId()) {
QWidget *nativeParent = widget->nativeParentWidget();
const QPoint offset = widget->mapTo(nativeParent, QPoint(0, 0));
paintRegion.translate(offset);
widgetRect.translate(offset);
widget = nativeParent;
}
//flags to fool painter
bool paintUnclipped = widget->testAttribute(Qt::WA_PaintUnclipped);
if (unclipped && !widget->d_func()->paintOnScreen())
widget->setAttribute(Qt::WA_PaintUnclipped);
const bool setFlag = !widget->testAttribute(Qt::WA_WState_InPaintEvent);
if (setFlag)
widget->setAttribute(Qt::WA_WState_InPaintEvent);
//setup the engine
QPaintEngine *pe = widget->paintEngine();
if (pe) {
pe->setSystemClip(paintRegion);
{
QPainter p(widget);
p.setClipRegion(paintRegion);
static int i = 0;
switch (i) {
case 0:
p.fillRect(widgetRect, QColor(255,255,0));
break;
case 1:
p.fillRect(widgetRect, QColor(255,200,55));
break;
case 2:
p.fillRect(widgetRect, QColor(200,255,55));
break;
case 3:
p.fillRect(widgetRect, QColor(200,200,0));
break;
}
i = (i+1) & 3;
p.end();
}
}
if (setFlag)
widget->setAttribute(Qt::WA_WState_InPaintEvent, false);
//restore
widget->setAttribute(Qt::WA_PaintUnclipped, paintUnclipped);
if (pe)
pe->setSystemClip(QRegion());
QApplication::syncX();
::usleep(1000 * msec);
}
