void tst_QRegion::setRects()
{
{
QRegion region;
region.setRects( 0, 0 );
QVERIFY( region.rects().isEmpty() );
}
{
QRegion region;
QRect rect;
region.setRects( &rect, 0 );
QVERIFY(region.isEmpty());
QVERIFY(region == QRegion());
QVERIFY(!region.boundingRect().isValid());
QVERIFY(region.rects().isEmpty());
}
{
QRegion region;
QRect rect;
region.setRects( &rect, 1 );
QVERIFY( !region.boundingRect().isValid() );
QVERIFY( region.rects().isEmpty() );
}
{
QRegion region;
QRect rect( 10, -20, 30, 40 );
region.setRects( &rect, 1 );
QCOMPARE( region.rects().count(), 1 );
QCOMPARE( region.rects()[0], rect );
}
}
/*!
\reimp
*/
void QTransformedScreen::solidFill(const QColor &color, const QRegion ®ion)
{
const QRegion tr = mapToDevice(region, QSize(w,h));
Q_ASSERT(tr.boundingRect() == mapToDevice(region.boundingRect(), QSize(w,h)));
#ifdef QT_REGION_DEBUG
qDebug() << "QTransformedScreen::solidFill region" << region << "transformed" << tr;
#endif
QProxyScreen::solidFill(color, tr);
}
/*!
Called when the user clicks in the \c Maximize region.
\a widget is the widget to be maximized.
The default behaviour is to resize the widget to be full-screen.
This method can be overridden e.g. to allow room for launch
panels.
*/
void QWSDecoration::maximize( QWidget *widget )
{
QRect nr;
// find out how much space the decoration needs
extern QRect qt_maxWindowRect;
QRect desk = qt_maxWindowRect;
/*
#ifdef QPE_WM_LOOK_AND_FEEL
if (wmStyle == QtEmbedded_WMStyle) {
QRect dummy( 0, 0, desk.width(), 1 );
QRegion r = region(widget, dummy, Title);
QRect rect = r.boundingRect();
nr = QRect(desk.x(), desk.y()-rect.y(),
desk.width(), desk.height() - rect.height());
} else
#endif
*/
{
QRect dummy( 0, 0, 1, 1);
QRegion r = region(widget, dummy);
if (r.isEmpty()) {
nr = desk;
} else {
QRect rect = r.boundingRect();
nr = QRect(desk.x()-rect.x(), desk.y()-rect.y(),
desk.width() - (rect.width()==1 ? 0 : rect.width()), // ==1 -> dummy
desk.height() - (rect.height()==1 ? 0 : rect.height()));
}
}
widget->setGeometry(nr);
}
void QXcbNativeBackingStore::resize(const QSize &size, const QRegion &staticContents)
{
if (size == m_pixmap.size())
return;
QPixmap newPixmap(size);
#if QT_CONFIG(xrender)
if (m_translucentBackground && newPixmap.depth() != 32)
qt_x11Pixmap(newPixmap)->convertToARGB32();
#endif
if (!m_pixmap.isNull()) {
Pixmap from = qt_x11PixmapHandle(m_pixmap);
Pixmap to = qt_x11PixmapHandle(newPixmap);
QRect br = staticContents.boundingRect().intersected(QRect(QPoint(0, 0), size));
if (!br.isEmpty()) {
GC gc = XCreateGC(display(), to, 0, Q_NULLPTR);
XCopyArea(display(), from, to, gc, br.x(), br.y(), br.width(), br.height(), br.x(), br.y());
XFreeGC(display(), gc);
}
}
m_pixmap = newPixmap;
}
void SubtitleScreen::OptimiseDisplayedArea(void)
{
if (!m_refreshArea)
return;
QRegion visible;
QListIterator<MythUIType *> i(m_ChildrenList);
while (i.hasNext())
{
MythUIType *img = i.next();
visible = visible.united(img->GetArea());
}
if (visible.isEmpty())
return;
QRect bounding = visible.boundingRect();
bounding = bounding.translated(m_safeArea.topLeft());
bounding = m_safeArea.intersected(bounding);
int left = m_safeArea.left() - bounding.left();
int top = m_safeArea.top() - bounding.top();
SetArea(MythRect(bounding));
i.toFront();;
while (i.hasNext())
{
MythUIType *img = i.next();
img->SetArea(img->GetArea().translated(left, top));
}
}
bool QRasterWindowSurface::scroll(const QRegion &area, int dx, int dy)
{
#ifdef Q_WS_WIN
Q_D(QRasterWindowSurface);
if (!d->image || !d->image->hdc)
return false;
QRect rect = area.boundingRect();
BitBlt(d->image->hdc, rect.x()+dx, rect.y()+dy, rect.width(), rect.height(),
d->image->hdc, rect.x(), rect.y(), SRCCOPY);
return true;
#else
Q_D(QRasterWindowSurface);
if (!d->image || d->image->image.isNull())
return false;
#if defined(Q_WS_X11) && !defined(QT_NO_MITSHM)
syncX();
#endif
const QVector<QRect> rects = area.rects();
for (int i = 0; i < rects.size(); ++i)
qt_scrollRectInImage(d->image->image, rects.at(i), QPoint(dx, dy));
return true;
#endif
}
void QX11WindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
{
if (d_ptr->device.isNull())
return;
QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
QRegion wrgn(rgn);
QRect br = rgn.boundingRect();
if (!wOffset.isNull())
wrgn.translate(-wOffset);
QRect wbr = wrgn.boundingRect();
int num;
XRectangle *rects = (XRectangle *)qt_getClipRects(wrgn, num);
if (num <= 0)
return;
// 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;
if (num != 1)
XSetClipRectangles(X11->display, gc, 0, 0, rects, num, YXBanded);
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());
if (num != 1)
XSetClipMask(X11->display, gc, XNone);
}
void QXcbBackingStore::flush(QWindow *window, const QRegion ®ion, const QPoint &offset)
{
if (!m_image || m_image->size().isEmpty())
return;
QSize imageSize = m_image->size();
QRegion clipped = region;
clipped &= QRect(0, 0, window->width(), window->height());
clipped &= QRect(0, 0, imageSize.width(), imageSize.height()).translated(-offset);
QRect bounds = clipped.boundingRect();
if (bounds.isNull())
return;
Q_XCB_NOOP(connection());
QXcbWindow *platformWindow = static_cast<QXcbWindow *>(window->handle());
QVector<QRect> rects = clipped.rects();
for (int i = 0; i < rects.size(); ++i)
m_image->put(platformWindow->xcb_window(), rects.at(i).topLeft(), rects.at(i).translated(offset));
Q_XCB_NOOP(connection());
if (m_syncingResize) {
xcb_flush(xcb_connection());
connection()->sync();
m_syncingResize = false;
platformWindow->updateSyncRequestCounter();
}
}
void TilePainter::drawStamp(const TileLayer *stamp,
const QRegion &drawRegion)
{
Q_ASSERT(stamp);
if (stamp->bounds().isEmpty())
return;
const QRegion region = paintableRegion(drawRegion);
if (region.isEmpty())
return;
const int w = stamp->width();
const int h = stamp->height();
const QRect regionBounds = region.boundingRect();
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 int stampX = (_x - regionBounds.left()) % w;
const int stampY = (_y - regionBounds.top()) % h;
const Cell &cell = stamp->cellAt(stampX, stampY);
if (cell.isEmpty())
continue;
mTileLayer->setCell(_x - mTileLayer->x(),
_y - mTileLayer->y(),
cell);
}
}
}
mMapDocument->emitRegionChanged(region);
}
void QWidgetPrivate::updateFrameStrut()
{
Q_Q(QWidget);
if(!q->isVisible() || (q->windowType() == Qt::Desktop)) {
data.fstrut_dirty = q->isVisible();
return;
}
#ifndef QT_NO_QWS_MANAGER
if (extra && extra->topextra && extra->topextra->qwsManager) {
QTLWExtra *topextra = extra->topextra;
const QRect oldFrameStrut = topextra->frameStrut;
const QRect contents = data.crect;
QRegion r = localRequestedRegion().translated(contents.topLeft());
r += extra->topextra->qwsManager->region();
const QRect frame = r.boundingRect();
topextra->frameStrut.setCoords(contents.left() - frame.left(),
contents.top() - frame.top(),
frame.right() - contents.right(),
frame.bottom() - contents.bottom());
topextra->qwsManager->repaintRegion(QDecoration::All, QDecoration::Normal);
}
#endif
data.fstrut_dirty = false;
}
bool EraseTiles::mergeWith(const QUndoCommand *other) {
const EraseTiles *o = static_cast<const EraseTiles*>(other);
if (!(mMapEditor == o->mMapEditor &&
mTileLayer == o->mTileLayer &&
o->mMergeable))
return false;
const QRegion combinedRegion = mRegion.united(o->mRegion);
if (mRegion != combinedRegion) {
const QRect bounds = mRegion.boundingRect();
const QRect combinedBounds = combinedRegion.boundingRect();
//resize the erased tiles layer when necessary
if (bounds != combinedBounds) {
const QPoint shift = bounds.topLeft() - combinedBounds.topLeft();
mErasedCells->resize(combinedBounds.size(), shift);
}
//copy the newly erased tiles over
const QRect otherBounds = o->mRegion.boundingRect();
const QPoint pos = otherBounds.topLeft() - combinedBounds.topLeft();
mErasedCells->merge(pos, o->mErasedCells);
mRegion = combinedRegion;
}
return true;
}
void QXcbWindowSurface::flush(QWidget *widget, const QRegion ®ion, const QPoint &offset)
{
QRect bounds = region.boundingRect();
if (size().isEmpty() || !geometry().contains(bounds))
return;
Q_XCB_NOOP(connection());
QXcbWindow *window = static_cast<QXcbWindow *>(widget->window()->platformWindow());
extern QWidgetData* qt_widget_data(QWidget *);
QPoint widgetOffset = qt_qwidget_data(widget)->wrect.topLeft();
QVector<QRect> rects = region.rects();
for (int i = 0; i < rects.size(); ++i)
m_image->put(window->window(), rects.at(i).topLeft() - widgetOffset, rects.at(i).translated(offset));
Q_XCB_NOOP(connection());
if (m_syncingResize) {
xcb_flush(xcb_connection());
connection()->sync();
m_syncingResize = false;
window->updateSyncRequestCounter();
}
}
void StatusBar::onVolumeButtonsPressed()
{
QRegion region = visibleRegion();
if (region.isEmpty())
{
return;
}
QRect visible_rect = region.boundingRect();
if (visible_rect.width() < height() && visible_rect.height() < height())
{
return;
}
VolumeControlDialog * dialog = volumeDialog(true);
if (!dialog->isVisible())
{
dialog->ensureVisible();
onyx::screen::instance().updateWidget(0, onyx::screen::ScreenProxy::GU, false, onyx::screen::ScreenCommand::WAIT_COMMAND_FINISH);
}
else
{
dialog->resetTimer();
}
}
//! Clears the complex on the specified region. Please observe that the actually cleared region
//! consists of all lattice cells intersecting the passed region, therefore resulting in a cleared region
//! typically larger than passed one, up to the lattice granularity.
void TCacheResource::clear(QRegion region)
{
if (!m_region.intersects(region))
return;
//Get the region bbox
TRect bbox(toTRect(region.boundingRect()));
//For all cells intersecting the bbox
TPoint initialPos(getCellPos(bbox.getP00()));
TPoint pos;
for (pos.x = initialPos.x; pos.x <= bbox.x1; pos.x += latticeStep)
for (pos.y = initialPos.y; pos.y <= bbox.y1; pos.y += latticeStep) {
QRect cellQRect(toQRect(TRect(pos, TDimension(latticeStep, latticeStep))));
if (region.intersects(cellQRect) && m_region.intersects(cellQRect)) {
//Release the associated cell from cache and clear the cell from the content region.
TImageCache::instance()->remove(getCellCacheId(pos));
m_region -= cellQRect;
--m_cellsCount;
//DIAGNOSTICS_GLOADD("crCellsCnt", -1);
//Release the cell from m_cellDatas
m_cellDatas[getCellIndex(pos)].m_modified = true;
}
}
if (m_region.isEmpty()) {
m_tileType = NONE;
m_locksCount = 0;
}
}
void QQnxWindow::post(const QRegion &dirty)
{
// How double-buffering works
// --------------------------
//
// The are two buffers, the previous one and the current one.
// The previous buffer always contains the complete, full image of the whole window when it
// was last posted.
// The current buffer starts with the complete, full image of the second to last posting
// of the window.
//
// During painting, Qt paints on the current buffer. Thus, when Qt has finished painting, the
// current buffer contains the second to last image plus the newly painted regions.
// Since the second to last image is too old, we copy over the image from the previous buffer, but
// only for those regions that Qt didn't paint (because that would overwrite what Qt has just
// painted). This is the copyPreviousToCurrent() call below.
//
// After the call to copyPreviousToCurrent(), the current buffer contains the complete, full image of the
// whole window in its current state, and we call screen_post_window() to make the new buffer
// available to libscreen (called "posting"). There, only the regions that Qt painted on are
// posted, as nothing else has changed.
//
// After that, the previous and the current buffers are swapped, and the whole cycle starts anew.
// Check if render buffer exists and something was rendered
if (m_currentBufferIndex != -1 && !dirty.isEmpty()) {
qWindowDebug() << Q_FUNC_INFO << "window =" << window();
QQnxBuffer ¤tBuffer = m_buffers[m_currentBufferIndex];
// Copy unmodified region from old render buffer to new render buffer;
// required to allow partial updates
QRegion preserve = m_previousDirty - dirty - m_scrolled;
blitPreviousToCurrent(preserve, 0, 0);
// Calculate region that changed
QRegion modified = preserve + dirty + m_scrolled;
QRect rect = modified.boundingRect();
int dirtyRect[4] = { rect.x(), rect.y(), rect.x() + rect.width(), rect.y() + rect.height() };
// Update the display with contents of render buffer
errno = 0;
int result = screen_post_window(m_window, currentBuffer.nativeBuffer(), 1, dirtyRect, 0);
if (result != 0)
qFatal("QQnxWindow: failed to post window buffer, errno=%d", errno);
// Advance to next nender buffer
m_previousBufferIndex = m_currentBufferIndex++;
if (m_currentBufferIndex >= MAX_BUFFER_COUNT)
m_currentBufferIndex = 0;
// Save modified region and clear scrolled region
m_previousDirty = dirty;
m_scrolled = QRegion();
// Notify screen that window posted
if (m_screen != 0)
m_screen->onWindowPost(this);
}
}
void QWindowsBackingStore::flush(QWindow *window, const QRegion ®ion,
const QPoint &offset)
{
Q_ASSERT(window);
const QRect br = region.boundingRect();
if (QWindowsContext::verbose > 1)
qCDebug(lcQpaBackingStore) << __FUNCTION__ << this << window << offset << br;
QWindowsWindow *rw = QWindowsWindow::baseWindowOf(window);
#ifndef Q_OS_WINCE
const bool hasAlpha = rw->format().hasAlpha();
const Qt::WindowFlags flags = window->flags();
if ((flags & Qt::FramelessWindowHint) && QWindowsWindow::setWindowLayered(rw->handle(), flags, hasAlpha, rw->opacity()) && hasAlpha) {
// Windows with alpha: Use blend function to update.
QRect r = window->frameGeometry();
QPoint frameOffset(window->frameMargins().left(), window->frameMargins().top());
QRect dirtyRect = br.translated(offset + frameOffset);
SIZE size = {r.width(), r.height()};
POINT ptDst = {r.x(), r.y()};
POINT ptSrc = {0, 0};
BLENDFUNCTION blend = {AC_SRC_OVER, 0, (BYTE)(255.0 * rw->opacity()), AC_SRC_ALPHA};
if (QWindowsContext::user32dll.updateLayeredWindowIndirect) {
RECT dirty = {dirtyRect.x(), dirtyRect.y(),
dirtyRect.x() + dirtyRect.width(), dirtyRect.y() + dirtyRect.height()};
UPDATELAYEREDWINDOWINFO info = {sizeof(info), NULL, &ptDst, &size, m_image->hdc(), &ptSrc, 0, &blend, ULW_ALPHA, &dirty};
QWindowsContext::user32dll.updateLayeredWindowIndirect(rw->handle(), &info);
} else {
QWindowsContext::user32dll.updateLayeredWindow(rw->handle(), NULL, &ptDst, &size, m_image->hdc(), &ptSrc, 0, &blend, ULW_ALPHA);
}
} else {
#endif
const HDC dc = rw->getDC();
if (!dc) {
qErrnoWarning("%s: GetDC failed", __FUNCTION__);
return;
}
if (!BitBlt(dc, br.x(), br.y(), br.width(), br.height(),
m_image->hdc(), br.x() + offset.x(), br.y() + offset.y(), SRCCOPY)) {
const DWORD lastError = GetLastError(); // QTBUG-35926, QTBUG-29716: may fail after lock screen.
if (lastError != ERROR_SUCCESS && lastError != ERROR_INVALID_HANDLE)
qErrnoWarning(lastError, "%s: BitBlt failed", __FUNCTION__);
}
rw->releaseDC();
#ifndef Q_OS_WINCE
}
#endif
// Write image for debug purposes.
if (QWindowsContext::verbose > 2 && lcQpaBackingStore().isDebugEnabled()) {
static int n = 0;
const QString fileName = QString::fromLatin1("win%1_%2.png").
arg(rw->winId()).arg(n++);
m_image->image().save(fileName);
qCDebug(lcQpaBackingStore) << "Wrote " << m_image->image().size() << fileName;
}
}
void TrackView::paintTrack(QStylePainter &painter, const QRegion ®ion, int track)
{
const QRect &rect = region.boundingRect();
int firstRow = qBound(0, getRowFromPhysicalY(qMax(rect.top(), topMarginHeight)), getRows() - 1);
int lastRow = qBound(0, getRowFromPhysicalY(qMax(rect.bottom(), topMarginHeight)), getRows() - 1);
QRect selection = getSelection();
const SyncTrack *t = getTrack(track);
for (int row = firstRow; row <= lastRow; ++row) {
QRect patternDataRect(getPhysicalX(track), getPhysicalY(row), trackWidth, rowHeight);
if (!region.intersects(patternDataRect))
continue;
const SyncTrack::TrackKey *key = t->getPrevKeyFrame(row);
SyncTrack::TrackKey::KeyType interpolationType = key ? key->type : SyncTrack::TrackKey::STEP;
bool selected = selection.contains(track, row);
QBrush baseBrush = bgBaseBrush;
QBrush darkBrush = bgDarkBrush;
if (selected) {
baseBrush = selectBaseBrush;
darkBrush = selectDarkBrush;
}
QBrush bgBrush = (row % 8 == 0) ? darkBrush : baseBrush;
QRect fillRect = patternDataRect;
painter.fillRect(fillRect, bgBrush);
if (row % 8 == 0) {
painter.setPen(selected ? rowSelectPen : rowPen);
painter.drawLine(QPointF(patternDataRect.left() + 0.5, patternDataRect.top() + 0.5),
QPointF(patternDataRect.right() + 0.5, patternDataRect.top() + 0.5));
}
if (interpolationType != SyncTrack::TrackKey::STEP) {
painter.setPen(getInterpolationPen(interpolationType));
painter.drawLine(QPoint(patternDataRect.right(), patternDataRect.top() + 1),
QPoint(patternDataRect.right(), patternDataRect.bottom()));
}
if (row == editRow && track == editTrack) {
QRectF selectRect = QRectF(patternDataRect).adjusted(0.5, 0.5, -0.5, -0.5);
painter.setPen(QColor(0, 0, 0));
painter.drawRect(selectRect);
}
painter.setPen(selected ?
palette().color(QPalette::HighlightedText) :
palette().color(QPalette::WindowText));
painter.drawText(patternDataRect, t->isKeyFrame(row) ?
QString::number(t->getKeyFrame(row).value, 'f', 2) :
" ---");
}
}
void EditorTools::onRemoveHorizontalLinesClicked(){
if(editor->editorView()->selectedImage()){
QRegion selected = editor->editorView()->selectedRegion();
/* Do vertical averaging */
/* simplify selection */
QRect rect = selected.boundingRect();
editor->editorView()->selectedImage()->removeHorizontalLines(rect);
}
}
void
DBusInputContextConnection::updateInputMethodArea(const QRegion ®ion)
{
ComMeegoInputmethodInputcontext1Interface *proxy = mProxys.value(activeConnection);
if (proxy) {
QRect rect = region.boundingRect();
proxy->updateInputMethodArea(rect.x(), rect.y(), rect.width(), rect.height());
}
}
// Fill in the background. This is only called if there is some area of
// the screen that is not covered with other visibles.
void MHIContext::DrawBackground(const QRegion ®)
{
if (reg.isEmpty())
return;
QRect bounds = reg.boundingRect();
DrawRect(bounds.x(), bounds.y(), bounds.width(), bounds.height(),
MHRgba(0, 0, 0, 255)/* black. */);
}
void QWebFrameAdapter::renderRelativeCoords(QPainter* painter, int layers, const QRegion& clip)
{
GraphicsContext context(painter);
if (context.paintingDisabled() && !context.updatingControlTints())
return;
if (!frame->view() || !frame->contentRenderer())
return;
QVector<QRect> vector = clip.rects();
if (vector.isEmpty())
return;
WebCore::FrameView* view = frame->view();
view->updateLayoutAndStyleIfNeededRecursive();
if (layers & ContentsLayer) {
QRect clipBoundingRect = clip.boundingRect();
coalesceRectsIfPossible(clipBoundingRect, vector);
for (int i = 0; i < vector.size(); ++i) {
const QRect& clipRect = vector.at(i);
QRect rect = clipRect.intersected(view->frameRect());
context.save();
painter->setClipRect(clipRect, Qt::IntersectClip);
int x = view->x();
int y = view->y();
int scrollX = view->scrollX();
int scrollY = view->scrollY();
context.translate(x, y);
rect.translate(-x, -y);
context.translate(-scrollX, -scrollY);
rect.translate(scrollX, scrollY);
context.clip(view->visibleContentRect());
view->paintContents(&context, rect);
context.restore();
}
#if USE(ACCELERATED_COMPOSITING)
renderCompositedLayers(&context, IntRect(clipBoundingRect));
#endif
}
renderFrameExtras(&context, layers, clip);
#if ENABLE(INSPECTOR)
if (frame->page()->inspectorController()->highlightedNode()) {
context.save();
frame->page()->inspectorController()->drawHighlight(context);
context.restore();
}
#endif
}
void BlurEffect::paintEffectFrame(EffectFrame *frame, QRegion region, double opacity, double frameOpacity)
{
const QRect screen = effects->virtualScreenGeometry();
bool valid = target->valid() && shader && shader->isValid();
QRegion shape = frame->geometry().adjusted(-5, -5, 5, 5) & screen;
if (valid && !shape.isEmpty() && region.intersects(shape.boundingRect()) && frame->style() != EffectFrameNone) {
doBlur(shape, screen, opacity * frameOpacity);
}
effects->paintEffectFrame(frame, region, opacity, frameOpacity);
}
void QVFbWindowSurface::flush(QWidget *widget, const QRegion ®ion, const QPoint &offset)
{
Q_UNUSED(widget);
Q_UNUSED(offset);
// QRect rect = geometry();
// QPoint topLeft = rect.topLeft();
mScreen->setDirty(region.boundingRect());
}
QPoint LDesktop::findNewPluginLocation(QRegion avail, QSize winsize){
//This just searches through the region of available space until it find the first location where it
// will fit without overlapping anything else (scanning left->right, top->bottom)
//return QPoint(-1,-1); //just for testing
QRect bounds = avail.boundingRect();
//qDebug() << "Bounds:" << bounds;
if(bounds.width()<winsize.width() || bounds.height()<winsize.height()){ return QPoint(-1,-1); }
QPoint pt = bounds.topLeft(); //start in upper-left corner
bool found = false;
if(DEBUG){ qDebug() << "Check Availability:" << bounds << winsize; }
while(pt.y()+winsize.height() < bounds.bottom() && !found){
int dy = winsize.height()/2;
while(pt.x()+winsize.width() < bounds.right() && !found){
//Check the horizontal position (incrementing as necessary)
QRegion intersect = avail.intersected(QRect(pt, winsize)); // full intersection
if(DEBUG){ qDebug() << "Check X:" << pt << " - Inter:" << intersect.boundingRect(); }
if(intersect.boundingRect().size()==winsize && intersect.rects().length()==1 ){ found = true; } //use this point
else{
QRect inter = avail.intersected(QRect(pt, QSize(winsize.width(),1))).boundingRect(); //1D intersection in X-dir
int dx = winsize.width() - inter.width();
if(dx>0 && inter.left() > pt.x()){ pt.setX( inter.left() ); }
else if(inter.width()==0){ pt.setX( pt.x()+winsize.width() ); }
else{ pt.setX( pt.x()+inter.width() ); }
//Also adjust the dy value to the smallest amount
inter = avail.intersected(QRect(pt, QSize(1,winsize.height()))).boundingRect(); //1D intersection in X-dir
int ddy = inter.y()-pt.y();
if(ddy < dy && ddy>0){ dy = ddy; }
}
}
if(!found){
//Nothing in the horizontal direction - increment the vertical dimension
pt.setX( bounds.left() ); //reset back to the left-most edge
pt.setY( pt.y()+dy );
if(DEBUG){ qDebug() << "Check Y:" << pt << dy; }
}
}
//qDebug() << "Found Point:" << found << pt;
if(!found){ return QPoint(-1,-1); } //no space found - return an invalid point
else{ return pt; }
}
void TeletextScreen::OptimiseDisplayedArea(void)
{
VideoOutput *vo = m_player->GetVideoOutput();
if (!vo)
return;
MythPainter *osd_painter = vo->GetOSDPainter();
if (!osd_painter)
return;
QHashIterator<int, QImage*> it(m_rowImages);
while (it.hasNext())
{
it.next();
MythImage* image = osd_painter->GetFormatImage();
if (!image || !it.value())
continue;
int row = it.key();
image->Assign(*(it.value()));
MythUIImage *uiimage = new MythUIImage(this, QString("ttrow%1")
.arg(row));
if (uiimage)
{
uiimage->SetImage(image);
uiimage->SetArea(MythRect(0, row * m_rowHeight,
m_safeArea.width(), m_rowHeight * 2));
}
}
QRegion visible;
QListIterator<MythUIType *> i(m_ChildrenList);
while (i.hasNext())
{
MythUIType *img = i.next();
visible = visible.united(img->GetArea());
}
if (visible.isEmpty())
return;
QRect bounding = visible.boundingRect();
bounding = bounding.translated(m_safeArea.topLeft());
bounding = m_safeArea.intersected(bounding);
int left = m_safeArea.left() - bounding.left();
int top = m_safeArea.top() - bounding.top();
SetArea(MythRect(bounding));
i.toFront();;
while (i.hasNext())
{
MythUIType *img = i.next();
img->SetArea(img->GetArea().translated(left, top));
}
}
void QMultiScreen::setDirty(const QRect &rect)
{
const int n = d_ptr->screens.size();
for (int i = 0; i < n; ++i) {
QScreen *screen = d_ptr->screens.at(i);
const QRegion r = screen->region() & rect;
if (r.isEmpty())
continue;
screen->setDirty(r.boundingRect());
}
}
void QD3DWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
{
QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
QDirect3DPaintEngine *engine = qt_d3dEngine();
LPDIRECT3DSWAPCHAIN9 swapchain = engine->swapChain(d_ptr->m_widget);
if (swapchain) {
QRect br = rgn.boundingRect();
QRect wbr = br.translated(-wOffset);
RECT destrect;
destrect.left = wbr.x();
destrect.top = wbr.y();
destrect.right = destrect.left + wbr.width();
destrect.bottom = destrect.top + wbr.height();
RECT srcrect;
srcrect.left = br.x() + offset.x();
srcrect.top = br.y() + offset.y();
srcrect.right = wbr.width() + srcrect.left;
srcrect.bottom = wbr.height() + srcrect.top;
int devwidth = d_ptr->m_lastSize.width();
int devheight = d_ptr->m_lastSize.height();
if (devwidth <= srcrect.right) {
int diff = srcrect.right - devwidth;
srcrect.right -= diff;
destrect.right -= diff;
if (srcrect.right <= srcrect.left)
return;
}
if (devheight <= srcrect.bottom) {
int diff = srcrect.bottom - devheight;
srcrect.bottom -= diff;
destrect.bottom -= diff;
if (srcrect.bottom <= srcrect.top)
return;
}
if (FAILED(swapchain->Present(&srcrect, &destrect, widget->winId(), 0, 0)))
qWarning("QDirect3DPaintEngine: failed to present back buffer.");
#ifdef D3D_DEBUG_BACKBUFFER
qDebug() << widget << srcrect.left << srcrect.top << wbr.width() << wbr.height() << "Dest: " << destrect.left << destrect.top;
IDirect3DSurface9 *surface;
swapchain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &surface);
QString filename("C:\\test.bmp");
D3DXSaveSurfaceToFile(filename.utf16(), D3DXIFF_BMP, surface, 0, 0);
surface->Release();
#endif
}
}
void QPicturePaintEngine::updateClipRegion(const QRegion ®ion, Qt::ClipOperation op)
{
Q_D(QPicturePaintEngine);
#ifdef QT_PICTURE_DEBUG
qDebug() << " -> updateClipRegion(): op:" << op
<< "bounding rect:" << region.boundingRect();
#endif
int pos;
SERIALIZE_CMD(QPicturePrivate::PdcSetClipRegion);
d->s << region << qint8(op);
writeCmdLength(pos, QRectF(), false);
}
void QWindowsBackingStore::flush(QWindow *window, const QRegion ®ion,
const QPoint &offset)
{
Q_ASSERT(window);
const QRect br = region.boundingRect();
if (QWindowsContext::verboseBackingStore > 1)
qDebug() << __FUNCTION__ << window << offset << br;
QWindowsWindow *rw = QWindowsWindow::baseWindowOf(window);
#ifndef Q_OS_WINCE
if (rw->format().hasAlpha() && (window->flags() & Qt::FramelessWindowHint)) {
const long wl = GetWindowLong(rw->handle(), GWL_EXSTYLE);
if ((wl & WS_EX_LAYERED) == 0)
SetWindowLong(rw->handle(), GWL_EXSTYLE, wl | WS_EX_LAYERED);
QRect r = window->frameGeometry();
QPoint frameOffset(window->frameMargins().left(), window->frameMargins().top());
QRect dirtyRect = br.translated(offset + frameOffset);
SIZE size = {r.width(), r.height()};
POINT ptDst = {r.x(), r.y()};
POINT ptSrc = {0, 0};
BLENDFUNCTION blend = {AC_SRC_OVER, 0, (BYTE)(255.0 * rw->opacity()), AC_SRC_ALPHA};
RECT dirty = {dirtyRect.x(), dirtyRect.y(),
dirtyRect.x() + dirtyRect.width(), dirtyRect.y() + dirtyRect.height()};
UPDATELAYEREDWINDOWINFO info = {sizeof(info), NULL, &ptDst, &size, m_image->hdc(), &ptSrc, 0, &blend, ULW_ALPHA, &dirty};
QWindowsContext::user32dll.updateLayeredWindowIndirect(rw->handle(), &info);
} else {
#endif
const HDC dc = rw->getDC();
if (!dc) {
qErrnoWarning("%s: GetDC failed", __FUNCTION__);
return;
}
if (!BitBlt(dc, br.x(), br.y(), br.width(), br.height(),
m_image->hdc(), br.x() + offset.x(), br.y() + offset.y(), SRCCOPY))
qErrnoWarning("%s: BitBlt failed", __FUNCTION__);
rw->releaseDC();
#ifndef Q_OS_WINCE
}
#endif
// Write image for debug purposes.
if (QWindowsContext::verboseBackingStore > 2) {
static int n = 0;
const QString fileName = QString::fromLatin1("win%1_%2.png").
arg(rw->winId()).arg(n++);
m_image->image().save(fileName);
qDebug() << "Wrote " << m_image->image().size() << fileName;
}
}
void LDesktop::UpdateDesktopPluginArea(){
QRegion visReg( bgWindow->geometry() ); //visible region (not hidden behind a panel)
QRect rawRect = visReg.boundingRect(); //initial value (screen size)
for(int i=0; i<PANELS.length(); i++){
QRegion shifted = visReg;
QString loc = settings->value(PANELS[i]->prefix()+"location","top").toString().toLower();
int vis = PANELS[i]->visibleWidth();
if(loc=="top"){
if(!shifted.contains(QRect(rawRect.x(), rawRect.y(), rawRect.width(), vis))){ continue; }
shifted.translate(0, (rawRect.top()+vis)-shifted.boundingRect().top() );
}else if(loc=="bottom"){
if(!shifted.contains(QRect(rawRect.x(), rawRect.bottom()-vis, rawRect.width(), vis))){ continue; }
shifted.translate(0, (rawRect.bottom()-vis)-shifted.boundingRect().bottom());
}else if(loc=="left"){
if( !shifted.contains(QRect(rawRect.x(), rawRect.y(), vis,rawRect.height())) ){ continue; }
shifted.translate((rawRect.left()+vis)-shifted.boundingRect().left() ,0);
}else{ //right
if(!shifted.contains(QRect(rawRect.right()-vis, rawRect.y(), vis,rawRect.height())) ){ continue; }
shifted.translate((rawRect.right()-vis)-shifted.boundingRect().right(),0);
}
visReg = visReg.intersected( shifted );
}
//Now make sure the desktop plugin area is only the visible area
QRect rec = visReg.boundingRect();
//LSession::handle()->XCB->SetScreenWorkArea((unsigned int) desktopnumber, rec);
//Now remove the X offset to place it on the current screen (needs widget-coords, not global)
globalWorkRect = rec; //save this for later
rec.moveTopLeft( QPoint( rec.x()-desktop->screenGeometry(desktopnumber).x() , rec.y() ) );
//qDebug() << "DPlug Area:" << rec.x() << rec.y() << rec.width() << rec.height();
if(rec == bgDesktop->geometry()){return; } //nothing changed
bgDesktop->setGeometry( rec );
bgDesktop->setBackground( QBrush(Qt::NoBrush) );
bgDesktop->update();
//Re-paint the panels (just in case a plugin was underneath it and the panel is transparent)
for(int i=0; i<PANELS.length(); i++){ PANELS[i]->update(); }
//Also need to re-arrange any desktop plugins to ensure that nothing is out of the screen area
AlignDesktopPlugins();
//Make sure to re-disable any WM control flags
LSession::handle()->XCB->SetDisableWMActions(bgWindow->winId());
}