void QRendererVideoWidgetBackend::paintEvent(QPaintEvent *event)
{
QPainter painter(m_widget);
if (m_widget->testAttribute(Qt::WA_OpaquePaintEvent)) {
QRegion borderRegion = event->region();
borderRegion = borderRegion.subtracted(m_boundingRect);
QBrush brush = m_widget->palette().window();
QVector<QRect> rects = borderRegion.rects();
for (QVector<QRect>::iterator it = rects.begin(), end = rects.end(); it != end; ++it) {
painter.fillRect(*it, brush);
}
}
if (m_surface->isActive() && m_boundingRect.intersects(event->rect())) {
m_surface->paint(&painter, m_boundingRect, m_sourceRect);
m_surface->setReady(true);
} else {
#if !defined(QT_NO_OPENGL) && !defined(QT_OPENGL_ES_1_CL) && !defined(QT_OPENGL_ES_1)
if (m_updatePaintDevice && (painter.paintEngine()->type() == QPaintEngine::OpenGL
|| painter.paintEngine()->type() == QPaintEngine::OpenGL2)) {
m_updatePaintDevice = false;
m_surface->setGLContext(const_cast<QGLContext *>(QGLContext::currentContext()));
if (m_surface->supportedShaderTypes() & QPainterVideoSurface::GlslShader) {
m_surface->setShaderType(QPainterVideoSurface::GlslShader);
} else {
m_surface->setShaderType(QPainterVideoSurface::FragmentProgramShader);
}
}
#endif
}
}
void WharfIcon::set(const char *icon, const char *msg)
{
const QIconSet *icons = Icon(icon);
if (icons == NULL)
return;
QPixmap *nvis = new QPixmap(icons->pixmap(QIconSet::Large, QIconSet::Normal));
if (bActivated){
resize(nvis->width(), nvis->height());
move((p_width - nvis->width()) / 2, (p_height - nvis->height()) / 2);
}
if (msg){
QPixmap msgPict = Pict(msg);
QRegion *rgn = NULL;
if (nvis->mask() && msgPict.mask()){
rgn = new QRegion(*msgPict.mask());
rgn->translate(nvis->width() - msgPict.width() - SMALL_PICT_OFFS,
nvis->height() - msgPict.height() - SMALL_PICT_OFFS);
*rgn += *nvis->mask();
}
QPainter p;
p.begin(nvis);
p.drawPixmap(nvis->width() - msgPict.width() - SMALL_PICT_OFFS,
nvis->height() - msgPict.height() - SMALL_PICT_OFFS, msgPict);
p.end();
if (rgn){
setMask(*rgn);
delete rgn;
}
}else{
const QBitmap *mask = nvis->mask();
if (mask) setMask(*mask);
}
if (vis) delete vis;
vis = nvis;
setIcon(*vis);
repaint();
}
void QWSLocalMemSurface::setGeometry(const QRect &rect)
{
QSize size = rect.size();
QWidget *win = window();
if (win && !win->mask().isEmpty()) {
const QRegion region = win->mask()
& rect.translated(-win->geometry().topLeft());
size = region.boundingRect().size();
}
uchar *deleteLater = 0;
// In case of a Hide event we need to delete the memory after sending the
// event to the server in order to let the server animate the event.
if (size.isEmpty()) {
deleteLater = mem;
mem = 0;
}
if (img.size() != size) {
delete[] mem;
if (size.isEmpty()) {
mem = 0;
img = QImage();
} else {
const QImage::Format format = preferredImageFormat(win);
const int bpl = nextMulOf4(bytesPerPixel(format) * size.width());
const int memsize = bpl * size.height();
mem = new uchar[memsize];
img = QImage(mem, size.width(), size.height(), bpl, format);
setImageMetrics(img, win);
}
}
QWSWindowSurface::setGeometry(rect);
delete[] deleteLater;
}
void BlurEffect::updateBlurRegion(EffectWindow *w) const
{
QRegion region;
const QByteArray value = w->readProperty(net_wm_blur_region, XCB_ATOM_CARDINAL, 32);
if (value.size() > 0 && !(value.size() % (4 * sizeof(unsigned long)))) {
const unsigned long *cardinals = reinterpret_cast<const unsigned long*>(value.constData());
for (unsigned int i = 0; i < value.size() / sizeof(unsigned long);) {
int x = cardinals[i++];
int y = cardinals[i++];
int w = cardinals[i++];
int h = cardinals[i++];
region += QRect(x, y, w, h);
}
}
if (region.isEmpty() && !value.isNull()) {
// Set the data to a dummy value.
// This is needed to be able to distinguish between the value not
// being set, and being set to an empty region.
w->setData(WindowBlurBehindRole, 1);
} else
w->setData(WindowBlurBehindRole, region);
}
bool QX11WindowSurface::scroll(const QRegion &area, int dx, int dy)
{
QRect rect = area.boundingRect();
if (d_ptr->device.isNull())
return false;
GC gc = XCreateGC(X11->display, d_ptr->device.handle(), 0, 0);
XCopyArea(X11->display, d_ptr->device.handle(), d_ptr->device.handle(), gc,
rect.x(), rect.y(), rect.width(), rect.height(),
rect.x()+dx, rect.y()+dy);
XFreeGC(X11->display, gc);
return true;
}
void tst_qregion::intersects_data()
{
QTest::addColumn<QRegion>("region");
QTest::addColumn<QRect>("rect");
QRegion region(0, 0, 100, 100);
QRegion complexRegion;
complexRegion = complexRegion.united(QRect(0, 0, 100, 100));
complexRegion = complexRegion.united(QRect(120, 20, 100, 100));
{
QRect rect(0, 0, 100, 100);
QTest::newRow("same -- simple") << region << rect;
}
{
QRect rect(10, 10, 10, 10);
QTest::newRow("inside -- simple") << region << rect;
}
{
QRect rect(110, 110, 10, 10);
QTest::newRow("outside -- simple") << region << rect;
}
{
QRect rect(0, 0, 100, 100);
QTest::newRow("same -- complex") << complexRegion << rect;
}
{
QRect rect(10, 10, 10, 10);
QTest::newRow("inside -- complex") << complexRegion << rect;
}
{
QRect rect(110, 110, 10, 10);
QTest::newRow("outside -- complex") << complexRegion << rect;
}
}
void UIFrameBufferQImage::paintSeamless(QPaintEvent *pEvent)
{
/* Get rectangle to paint: */
QRect paintRect = pEvent->rect().intersected(m_img.rect());
if (paintRect.isEmpty())
return;
/* Create painter: */
QPainter painter(m_pMachineView->viewport());
/* Determine the region to erase: */
lock();
QRegion regionToErase = (QRegion)paintRect - m_syncVisibleRegion;
unlock();
if (!regionToErase.isEmpty())
{
/* Optimize composition-mode: */
painter.setCompositionMode(QPainter::CompositionMode_Clear);
/* Erase required region, slowly, rectangle-by-rectangle: */
foreach (const QRect &rect, regionToErase.rects())
painter.eraseRect(rect);
/* Restore composition-mode: */
painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
}
void QXlibWindowSurface::beginPaint(const QRegion ®ion)
{
Q_UNUSED(region);
resizeBuffer(size());
if (shm_img.hasAlphaChannel()) {
QPainter p(&shm_img);
p.setCompositionMode(QPainter::CompositionMode_Source);
const QVector<QRect> rects = region.rects();
const QColor blank = Qt::transparent;
for (QVector<QRect>::const_iterator it = rects.begin(); it != rects.end(); ++it) {
p.fillRect(*it, blank);
}
}
}
void CannonField::moveShot()
{
QRegion region = shotRect();
++timerCount;
QRect shotR = shotRect();
if(shotR.intersects(targetRect()))
{
autoShootTimer->stop();
emit hit();
}
else if(shotR.x() > width() || shotR.y() > height())
{
autoShootTimer->stop();
emit missed();
}
else
{
region = region.unite(shotR);
}
update(region);
return;
}
bool QXcbNativeBackingStore::scroll(const QRegion &area, int dx, int dy)
{
if (m_pixmap.isNull())
return false;
QRect rect = area.boundingRect();
Pixmap pix = qt_x11PixmapHandle(m_pixmap);
GC gc = XCreateGC(display(), pix, 0, Q_NULLPTR);
XCopyArea(display(), pix, pix, gc,
rect.x(), rect.y(), rect.width(), rect.height(),
rect.x()+dx, rect.y()+dy);
XFreeGC(display(), gc);
return true;
}
bool MainWindow::eventFilter(QObject* obj, QEvent* event)
{
if (this->customStyleLoaded && obj == this->ui->grip)
{
if (event->type() == QEvent::MouseButtonPress && static_cast<QMouseEvent*>(event)->button() == Qt::LeftButton)
{
this->dragPosition = static_cast<QMouseEvent*>(event)->globalPos() - frameGeometry().topLeft();
}
if (event->type() == QEvent::MouseButtonRelease && static_cast<QMouseEvent*>(event)->button() == Qt::LeftButton)
{
this->dragPosition = QPoint();
}
else if (event->type() == QEvent::MouseMove && !this->isMaximized() && static_cast<QMouseEvent*>(event)->buttons() & Qt::LeftButton && !this->dragPosition.isNull())
{
move(static_cast<QMouseEvent*>(event)->globalPos() - this->dragPosition);
}
else if (event->type() == QEvent::Resize)
{
const QRegion maskedRegion(0, 0, this->ui->grip->width(), this->ui->grip->width());
if (this->isMaximized())
this->ui->grip->setMask(maskedRegion);
else
{
const QRegion cornerTopRight = QRegion(this->ui->grip->width() - WINDOW_BORDER_RADIUS, 0, WINDOW_BORDER_RADIUS, WINDOW_BORDER_RADIUS).subtracted(QRegion(this->ui->grip->width() - 2 * WINDOW_BORDER_RADIUS, 0, 2 * WINDOW_BORDER_RADIUS, 2 * WINDOW_BORDER_RADIUS, QRegion::Ellipse));
this->ui->grip->setMask(maskedRegion.subtracted(cornerTopRight));
}
}
else if (event->type() == QEvent::MouseButtonDblClick && static_cast<QMouseEvent*>(event)->button() == Qt::LeftButton)
{
this->maximize();
}
}
return QMainWindow::eventFilter(obj, event);
}
void TilePainter::drawCells(int x, int y, TileLayer *tileLayer)
{
const QRegion region = paintableRegion(x, y,
tileLayer->width(),
tileLayer->height());
if (region.isEmpty())
return;
foreach (const QRect &rect, region.rects()) {
for (int _x = rect.left(); _x <= rect.right(); ++_x) {
for (int _y = rect.top(); _y <= rect.bottom(); ++_y) {
const Cell &cell = tileLayer->cellAt(_x - x, _y - y);
if (cell.isEmpty())
continue;
mTileLayer->setCell(_x - mTileLayer->x(),
_y - mTileLayer->y(),
cell);
}
}
}
mMapDocument->emitRegionChanged(region);
}
virtual void frameRectsChanged()
{
if (!platformWidget())
return;
IntRect windowRect = convertToContainingWindow(IntRect(0, 0, frameRect().width(), frameRect().height()));
platformWidget()->setGeometry(windowRect);
ScrollView* parentScrollView = parent();
if (!parentScrollView)
return;
ASSERT(parentScrollView->isFrameView());
IntRect clipRect(static_cast<FrameView*>(parentScrollView)->windowClipRect());
clipRect.move(-windowRect.x(), -windowRect.y());
clipRect.intersect(platformWidget()->rect());
QRegion clipRegion = QRegion(clipRect);
platformWidget()->setMask(clipRegion);
// if setMask is set with an empty QRegion, no clipping will
// be performed, so in that case we hide the platformWidget
platformWidget()->setVisible(!clipRegion.isEmpty());
}
void Bullet::moveShot(){
cout << "moveShot" << endl;
QRegion region = shotRect();
QRect shotR = shotRect();
/*if (battleField->isHit(shotR)) return;
else {
region = region.united(shotR);
}*/
battleField->isHit(shotR);
if (battleField->invaderArmy->isHit(shotR)){
battleField->autoShootTimer->stop();
return;
}
else if(shotR.y() < 0){
cout << "MISSED" << endl;
battleField->autoShootTimer->stop();
}
else region = region.united(shotR);
update(region);
}
bool QS60WindowSurface::scroll(const QRegion &area, int dx, int dy)
{
QRect rect = area.boundingRect();
if (dx == 0 && dy == 0)
return false;
if (d_ptr->device.isNull())
return false;
QS60PixmapData *data = static_cast<QS60PixmapData*>(d_ptr->device.data_ptr().data());
data->scroll(dx, dy, rect);
return true;
}
void ThumbnailAsideEffect::paintScreen( int mask, QRegion region, ScreenPaintData& data )
{
effects->paintScreen( mask, region, data );
foreach( const Data& d, windows )
{
if( region.contains( d.rect ))
{
WindowPaintData data( d.window );
data.opacity = opacity;
QRect region;
setPositionTransformations( data, region, d.window, d.rect, Qt::KeepAspectRatio );
effects->drawWindow( d.window, PAINT_WINDOW_OPAQUE | PAINT_WINDOW_TRANSLUCENT | PAINT_WINDOW_TRANSFORMED,
region, data );
}
}
}
void QFbWindow::repaint(const QRegion ®ion)
{
QRect currentGeometry = geometry();
QRect dirtyClient = region.boundingRect();
QRect dirtyRegion(currentGeometry.left() + dirtyClient.left(),
currentGeometry.top() + dirtyClient.top(),
dirtyClient.width(),
dirtyClient.height());
QRect mOldGeometryLocal = mOldGeometry;
mOldGeometry = currentGeometry;
// If this is a move, redraw the previous location
if (mOldGeometryLocal != currentGeometry)
platformScreen()->setDirty(mOldGeometryLocal);
platformScreen()->setDirty(dirtyRegion);
}
// Convert QRegion to XserverRegion. All code uses XserverRegion
// only when really necessary as the shared implementation uses
// QRegion.
XserverRegion toXserverRegion(QRegion region)
{
QVector< QRect > rects = region.rects();
XRectangle* xr = new XRectangle[ rects.count()];
for (int i = 0;
i < rects.count();
++i) {
xr[ i ].x = rects[ i ].x();
xr[ i ].y = rects[ i ].y();
xr[ i ].width = rects[ i ].width();
xr[ i ].height = rects[ i ].height();
}
XserverRegion ret = XFixesCreateRegion(display(), xr, rects.count());
delete[] xr;
return ret;
}
WangId WangFiller::wangIdFromSurroundings(const TileLayer &back,
const QRegion &fillRegion,
QPoint point) const
{
Cell surroundingCells[8];
QPoint adjacentPoints[8];
getSurroundingPoints(point, mStaggeredRenderer, mStaggerAxis, adjacentPoints);
for (int i = 0; i < 8; ++i) {
if (!fillRegion.contains(adjacentPoints[i]))
surroundingCells[i] = back.cellAt(adjacentPoints[i]);
}
return mWangSet->wangIdFromSurrounding(surroundingCells);
}
/*!
\reimp
*/
QRegion QTransformedScreen::mapToDevice(const QRegion &rgn, const QSize &s) const
{
if (d_ptr->transformation == None)
return QProxyScreen::mapToDevice(rgn, s);
#ifdef QT_REGION_DEBUG
qDebug() << "mapToDevice size" << s << "rgn: " << rgn;
#endif
QRect tr;
QRegion trgn;
QVector<QRect> a = rgn.rects();
const QRect *r = a.data();
int w = s.width();
int h = s.height();
int size = a.size();
switch (d_ptr->transformation) {
case None:
break;
case Rot90:
for (int i = 0; i < size; i++, r++) {
tr.setCoords(r->y(), w - r->x() - 1,
r->bottom(), w - r->right() - 1);
trgn |= correctNormalized(tr);
}
break;
case Rot180:
for (int i = 0; i < size; i++, r++) {
tr.setCoords(w - r->x() - 1, h - r->y() - 1,
w - r->right() - 1, h - r->bottom() - 1);
trgn |= correctNormalized(tr);
}
break;
case Rot270:
for (int i = 0; i < size; i++, r++) {
tr.setCoords(h - r->y() - 1, r->x(),
h - r->bottom() - 1, r->right());
trgn |= correctNormalized(tr);
}
break;
}
#ifdef QT_REGION_DEBUG
qDebug() << "mapToDevice trgn: " << trgn;
#endif
return trgn;
}
void QX11WindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
{
if (d_ptr->device.isNull())
return;
#ifndef Q_FLATTEN_EXPOSE
extern void *qt_getClipRects(const QRegion &r, int &num); // in qpaintengine_x11.cpp
extern QWidgetData* qt_widget_data(QWidget *);
QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
GC gc = XCreateGC(X11->display, d_ptr->device.handle(), 0, 0);
QRegion wrgn(rgn);
QRect br = rgn.boundingRect();
if (!wOffset.isNull())
wrgn.translate(-wOffset);
QRect wbr = wrgn.boundingRect();
// #### why dirty widget here? should be up to date already
// if (br.right() + offset.x() >= d_ptr->device.size().width() || br.bottom() + offset.y() >= d_ptr->device.size().height()) {
// // QRegion dirty = rgn - QRect(-offset, d_ptr->device.size());
// // qDebug() << dirty;
// widget->d_func()->dirtyWidget_sys(rgn - QRect(-offset, d_ptr->device.size()));
// }
int num;
XRectangle *rects = (XRectangle *)qt_getClipRects(wrgn, num);
// qDebug() << "XSetClipRectangles";
// for (int i = 0; i < num; ++i)
// qDebug() << " " << i << rects[i].x << rects[i].x << rects[i].y << rects[i].width << rects[i].height;
XSetClipRectangles(X11->display, gc, 0, 0, rects, num, YXBanded);
#else
Q_UNUSED(rgn);
XGCValues values;
values.subwindow_mode = IncludeInferiors;
GC gc = XCreateGC(X11->display, d_ptr->device.handle(), GCSubwindowMode, &values);
#endif
XSetGraphicsExposures(X11->display, gc, False);
// XFillRectangle(X11->display, widget->handle(), gc, 0, 0, widget->width(), widget->height());
#ifndef Q_FLATTEN_EXPOSE
XCopyArea(X11->display, d_ptr->device.handle(), widget->handle(), gc,
br.x() + offset.x(), br.y() + offset.y(), br.width(), br.height(), wbr.x(), wbr.y());
#else
Q_ASSERT(widget->isWindow());
XCopyArea(X11->display, d_ptr->device.handle(), widget->handle(), gc,
offset.x(), offset.y(), widget->width(), widget->height(), 0, 0);
#endif
XFreeGC(X11->display, gc);
}
void QXcbBackingStore::beginPaint(const QRegion ®ion)
{
if (!m_image)
return;
m_image->preparePaint(region);
if (m_image->image()->hasAlphaChannel()) {
QPainter p(m_image->image());
p.setCompositionMode(QPainter::CompositionMode_Source);
const QVector<QRect> rects = region.rects();
const QColor blank = Qt::transparent;
for (QVector<QRect>::const_iterator it = rects.begin(); it != rects.end(); ++it) {
p.fillRect(*it, blank);
}
}
}
void PerftestLinuxFbScreen::exposeRegion(QRegion region, int windowIndex)
{
if (QPerformanceLog::enabled()) {
QWSWindow *changed = 0;
if (windowIndex >= 0 && QWSServer::instance() && QWSServer::instance()->clientWindows().count() > windowIndex)
changed = QWSServer::instance()->clientWindows().at(windowIndex);
if(changed && !changed->client()->identity().isEmpty()) {
QRect r = region.boundingRect();
QPerformanceLog()
<< changed->client()->identity()
<< ": expose_region"
<< QString("QRect(%1,%2 %3x%4)").arg(r.left()).arg(r.top()).arg(r.width()).arg(r.height());
}
}
return QLinuxFbScreen::exposeRegion(region, windowIndex);
}
/*!
Invalidates the \a rgn (in widget's coordinates) of the backing store, i.e.
all widgets intersecting with the region will be repainted when the backing store
is synced.
### Qt 4.6: Merge into a template function (after MSVC isn't supported anymore).
*/
void QWidgetPrivate::invalidateBuffer(const QRegion &rgn)
{
Q_Q(QWidget);
QTLWExtra *tlwExtra = q->window()->d_func()->maybeTopData();
if (discardInvalidateBufferRequest(q, tlwExtra) || rgn.isEmpty())
return;
QRegion wrgn(rgn);
wrgn &= clipRect();
if (!graphicsEffect && extra && extra->hasMask)
wrgn &= extra->mask;
if (wrgn.isEmpty())
return;
tlwExtra->backingStore->markDirty(wrgn, q, false, true);
}
void QDirectFBWindowSurface::flush(QWidget *widget, const QRegion ®ion,
const QPoint &offset)
{
QWidget *win = window();
if (!win)
return;
#if !defined(QT_NO_QWS_PROXYSCREEN) && !defined(QT_NO_GRAPHICSVIEW)
QWExtra *extra = qt_widget_private(widget)->extraData();
if (extra && extra->proxyWidget)
return;
#else
Q_UNUSED(widget);
#endif
const quint8 windowOpacity = quint8(win->windowOpacity() * 0xff);
const QRect windowGeometry = geometry();
#ifdef QT_DIRECTFB_WM
quint8 currentOpacity;
Q_ASSERT(dfbWindow);
dfbWindow->GetOpacity(dfbWindow, ¤tOpacity);
if (currentOpacity != windowOpacity) {
dfbWindow->SetOpacity(dfbWindow, windowOpacity);
}
screen->flipSurface(dfbSurface, flipFlags, region, offset);
#else
setOpaque(windowOpacity == 0xff);
if (mode == Offscreen) {
screen->exposeRegion(region.translated(offset + geometry().topLeft()), 0);
} else {
screen->flipSurface(dfbSurface, flipFlags, region, offset);
}
#endif
#ifdef QT_DIRECTFB_TIMING
enum { Secs = 3 };
++frames;
if (timer.elapsed() >= Secs * 1000) {
qDebug("%d fps", int(double(frames) / double(Secs)));
frames = 0;
timer.restart();
}
#endif
flushPending = false;
}
// ### copied from qwindowsurface_raster.cpp -- should be cross-platform
void QWSMemorySurface::beginPaint(const QRegion &rgn)
{
if (!isWidgetOpaque(window())) {
QPainter p(&img);
p.setCompositionMode(QPainter::CompositionMode_Source);
const QVector<QRect> rects = rgn.rects();
const QColor blank = Qt::transparent;
for (QVector<QRect>::const_iterator it = rects.begin(); it != rects.end(); ++it) {
QRect r = *it;
#ifdef Q_BACKINGSTORE_SUBSURFACES
r.translate(painterOffset());
#endif
p.fillRect(r, blank);
}
}
QWSWindowSurface::beginPaint(rgn);
}
void RegionEditDialog::setRegion(const QRegion &aValue)
{
while (ui->itemsLayout->count()>0)
{
delete ui->itemsLayout->takeAt(0)->widget();
}
QVector<QRect> aRects=aValue.rects();
for (int i=0; i<aRects.count(); ++i)
{
on_addButton_clicked();
((RectFrame *)ui->itemsLayout->itemAt(i)->widget())->setValue(aRects.at(i));
}
updateCountButtons();
}
bool QVGEGLWindowSurfaceDirect::scroll(QWidget *widget, const QRegion& area, int dx, int dy)
{
#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;
}
#endif
return false;
}
void QX11GLWindowSurface::flush(QWidget *widget, const QRegion &widgetRegion, const QPoint &offset)
{
// 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);
}
bool PaintTilelayer::mergeWith(const QUndoCommand *other) {
const PaintTilelayer *o = static_cast<const PaintTilelayer*>(other);
if (!(mMapEditor == o->mMapEditor &&
mTarget == o->mTarget &&
o->mMergeable))
return false;
const QRegion newRegion = o->mPaintedRegion.subtracted(mPaintedRegion);
const QRegion combinedRegion = mPaintedRegion.united(o->mPaintedRegion);
const QRect bounds = QRect(mX, mY, mSource->width(), mSource->height());
const QRect combinedBounds = combinedRegion.boundingRect();
//resize the erased tiles and source layers when necessary
if (bounds != combinedBounds) {
const QPoint shift = bounds.topLeft() - combinedBounds.topLeft();
mErased->resize(combinedBounds.size(), shift);
mSource->resize(combinedBounds.size(), shift);
}
mX = combinedBounds.left();
mY = combinedBounds.top();
mPaintedRegion = combinedRegion;
// Copy the painted tiles from the other command over
const QPoint pos = QPoint(o->mX, o->mY) - combinedBounds.topLeft();
mSource->merge(pos, o->mSource);
// Copy the newly erased tiles from the other command over
foreach (const QRect &rect, newRegion.rects())
for (int y = rect.top(); y <= rect.bottom(); ++y)
for (int x = rect.left(); x <= rect.right(); ++x)
mErased->setCell(x - mX,
y - mY,
o->mErased->cellAt(x - o->mX, y - o->mY));
return true;
}