qwidgetbackingstore.cpp

Jenkins

Absolute File Name:

/home/qt/qt5_coco/qt5/qtbase/src/widgets/kernel/qwidgetbackingstore.cpp

Line

Source

Count

extern QRegion qt_dirtyRegion(QWidget *);

namespace { namespace Q_QGS_qt_dummy_platformTextureList { typedef QPlatformTextureList Type; QBasicAtomicInt guard = { QtGlobalStatic::Uninitialized }; __attribute__((visibility("hidden"))) inline Type *innerFunction() { struct HolderBase { ~HolderBase() noexcept { if (guard.load() == QtGlobalStatic::Initialized) guard.store(QtGlobalStatic::Destroyed); } }; static struct Holder : public HolderBase { Type value; Holder() noexcept(noexcept(Type ())) : value () { guard.store(QtGlobalStatic::Initialized); } } holder; return &holder.value; } } } static QGlobalStatic<QPlatformTextureList, Q_QGS_qt_dummy_platformTextureList::innerFunction, Q_QGS_qt_dummy_platformTextureList::guard> qt_dummy_platformTextureList;

void QWidgetBackingStore::qt_flush(QWidget *widget, const QRegion &region, QBackingStore *backingStore,

QWidget *tlw, const QPoint &tlwOffset, QPlatformTextureList *widgetTextures,

QWidgetBackingStore *widgetBackingStore)

{

((!(!region.isEmpty() || widgetTextures)) ? qt_assert("!region.isEmpty() || widgetTextures",__FILE__,8187) : qt_noop());

((!(widget)) ? qt_assert("widget",__FILE__,8389) : qt_noop());

((!(backingStore)) ? qt_assert("backingStore",__FILE__,8490) : qt_noop());

((!(tlw)) ? qt_assert("tlw",__FILE__,8591) : qt_noop());

static int flushUpdate = qEnvironmentVariableIntValue("QT_FLUSH_UPDATE");

if (flushUpdate > 0)

QWidgetBackingStore::showYellowThing(widget, region, flushUpdate * 10, false);

if (tlw->testAttribute(Qt::WA_DontShowOnScreen) || widget->testAttribute(Qt::WA_DontShowOnScreen))

return;

static bool fpsDebug = qEnvironmentVariableIntValue("QT_DEBUG_FPS");

if (fpsDebug) {

if (!widgetBackingStore->perfFrames++)

widgetBackingStore->perfTime.start();

if (widgetBackingStore->perfTime.elapsed() > 5000) {

double fps = double(widgetBackingStore->perfFrames * 1000) / widgetBackingStore->perfTime.restart();

QMessageLogger(__FILE__, 100106, __PRETTY_FUNCTION__).debug("FPS: %.1f\n", fps);

widgetBackingStore->perfFrames = 0;

}

QPoint offset = tlwOffset;

if (widget != tlw)

offset += widget->mapTo(tlw, QPoint());

QRegion effectiveRegion = region;

const bool compositionWasActive = widget->d_func()->renderToTextureComposeActive;

if (!widgetTextures) {

widget->d_func()->renderToTextureComposeActive = false;

if (compositionWasActive)

widgetTextures = qt_dummy_platformTextureList;

} else {

widget->d_func()->renderToTextureComposeActive = true;

}

if (compositionWasActive != widget->d_func()->renderToTextureComposeActive)

effectiveRegion = widget->rect();

if (widgetTextures) {

qt_window_private(tlw->windowHandle())->compositing = true;

widget->window()->d_func()->sendComposeStatus(widget->window(), false);

const bool translucentBackground = widget->testAttribute(Qt::WA_TranslucentBackground);

backingStore->handle()->composeAndFlush(widget->windowHandle(), effectiveRegion, offset, widgetTextures,

tlw->d_func()->shareContext(), translucentBackground);

widget->window()->d_func()->sendComposeStatus(widget->window(), true);

} else

backingStore->flush(effectiveRegion, widget->windowHandle(), offset);

}

void QWidgetBackingStore::showYellowThing(QWidget *widget, const QRegion &toBePainted, int msec, bool unclipped)

{

100

101

102

QRegion paintRegion = toBePainted;

103

QRect widgetRect = widget->rect();

104

105

if (!widget->internalWinId()) {

106

QWidget *nativeParent = widget->nativeParentWidget();

107

const QPoint offset = widget->mapTo(nativeParent, QPoint(0, 0));

108

paintRegion.translate(offset);

109

widgetRect.translate(offset);

110

widget = nativeParent;

}

bool paintUnclipped = widget->testAttribute(Qt::WA_PaintUnclipped);

119

if (unclipped && !widget->d_func()->paintOnScreen())

120

widget->setAttribute(Qt::WA_PaintUnclipped);

121

122

const bool setFlag = !widget->testAttribute(Qt::WA_WState_InPaintEvent);

123

if (setFlag)

124

widget->setAttribute(Qt::WA_WState_InPaintEvent);

125

126

127

QPaintEngine *pe = widget->paintEngine();

128

if (pe) {

129

pe->setSystemClip(paintRegion);

130

{

131

QPainter p(widget);

132

p.setClipRegion(paintRegion);

static int i = 0;

switch (i) {

case 0:

p.fillRect(widgetRect, QColor(255,255,0));

137

break;

138

case 1:

139

p.fillRect(widgetRect, QColor(255,200,55));

140

break;

141

case 2:

142

p.fillRect(widgetRect, QColor(200,255,55));

143

break;

144

case 3:

145

p.fillRect(widgetRect, QColor(200,200,0));

break;

}

i = (i+1) & 3;

p.end();

}

}

if (setFlag)

widget->setAttribute(Qt::WA_WState_InPaintEvent, false);

155

156

157

widget->setAttribute(Qt::WA_PaintUnclipped, paintUnclipped);

158

159

if (pe)

160

pe->setSystemClip(QRegion());

161

162

163

::usleep(1000 * msec);

}

bool QWidgetBackingStore::flushPaint(QWidget *widget, const QRegion &rgn)

{

if (!widget)

return false;

int delay = 0;

if (widget->testAttribute(Qt::WA_WState_InPaintEvent)) {

175

static int flushPaintEvent = qEnvironmentVariableIntValue("QT_FLUSH_PAINT_EVENT");

176

if (!flushPaintEvent)

177

return false;

178

delay = flushPaintEvent;

179

} else {

180

static int flushPaint = qEnvironmentVariableIntValue("QT_FLUSH_PAINT");

if (!flushPaint)

return false;

delay = flushPaint;

}

QWidgetBackingStore::showYellowThing(widget, rgn, delay * 10, true);

return true;

}

void QWidgetBackingStore::unflushPaint(QWidget *widget, const QRegion &rgn)

191

{

192

if (widget->d_func()->paintOnScreen() || rgn.isEmpty())

193

return;

194

195

QWidget *tlw = widget->window();

196

QTLWExtra *tlwExtra = tlw->d_func()->maybeTopData();

if (!tlwExtra)

return;

const QPoint offset = widget->mapTo(tlw, QPoint());

201

qt_flush(widget, rgn, tlwExtra->backingStoreTracker->store, tlw, offset, 0, tlw->d_func()->maybeBackingStore());

}

bool QWidgetBackingStore::bltRect(const QRect &rect, int dx, int dy, QWidget *widget)

210

{

211

const QPoint pos(tlwOffset + widget->mapTo(tlw, rect.topLeft()));

212

const QRect tlwRect(QRect(pos, rect.size()));

213

if (fullUpdatePending || dirty.intersects(tlwRect))

214

return false;

215

return store->scroll(tlwRect, dx, dy);

216

}

217

218

void QWidgetBackingStore::releaseBuffer()

219

{

220

if (store)

221

store->resize(QSize());

}

void QWidgetBackingStore::beginPaint(QRegion &toClean, QWidget *widget, QBackingStore *backingStore,

231

BeginPaintInfo *returnInfo, bool toCleanIsInTopLevelCoordinates)

232

{

233

(void)widget;;

234

(void)toCleanIsInTopLevelCoordinates;;

235

236

237

dirtyOnScreen += toClean;

returnInfo->wasFlushed = QWidgetBackingStore::flushPaint(tlw, toClean);

if (!returnInfo->wasFlushed)

248

backingStore->beginPaint(toClean);

(void)returnInfo;;

}

void QWidgetBackingStore::endPaint(const QRegion &cleaned, QBackingStore *backingStore,

255

BeginPaintInfo *beginPaintInfo)

256

{

257

258

if (!beginPaintInfo->wasFlushed)

259

backingStore->endPaint();

260

else

261

QWidgetBackingStore::unflushPaint(tlw, cleaned);

flush();

}

QRegion QWidgetBackingStore::dirtyRegion(QWidget *widget) const

278

{

279

const bool widgetDirty = widget && widget != tlw;

280

const QRect tlwRect(topLevelRect());

281

const QRect surfaceGeometry(tlwRect.topLeft(), store->size());

282

if (fullUpdatePending || (surfaceGeometry != tlwRect && surfaceGeometry.size() != tlwRect.size())) {

283

if (widgetDirty) {

284

const QRect dirtyTlwRect = QRect(QPoint(), tlwRect.size());

285

const QPoint offset(widget->mapTo(tlw, QPoint()));

286

const QRect dirtyWidgetRect(dirtyTlwRect & widget->rect().translated(offset));

287

return dirtyWidgetRect.translated(-offset);

288

}

289

return QRect(QPoint(), tlwRect.size());

}

QRegion r(dirty);

for (int i = 0; i < dirtyWidgets.size(); ++i) {

295

QWidget *w = dirtyWidgets.at(i);

296

if (widgetDirty && w != widget && !widget->isAncestorOf(w))

297

continue;

298

r += w->d_func()->dirty.translated(w->mapTo(tlw, QPoint()));

}

r += dirtyOnScreen;

if (dirtyOnScreenWidgets) {

305

for (int i = 0; i < dirtyOnScreenWidgets->size(); ++i) {

306

QWidget *w = dirtyOnScreenWidgets->at(i);

307

if (widgetDirty && w != widget && !widget->isAncestorOf(w))

308

continue;

309

QWidgetPrivate *wd = w->d_func();

310

((!(wd->needsFlush)) ? qt_assert("wd->needsFlush",__FILE__,403409) : qt_noop());

311

r += wd->needsFlush->translated(w->mapTo(tlw, QPoint()));

}

}

if (widgetDirty) {

const QPoint offset(widget->mapTo(tlw, QPoint()));

318

r &= widget->rect().translated(offset);

319

r.translate(-offset);

}

return r;

}

QRegion QWidgetBackingStore::staticContents(QWidget *parent, const QRect &withinClipRect) const

330

{

331

if (!parent && tlw->testAttribute(Qt::WA_StaticContents)) {

332

const QSize surfaceGeometry(store->size());

333

QRect surfaceRect(0, 0, surfaceGeometry.width(), surfaceGeometry.height());

334

if (!withinClipRect.isEmpty())

335

surfaceRect &= withinClipRect;

336

return QRegion(surfaceRect);

}

QRegion region;

if (parent && parent->d_func()->children.isEmpty())

341

return region;

342

343

const bool clipToRect = !withinClipRect.isEmpty();

344

const int count = staticWidgets.count();

345

for (int i = 0; i < count; ++i) {

346

QWidget *w = staticWidgets.at(i);

347

QWidgetPrivate *wd = w->d_func();

348

if (!wd->isOpaque || !wd->extra || wd->extra->staticContentsSize.isEmpty()

349

|| !w->isVisible() || (parent && !parent->isAncestorOf(w))) {

continue;

}

QRect rect(0, 0, wd->extra->staticContentsSize.width(), wd->extra->staticContentsSize.height());

354

const QPoint offset = w->mapTo(parent ? parent : tlw, QPoint());

355

if (clipToRect)

356

rect &= withinClipRect.translated(-offset);

if (rect.isEmpty())

continue;

rect &= wd->clipRect();

if (rect.isEmpty())

continue;

QRegion visible(rect);

365

wd->clipToEffectiveMask(visible);

366

if (visible.isEmpty())

367

continue;

368

wd->subtractOpaqueSiblings(visible, 0, true);

369

370

visible.translate(offset);

region += visible;

}

return region;

}

void QWidgetBackingStore::sendUpdateRequest(QWidget *widget, UpdateTime updateTime)

{

if (!widget)

return;

QWidget *w = widget->window();

388

if (updateTime == UpdateNow && w && w->windowHandle() && QWindowPrivate::get(w->windowHandle())->compositing) {

389

int refresh = 60;

390

QScreen *ws = w->windowHandle()->screen();

391

if (ws)

392

refresh = ws->refreshRate();

393

QWindowPrivate *wd = QWindowPrivate::get(w->windowHandle());

394

if (wd->lastComposeTime.isValid()) {

395

const qint64 elapsed = wd->lastComposeTime.elapsed();

396

if (elapsed <= qint64(1000.0f / refresh))

397

updateTime = UpdateLater;

}

}

switch (updateTime) {

403

case UpdateLater:

404

updateRequestSent = true;

405

QApplication::postEvent(widget, new QEvent(QEvent::UpdateRequest), Qt::LowEventPriority);

406

break;

407

case UpdateNow: {

408

QEvent event(QEvent::UpdateRequest);

409

QApplication::sendEvent(widget, &event);

break;

}

}

}

void QWidgetBackingStore::markDirty(const QRegion &rgn, QWidget *widget,

415

UpdateTime updateTime, BufferState bufferState)

416

{

417

((!(tlw->d_func()->extra)) ? qt_assert("tlw->d_func()->extra",__FILE__,524530) : qt_noop());

418

((!(tlw->d_func()->extra->topextra)) ? qt_assert("tlw->d_func()->extra->topextra",__FILE__,525531) : qt_noop());

419

((!(!tlw->d_func()->extra->topextra->inTopLevelResize)) ? qt_assert("!tlw->d_func()->extra->topextra->inTopLevelResize",__FILE__,526532) : qt_noop());

420

((!(widget->isVisible() && widget->updatesEnabled())) ? qt_assert("widget->isVisible() && widget->updatesEnabled()",__FILE__,527533) : qt_noop());

421

((!(widget->window() == tlw)) ? qt_assert("widget->window() == tlw",__FILE__,528534) : qt_noop());

422

((!(!rgn.isEmpty())) ? qt_assert("!rgn.isEmpty()",__FILE__,529535) : qt_noop());

423

424

425

widget->d_func()->invalidateGraphicsEffectsRecursively();

426

427

428

if (widget->d_func()->paintOnScreen()) {

429

if (widget->d_func()->dirty.isEmpty()) {

430

widget->d_func()->dirty = rgn;

431

sendUpdateRequest(widget, updateTime);

432

return;

433

} else if (qt_region_strictContains(widget->d_func()->dirty, widget->rect())) {

434

if (updateTime == UpdateNow)

435

sendUpdateRequest(widget, updateTime);

return;

}

const bool eventAlreadyPosted = !widget->d_func()->dirty.isEmpty();

440

widget->d_func()->dirty += rgn;

441

if (!eventAlreadyPosted || updateTime == UpdateNow)

442

sendUpdateRequest(widget, updateTime);

return;

}

if (fullUpdatePending) {

448

if (updateTime == UpdateNow)

449

sendUpdateRequest(tlw, updateTime);

return;

}

const QPoint offset = widget->mapTo(tlw, QPoint());

454

455

if (QWidgetPrivate::get(widget)->renderToTexture) {

456

if (!widget->d_func()->inDirtyList)

457

addDirtyRenderToTextureWidget(widget);

458

if (!updateRequestSent || updateTime == UpdateNow)

459

sendUpdateRequest(tlw, updateTime);

return;

}

const QRect widgetRect = widget->d_func()->effectiveRectFor(widget->rect());

464

if (qt_region_strictContains(dirty, widgetRect.translated(offset))) {

465

if (updateTime == UpdateNow)

466

sendUpdateRequest(tlw, updateTime);

return;

}

if (bufferState == BufferInvalid) {

471

const bool eventAlreadyPosted = !dirty.isEmpty() || updateRequestSent;

472

473

if (widget->d_func()->graphicsEffect)

474

dirty += widget->d_func()->effectiveRectFor(rgn.boundingRect()).translated(offset);

475

else

476

477

dirty += rgn.translated(offset);

478

if (!eventAlreadyPosted || updateTime == UpdateNow)

479

sendUpdateRequest(tlw, updateTime);

return;

}

if (dirtyWidgets.isEmpty()) {

484

addDirtyWidget(widget, rgn);

485

sendUpdateRequest(tlw, updateTime);

return;

}

if (widget->d_func()->inDirtyList) {

490

if (!qt_region_strictContains(widget->d_func()->dirty, widgetRect)) {

491

492

if (widget->d_func()->graphicsEffect)

493

widget->d_func()->dirty += widget->d_func()->effectiveRectFor(rgn.boundingRect());

494

else

495

496

widget->d_func()->dirty += rgn;

497

}

498

} else {

499

addDirtyWidget(widget, rgn);

500

}

501

502

if (updateTime == UpdateNow)

503

sendUpdateRequest(tlw, updateTime);

504

}

505

void QWidgetBackingStore::markDirty(const QRect &rect, QWidget *widget,

506

UpdateTime updateTime, BufferState bufferState)

507

{

508

((!(tlw->d_func()->extra)) ? qt_assert("tlw->d_func()->extra",__FILE__,623629) : qt_noop());

509

((!(tlw->d_func()->extra->topextra)) ? qt_assert("tlw->d_func()->extra->topextra",__FILE__,624630) : qt_noop());

510

((!(!tlw->d_func()->extra->topextra->inTopLevelResize)) ? qt_assert("!tlw->d_func()->extra->topextra->inTopLevelResize",__FILE__,625631) : qt_noop());

511

((!(widget->isVisible() && widget->updatesEnabled())) ? qt_assert("widget->isVisible() && widget->updatesEnabled()",__FILE__,626632) : qt_noop());

512

((!(widget->window() == tlw)) ? qt_assert("widget->window() == tlw",__FILE__,627633) : qt_noop());

513

((!(!rect.isEmpty())) ? qt_assert("!rect.isEmpty()",__FILE__,628634) : qt_noop());

514

515

516

widget->d_func()->invalidateGraphicsEffectsRecursively();

517

518

519

if (widget->d_func()->paintOnScreen()) {

520

if (widget->d_func()->dirty.isEmpty()) {

521

widget->d_func()->dirty = QRegion(rect);

522

sendUpdateRequest(widget, updateTime);

523

return;

524

} else if (qt_region_strictContains(widget->d_func()->dirty, rect)) {

525

if (updateTime == UpdateNow)

526

sendUpdateRequest(widget, updateTime);

return;

}

const bool eventAlreadyPosted = !widget->d_func()->dirty.isEmpty();

531

widget->d_func()->dirty += rect;

532

if (!eventAlreadyPosted || updateTime == UpdateNow)

533

sendUpdateRequest(widget, updateTime);

return;

}

if (fullUpdatePending) {

538

if (updateTime == UpdateNow)

539

sendUpdateRequest(tlw, updateTime);

return;

}

if (QWidgetPrivate::get(widget)->renderToTexture) {

544

if (!widget->d_func()->inDirtyList)

545

addDirtyRenderToTextureWidget(widget);

546

if (!updateRequestSent || updateTime == UpdateNow)

547

sendUpdateRequest(tlw, updateTime);

return;

}

const QRect widgetRect = widget->d_func()->effectiveRectFor(rect);

553

QRect translatedRect = widgetRect;

554

if (widget != tlw)

555

translatedRect.translate(widget->mapTo(tlw, QPoint()));

556

557

translatedRect = translatedRect.intersected(QRect(QPoint(), tlw->size()));

558

if (qt_region_strictContains(dirty, translatedRect)) {

559

if (updateTime == UpdateNow)

560

sendUpdateRequest(tlw, updateTime);

return;

}

if (bufferState == BufferInvalid) {

565

const bool eventAlreadyPosted = !dirty.isEmpty();

566

dirty += translatedRect;

567

if (!eventAlreadyPosted || updateTime == UpdateNow)

568

sendUpdateRequest(tlw, updateTime);

return;

}

if (dirtyWidgets.isEmpty()) {

573

addDirtyWidget(widget, rect);

574

sendUpdateRequest(tlw, updateTime);

return;

}

if (widget->d_func()->inDirtyList) {

579

if (!qt_region_strictContains(widget->d_func()->dirty, widgetRect))

580

widget->d_func()->dirty += widgetRect;

581

} else {

582

addDirtyWidget(widget, rect);

583

}

584

585

if (updateTime == UpdateNow)

586

sendUpdateRequest(tlw, updateTime);

}

void QWidgetBackingStore::markDirtyOnScreen(const QRegion &region, QWidget *widget, const QPoint &topLevelOffset)

596

{

597

if (!widget || widget->d_func()->paintOnScreen() || region.isEmpty())

598

return;

599

if (widget == tlw) {

600

if (!widget->testAttribute(Qt::WA_WState_InPaintEvent))

601

dirtyOnScreen += region;

return;

}

if (!widget->internalWinId() && !widget->isWindow()) {

607

QWidget *nativeParent = widget->nativeParentWidget();

608

if (nativeParent == tlw) {

609

if (!widget->testAttribute(Qt::WA_WState_InPaintEvent))

610

dirtyOnScreen += region.translated(topLevelOffset);

return;

}

QWidgetPrivate *nativeParentPrivate = nativeParent->d_func();

616

if (!nativeParentPrivate->needsFlush)

617

nativeParentPrivate->needsFlush = new QRegion;

618

const QPoint nativeParentOffset = widget->mapTo(nativeParent, QPoint());

619

*nativeParentPrivate->needsFlush += region.translated(nativeParentOffset);

620

appendDirtyOnScreenWidget(nativeParent);

return;

}

QWidgetPrivate *widgetPrivate = widget->d_func();

626

if (!widgetPrivate->needsFlush)

627

widgetPrivate->needsFlush = new QRegion;

628

*widgetPrivate->needsFlush += region;

629

appendDirtyOnScreenWidget(widget);

630

}

631

632

void QWidgetBackingStore::removeDirtyWidget(QWidget *w)

{

if (!w)

return;

dirtyWidgetsRemoveAll(w);

638

dirtyOnScreenWidgetsRemoveAll(w);

639

dirtyRenderToTextureWidgets.removeAll(w);

640

resetWidget(w);

641

642

QWidgetPrivate *wd = w->d_func();

643

const int n = wd->children.count();

644

for (int i = 0; i < n; ++i) {

645

if (QWidget *child = qobject_cast<QWidget*>(wd->children.at(i)))

646

removeDirtyWidget(child);

}

}

void QWidgetBackingStore::updateLists(QWidget *cur)

{

if (!cur)

return;

QList<QObject*> children = cur->children();

656

for (int i = 0; i < children.size(); ++i) {

657

QWidget *child = qobject_cast<QWidget*>(children.at(i));

if (!child)

continue;

updateLists(child);

}

if (cur->testAttribute(Qt::WA_StaticContents))

665

addStaticWidget(cur);

666

}

667

668

QWidgetBackingStore::QWidgetBackingStore(QWidget *topLevel)

669

: tlw(topLevel),

670

dirtyOnScreenWidgets(0),

671

fullUpdatePending(0),

672

updateRequestSent(0),

673

textureListWatcher(0),

674

perfFrames(0)

675

{

676

store = tlw->backingStore();

677

((!(store)) ? qt_assert("store",__FILE__,800806) : qt_noop());

678

679

680

updateLists(topLevel);

681

}

682

683

QWidgetBackingStore::~QWidgetBackingStore()

684

{

685

for (int c = 0; c < dirtyWidgets.size(); ++c)

686

resetWidget(dirtyWidgets.at(c));

687

for (int c = 0; c < dirtyRenderToTextureWidgets.size(); ++c)

688

resetWidget(dirtyRenderToTextureWidgets.at(c));

689

690

delete dirtyOnScreenWidgets;

}

void QWidgetPrivate::moveRect(const QRect &rect, int dx, int dy)

696

{

697

QWidget * const q = q_func();

698

if (!q->isVisible() || (dx == 0 && dy == 0))

699

return;

700

701

QWidget *tlw = q->window();

702

QTLWExtra* x = tlw->d_func()->topData();

703

if (x->inTopLevelResize)

704

return;

705

706

static const bool accelEnv = qEnvironmentVariableIntValue("QT_NO_FAST_MOVE") == 0;

707

708

QWidget *pw = q->parentWidget();

709

QPoint toplevelOffset = pw->mapTo(tlw, QPoint());

710

QWidgetPrivate *pd = pw->d_func();

711

QRect clipR(pd->clipRect());

712

const QRect newRect(rect.translated(dx, dy));

713

QRect destRect = rect.intersected(clipR);

714

if (destRect.isValid())

715

destRect = destRect.translated(dx, dy).intersected(clipR);

716

const QRect sourceRect(destRect.translated(-dx, -dy));

717

const QRect parentRect(rect & clipR);

718

const bool nativeWithTextureChild = textureChildSeen && q->internalWinId();

719

720

bool accelerateMove = accelEnv && isOpaque && !nativeWithTextureChild

721

722

723

&& !tlw->d_func()->extra->proxyWidget

724

725

&& !isOverlapped(sourceRect) && !isOverlapped(destRect);

726

727

if (!accelerateMove) {

728

QRegion parentR(effectiveRectFor(parentRect));

729

if (!extra || !extra->hasMask) {

parentR -= newRect;

} else {

parentR += newRect & clipR;

734

}

735

pd->invalidateBuffer(parentR);

736

invalidateBuffer((newRect & clipR).translated(-data.crect.topLeft()));

737

} else {

738

739

QWidgetBackingStore *wbs = x->backingStoreTracker.data();

740

QRegion childExpose(newRect & clipR);

741

742

if (sourceRect.isValid() && wbs->bltRect(sourceRect, dx, dy, pw))

743

childExpose -= destRect;

744

745

if (!pw->updatesEnabled())

746

return;

747

748

const bool childUpdatesEnabled = q->updatesEnabled();

749

if (childUpdatesEnabled && !childExpose.isEmpty()) {

750

childExpose.translate(-data.crect.topLeft());

751

wbs->markDirty(childExpose, q);

isMoved = true;

}

QRegion parentExpose(parentRect);

756

parentExpose -= newRect;

757

if (extra && extra->hasMask)

758

parentExpose += QRegion(newRect) - extra->mask.translated(data.crect.topLeft());

759

760

if (!parentExpose.isEmpty()) {

761

wbs->markDirty(parentExpose, pw);

pd->isMoved = true;

}

if (childUpdatesEnabled) {

766

QRegion needsFlush(sourceRect);

767

needsFlush += destRect;

768

wbs->markDirtyOnScreen(needsFlush, pw, toplevelOffset);

}

}

}

void QWidgetPrivate::scrollRect(const QRect &rect, int dx, int dy)

775

{

776

QWidget * const q = q_func();

777

QWidget *tlw = q->window();

778

QTLWExtra* x = tlw->d_func()->topData();

779

if (x->inTopLevelResize)

780

return;

781

782

QWidgetBackingStore *wbs = x->backingStoreTracker.data();

if (!wbs)

return;

static const bool accelEnv = qEnvironmentVariableIntValue("QT_NO_FAST_SCROLL") == 0;

787

788

QRect scrollRect = rect & clipRect();

789

bool overlapped = false;

790

bool accelerateScroll = accelEnv && isOpaque && !q_func()->testAttribute(Qt::WA_WState_InPaintEvent)

791

&& !(overlapped = isOverlapped(scrollRect.translated(data.crect.topLeft())));

792

793

if (!accelerateScroll) {

794

if (overlapped) {

795

QRegion region(scrollRect);

796

subtractOpaqueSiblings(region);

797

invalidateBuffer(region);

798

}else {

799

invalidateBuffer(scrollRect);

800

}

801

} else {

802

const QPoint toplevelOffset = q->mapTo(tlw, QPoint());

803

const QRect destRect = scrollRect.translated(dx, dy) & scrollRect;

804

const QRect sourceRect = destRect.translated(-dx, -dy);

805

806

QRegion childExpose(scrollRect);

807

if (sourceRect.isValid()) {

808

if (wbs->bltRect(sourceRect, dx, dy, q))

809

childExpose -= destRect;

}

if (inDirtyList) {

if (rect == q->rect()) {

814

dirty.translate(dx, dy);

815

} else {

816

QRegion dirtyScrollRegion = dirty.intersected(scrollRect);

817

if (!dirtyScrollRegion.isEmpty()) {

818

dirty -= dirtyScrollRegion;

819

dirtyScrollRegion.translate(dx, dy);

820

dirty += dirtyScrollRegion;

}

}

}

if (!q->updatesEnabled())

826

return;

827

828

if (!childExpose.isEmpty()) {

829

wbs->markDirty(childExpose, q);

isScrolled = true;

}

wbs->markDirtyOnScreen(destRect, q, toplevelOffset);

}

}

static void findTextureWidgetsRecursively(QWidget *tlw, QWidget *widget, QPlatformTextureList *widgetTextures, QVector<QWidget *> *nativeChildren)

842

{

843

QWidgetPrivate *wd = QWidgetPrivate::get(widget);

844

if (wd->renderToTexture) {

845

QPlatformTextureList::Flags flags = 0;

846

if (widget->testAttribute(Qt::WA_AlwaysStackOnTop))

847

flags |= QPlatformTextureList::StacksOnTop;

848

const QRect rect(widget->mapTo(tlw, QPoint()), widget->size());

849

widgetTextures->appendTexture(widget, wd->textureId(), rect, wd->clipRect(), flags);

850

}

851

852

for (int i = 0; i < wd->children.size(); ++i) {

853

QWidget *w = qobject_cast<QWidget *>(wd->children.at(i));

854

855

if (w && !w->isWindow() && w->internalWinId())

856

nativeChildren->append(w);

857

if (w && !w->isWindow() && !w->internalWinId() && !w->isHidden() && QWidgetPrivate::get(w)->textureChildSeen)

858

findTextureWidgetsRecursively(tlw, w, widgetTextures, nativeChildren);

}

}

static void findAllTextureWidgetsRecursively(QWidget *tlw, QWidget *widget)

863

{

864

865

if (QWidgetPrivate::get(widget)->textureChildSeen) {

866

QVector<QWidget *> nativeChildren;

867

QScopedPointer<QPlatformTextureList> tl(new QPlatformTextureList);

868

869

870

findTextureWidgetsRecursively(tlw, widget, tl.data(), &nativeChildren);

871

872

if (!tl->isEmpty())

873

QWidgetPrivate::get(tlw)->topData()->widgetTextures.append(tl.take());

874

875

for (QForeachContainer<typename QtPrivate::remove_reference<decltype(nativeChildren)>::type> _container_((nativeChildren)); _container_.control && _container_.i != _container_.e; ++_container_.i, _container_.control ^= 1) for (QWidget *ncw = *_container_.i; _container_.control; _container_.control = 0) {

876

if (QWidgetPrivate::get(ncw)->textureChildSeen)

877

findAllTextureWidgetsRecursively(tlw, ncw);

}

}

}

static QPlatformTextureList *widgetTexturesFor(QWidget *tlw, QWidget *widget)

883

{

884

for (QForeachContainer<typename QtPrivate::remove_reference<decltype(QWidgetPrivate::get(tlw)->topData()->widgetTextures)>::type> _container_((QWidgetPrivate::get(tlw)->topData()->widgetTextures)); _container_.control && _container_.i != _container_.e; ++_container_.i, _container_.control ^= 1) for (QPlatformTextureList *tl = *_container_.i; _container_.control; _container_.control = 0) {

885

((!(!tl->isEmpty())) ? qt_assert("!tl->isEmpty()",__FILE__,10081014) : qt_noop());

886

for (int i = 0; i < tl->count(); ++i) {

887

QWidget *w = static_cast<QWidget *>(tl->source(i));

888

if ((w->internalWinId() && w == widget) || (!w->internalWinId() && w->nativeParentWidget() == widget))

return tl;

}

}

if (QWidgetPrivate::get(tlw)->textureChildSeen) {

static bool switchableWidgetComposition =

900

QGuiApplicationPrivate::instance()->platformIntegration()

901

->hasCapability(QPlatformIntegration::SwitchableWidgetComposition);

902

if (!switchableWidgetComposition

903

)

904

{

905

return qt_dummy_platformTextureList();

}

}

return 0;

}

QPlatformTextureListWatcher::QPlatformTextureListWatcher(QWidgetBackingStore *backingStore)

918

: m_backingStore(backingStore)

{

}

void QPlatformTextureListWatcher::watch(QPlatformTextureList *textureList)

923

{

924

connect(textureList, qFlagLocation("2""locked(bool)" "\0" __FILE__ ":" "1056""1062"), qFlagLocation("1""onLockStatusChanged(bool)" "\0" __FILE__ ":" "1056""1062"));

925

m_locked[textureList] = textureList->isLocked();

926

}

927

928

bool QPlatformTextureListWatcher::isLocked() const

929

{

930

for (QForeachContainer<typename QtPrivate::remove_reference<decltype(m_locked)>::type> _container_((m_locked)); _container_.control && _container_.i != _container_.e; ++_container_.i, _container_.control ^= 1) for (bool v = *_container_.i; _container_.control; _container_.control = 0) {

if (v)

return true;

}

return false;

}

void QPlatformTextureListWatcher::onLockStatusChanged(bool locked)

938

{

939

QPlatformTextureList *tl = static_cast<QPlatformTextureList *>(sender());

940

m_locked[tl] = locked;

941

if (!isLocked())

942

m_backingStore->sync();

943

}

944

static inline bool discardSyncRequest(QWidget *tlw, QTLWExtra *tlwExtra)

945

{

946

if (!tlw || !tlwExtra || !tlw->testAttribute(Qt::WA_Mapped) || !tlw->isVisible())

return true;

return false;

}

bool QWidgetBackingStore::syncAllowed()

953

{

954

955

QTLWExtra *tlwExtra = tlw->d_func()->maybeTopData();

956

if (textureListWatcher && !textureListWatcher->isLocked()) {

957

textureListWatcher->deleteLater();

958

textureListWatcher = 0;

959

} else if (!tlwExtra->widgetTextures.isEmpty()) {

960

bool skipSync = false;

961

for (QForeachContainer<typename QtPrivate::remove_reference<decltype(tlwExtra->widgetTextures)>::type> _container_((tlwExtra->widgetTextures)); _container_.control && _container_.i != _container_.e; ++_container_.i, _container_.control ^= 1) for (QPlatformTextureList *tl = *_container_.i; _container_.control; _container_.control = 0) {

962

if (tl->isLocked()) {

963

if (!textureListWatcher)

964

textureListWatcher = new QPlatformTextureListWatcher(this);

965

if (!textureListWatcher->isLocked())

966

textureListWatcher->watch(tl);

skipSync = true;

}

}

if (skipSync)

return false;

}

return true;

}

void QWidgetBackingStore::sync(QWidget *exposedWidget, const QRegion &exposedRegion)

977

{

978

QTLWExtra *tlwExtra = tlw->d_func()->maybeTopData();

979

if (!tlw->isVisible() || !tlwExtra || tlwExtra->inTopLevelResize)

980

return;

981

982

if (!exposedWidget || !exposedWidget->internalWinId() || !exposedWidget->isVisible() || !exposedWidget->testAttribute(Qt::WA_Mapped)

983

|| !exposedWidget->updatesEnabled() || exposedRegion.isEmpty()) {

return;

}

if (!isDirty() && store->size().isValid()) {

989

QPlatformTextureList *tl = widgetTexturesFor(tlw, exposedWidget);

990

qt_flush(exposedWidget, tl ? QRegion() : exposedRegion, store, tlw, tlwOffset, tl, this);

return;

}

if (exposedWidget != tlw)

995

markDirtyOnScreen(exposedRegion, exposedWidget, exposedWidget->mapTo(tlw, QPoint()));

996

else

997

markDirtyOnScreen(exposedRegion, exposedWidget, QPoint());

if (syncAllowed())

doSync();

}

void QWidgetBackingStore::sync()

1007

{

1008

updateRequestSent = false;

1009

QTLWExtra *tlwExtra = tlw->d_func()->maybeTopData();

1010

if (discardSyncRequest(tlw, tlwExtra)) {

if (!tlw->isVisible()) {

1017

dirty = QRegion();

1018

for (int i = 0; i < dirtyWidgets.size(); ++i)

1019

resetWidget(dirtyWidgets.at(i));

1020

dirtyWidgets.clear();

1021

fullUpdatePending = false;

}

return;

}

if (syncAllowed())

doSync();

}

void QWidgetBackingStore::doSync()

1031

{

1032

const bool updatesDisabled = !tlw->updatesEnabled();

1033

bool repaintAllWidgets = false;

1034

1035

const bool inTopLevelResize = tlw->d_func()->maybeTopData()->inTopLevelResize;

1036

const QRect tlwRect(topLevelRect());

1037

const QRect surfaceGeometry(tlwRect.topLeft(), store->size());

1038

if ((fullUpdatePending || inTopLevelResize || surfaceGeometry.size() != tlwRect.size()) && !updatesDisabled) {

1039

if (hasStaticContents() && !store->size().isEmpty() ) {

1040

1041

const QRect clipRect(0, 0, surfaceGeometry.width(), surfaceGeometry.height());

1042

const QRegion staticRegion(staticContents(0, clipRect));

1043

QRegion newVisible(0, 0, tlwRect.width(), tlwRect.height());

1044

newVisible -= staticRegion;

1045

dirty += newVisible;

1046

store->setStaticContents(staticRegion);

1047

} else {

1048

1049

dirty = QRegion(0, 0, tlwRect.width(), tlwRect.height());

1050

for (int i = 0; i < dirtyWidgets.size(); ++i)

1051

resetWidget(dirtyWidgets.at(i));

1052

dirtyWidgets.clear();

1053

repaintAllWidgets = true;

}

}

if (inTopLevelResize || surfaceGeometry.size() != tlwRect.size())

1058

store->resize(tlwRect.size());

if (updatesDisabled)

return;

QRegion toClean(dirty);

QVarLengthArray<QWidget *, 32> opaqueNonOverlappedWidgets;

1071

for (int i = 0; i < dirtyWidgets.size(); ++i) {

1072

QWidget *w = dirtyWidgets.at(i);

1073

QWidgetPrivate *wd = w->d_func();

1074

if (wd->data.in_destructor)

continue;

wd->dirty &= wd->clipRect();

1079

wd->clipToEffectiveMask(wd->dirty);

1080

1081

1082

bool hasDirtySiblingsAbove = false;

1083

1084

if (!wd->isMoved)

1085

wd->subtractOpaqueSiblings(wd->dirty, &hasDirtySiblingsAbove);

const QRegion dirtyBeforeSubtractedOpaqueChildren = wd->dirty;

1092

1093

1094

if (!wd->isScrolled && !wd->isMoved)

1095

wd->subtractOpaqueChildren(wd->dirty, w->rect());

1096

1097

if (wd->dirty.isEmpty() && wd->textureChildSeen)

1098

wd->dirty = dirtyBeforeSubtractedOpaqueChildren;

1099

1100

if (wd->dirty.isEmpty()) {

resetWidget(w);

continue;

}

const QRegion widgetDirty(w != tlw ? wd->dirty.translated(w->mapTo(tlw, QPoint()))

1106

: wd->dirty);

1107

toClean += widgetDirty;

1108

1109

1110

if (tlw->d_func()->extra->proxyWidget) {

resetWidget(w);

continue;

}

if (!hasDirtySiblingsAbove && wd->isOpaque && !dirty.intersects(widgetDirty.boundingRect())) {

1117

opaqueNonOverlappedWidgets.append(w);

1118

} else {

1119

resetWidget(w);

1120

dirty += widgetDirty;

1121

}

1122

}

1123

dirtyWidgets.clear();

QTLWExtra *tlwExtra = tlw->d_func()->topData();

1130

qDeleteAll(tlwExtra->widgetTextures);

1131

tlwExtra->widgetTextures.clear();

1132

findAllTextureWidgetsRecursively(tlw, tlw);

1133

qt_window_private(tlw->windowHandle())->compositing = false;

1134

fullUpdatePending = false;

1135

1136

1137

if (toClean.isEmpty()) {

QVarLengthArray<QWidget *, 16> paintPending;

1144

const int numPaintPending = dirtyRenderToTextureWidgets.count();

1145

paintPending.reserve(numPaintPending);

1146

for (int i = 0; i < numPaintPending; ++i) {

1147

QWidget *w = dirtyRenderToTextureWidgets.at(i);

paintPending << w;

resetWidget(w);

}

dirtyRenderToTextureWidgets.clear();

1152

for (int i = 0; i < numPaintPending; ++i) {

1153

QWidget *w = paintPending[i];

1154

w->d_func()->sendPaintEvent(w->rect());

1155

if (w != tlw) {

1156

QWidget *npw = w->nativeParentWidget();

1157

if (w->internalWinId() || (npw && npw != tlw)) {

1158

if (!w->internalWinId())

1159

w = npw;

1160

QWidgetPrivate *wPrivate = w->d_func();

1161

if (!wPrivate->needsFlush)

1162

wPrivate->needsFlush = new QRegion;

1163

appendDirtyOnScreenWidget(w);

}

}

}

flush();

return;

}

for (int i = 0; i < tl->count(); ++i) {

1179

QWidget *w = static_cast<QWidget *>(tl->source(i));

1180

if (dirtyRenderToTextureWidgets.contains(w)) {

1181

const QRect rect = tl->geometry(i);

1182

1183

1184

w->d_func()->renderToTextureReallyDirty = 1;

dirty += rect;

toClean += rect;

}

}

}

for (int i = 0; i < dirtyRenderToTextureWidgets.count(); ++i)

1191

resetWidget(dirtyRenderToTextureWidgets.at(i));

1192

dirtyRenderToTextureWidgets.clear();

if (tlw->d_func()->extra->proxyWidget) {

1197

updateStaticContentsSize();

1198

dirty = QRegion();

1199

updateRequestSent = false;

1200

const QVector<QRect> rects(toClean.rects());

1201

for (int i = 0; i < rects.size(); ++i)

1202

tlw->d_func()->extra->proxyWidget->update(rects.at(i));

return;

}

BeginPaintInfo beginPaintInfo;

1208

beginPaint(toClean, tlw, store, &beginPaintInfo);

1209

if (beginPaintInfo.nothingToPaint) {

1210

for (int i = 0; i < opaqueNonOverlappedWidgets.size(); ++i)

1211

resetWidget(opaqueNonOverlappedWidgets[i]);

1212

dirty = QRegion();

1213

updateRequestSent = false;

return;

}

updateStaticContentsSize();

1220

const QRegion dirtyCopy(dirty);

1221

dirty = QRegion();

1222

updateRequestSent = false;

1223

1224

1225

for (int i = 0; i < opaqueNonOverlappedWidgets.size(); ++i) {

1226

QWidget *w = opaqueNonOverlappedWidgets[i];

1227

QWidgetPrivate *wd = w->d_func();

1228

1229

int flags = QWidgetPrivate::DrawRecursive;

1230

1231

if (!wd->isScrolled && !wd->isMoved)

1232

flags |= QWidgetPrivate::DontDrawOpaqueChildren;

1233

if (w == tlw)

1234

flags |= QWidgetPrivate::DrawAsRoot;

1235

1236

QRegion toBePainted(wd->dirty);

1237

resetWidget(w);

1238

1239

QPoint offset(tlwOffset);

1240

if (w != tlw)

1241

offset += w->mapTo(tlw, QPoint());

1242

wd->drawWidget(store->paintDevice(), toBePainted, offset, flags, 0, this);

}

if (repaintAllWidgets || !dirtyCopy.isEmpty()) {

1247

const int flags = QWidgetPrivate::DrawAsRoot | QWidgetPrivate::DrawRecursive;

1248

tlw->d_func()->drawWidget(store->paintDevice(), dirtyCopy, tlwOffset, flags, 0, this);

1249

}

1250

1251

endPaint(toClean, store, &beginPaintInfo);

}

void QWidgetBackingStore::flush(QWidget *widget)

1260

{

1261

const bool hasDirtyOnScreenWidgets = dirtyOnScreenWidgets && !dirtyOnScreenWidgets->isEmpty();

1262

bool flushed = false;

1263

1264

1265

if (!dirtyOnScreen.isEmpty()) {

1266

QWidget *target = widget ? widget : tlw;

1267

qt_flush(target, dirtyOnScreen, store, tlw, tlwOffset, widgetTexturesFor(tlw, tlw), this);

1268

dirtyOnScreen = QRegion();

flushed = true;

}

if (!flushed && !hasDirtyOnScreenWidgets) {

1274

1275

if (!tlw->d_func()->topData()->widgetTextures.isEmpty()) {

1276

QPlatformTextureList *tl = widgetTexturesFor(tlw, tlw);

1277

if (tl) {

1278

QWidget *target = widget ? widget : tlw;

1279

qt_flush(target, QRegion(), store, tlw, tlwOffset, tl, this);

}

}

}

if (!hasDirtyOnScreenWidgets)

1286

return;

1287

1288

for (int i = 0; i < dirtyOnScreenWidgets->size(); ++i) {

1289

QWidget *w = dirtyOnScreenWidgets->at(i);

1290

QWidgetPrivate *wd = w->d_func();

1291

((!(wd->needsFlush)) ? qt_assert("wd->needsFlush",__FILE__,14431449) : qt_noop());

1292

QPlatformTextureList *widgetTexturesForNative = wd->textureChildSeen ? widgetTexturesFor(tlw, w) : 0;

1293

qt_flush(w, *wd->needsFlush, store, tlw, tlwOffset, widgetTexturesForNative, this);

1294

*wd->needsFlush = QRegion();

1295

}

1296

dirtyOnScreenWidgets->clear();

1297

}

1298

1299

static inline bool discardInvalidateBufferRequest(QWidget *widget, QTLWExtra *tlwExtra)

1300

{

1301

((!(widget)) ? qt_assert("widget",__FILE__,14531459) : qt_noop());

1302

if (QApplication::closingDown())

1303

return true;

1304

1305

if (!tlwExtra || tlwExtra->inTopLevelResize || !tlwExtra->backingStore)

1306

return true;

1307

1308

if (!widget->isVisible() || !widget->updatesEnabled())

return true;

return false;

}

void QWidgetPrivate::invalidateBuffer_resizeHelper(const QPoint &oldPos, const QSize &oldSize)

1319

{

1320

QWidget * const q = q_func();

1321

((!(!q->isWindow())) ? qt_assert("!q->isWindow()",__FILE__,14731479) : qt_noop());

1322

((!(q->parentWidget())) ? qt_assert("q->parentWidget()",__FILE__,14741480) : qt_noop());

1323

1324

const bool staticContents = q->testAttribute(Qt::WA_StaticContents);

1325

const bool sizeDecreased = (data.crect.width() < oldSize.width())

1326

|| (data.crect.height() < oldSize.height());

1327

1328

const QPoint offset(data.crect.x() - oldPos.x(), data.crect.y() - oldPos.y());

1329

const bool parentAreaExposed = !offset.isNull() || sizeDecreased;

1330

const QRect newWidgetRect(q->rect());

1331

const QRect oldWidgetRect(0, 0, oldSize.width(), oldSize.height());

1332

1333

if (!staticContents || graphicsEffect) {

1334

QRegion staticChildren;

1335

QWidgetBackingStore *bs = 0;

1336

if (offset.isNull() && (bs = maybeBackingStore()))

1337

staticChildren = bs->staticContents(q, oldWidgetRect);

1338

const bool hasStaticChildren = !staticChildren.isEmpty();

1339

1340

if (hasStaticChildren) {

1341

QRegion dirty(newWidgetRect);

1342

dirty -= staticChildren;

1343

invalidateBuffer(dirty);

1344

} else {

1345

1346

invalidateBuffer(newWidgetRect);

1347

}

1348

1349

if (!parentAreaExposed)

return;

if (!graphicsEffect && extra && extra->hasMask) {

1354

QRegion parentExpose(extra->mask.translated(oldPos));

1355

parentExpose &= QRect(oldPos, oldSize);

1356

if (hasStaticChildren)

1357

parentExpose -= data.crect;

1358

q->parentWidget()->d_func()->invalidateBuffer(parentExpose);

1359

} else {

1360

if (hasStaticChildren && !graphicsEffect) {

1361

QRegion parentExpose(QRect(oldPos, oldSize));

1362

parentExpose -= data.crect;

1363

q->parentWidget()->d_func()->invalidateBuffer(parentExpose);

1364

} else {

1365

q->parentWidget()->d_func()->invalidateBuffer(effectiveRectFor(QRect(oldPos, oldSize)));

}

}

return;

}

if (!offset.isNull()) {

1373

if (sizeDecreased) {

1374

const QSize minSize(qMin(oldSize.width(), data.crect.width()),

1375

qMin(oldSize.height(), data.crect.height()));

1376

moveRect(QRect(oldPos, minSize), offset.x(), offset.y());

1377

} else {

1378

moveRect(QRect(oldPos, oldSize), offset.x(), offset.y());

}

}

if (!sizeDecreased || !oldWidgetRect.contains(newWidgetRect)) {

1384

QRegion newVisible(newWidgetRect);

1385

newVisible -= oldWidgetRect;

1386

invalidateBuffer(newVisible);

1387

}

1388

1389

if (!parentAreaExposed)

return;

const QRect oldRect(oldPos, oldSize);

1394

if (extra && extra->hasMask) {

1395

QRegion parentExpose(oldRect);

1396

parentExpose &= extra->mask.translated(oldPos);

1397

parentExpose -= (extra->mask.translated(data.crect.topLeft()) & data.crect);

1398

q->parentWidget()->d_func()->invalidateBuffer(parentExpose);

1399

} else {

1400

QRegion parentExpose(oldRect);

1401

parentExpose -= data.crect;

1402

q->parentWidget()->d_func()->invalidateBuffer(parentExpose);

1403

}

1404

}

1405

void QWidgetPrivate::invalidateBuffer(const QRegion &rgn)

1406

{

1407

QWidget * const q = q_func();

1408

1409

QTLWExtra *tlwExtra = q->window()->d_func()->maybeTopData();

1410

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->backingStoreTracker->markDirty(wrgn, q,

1421

QWidgetBackingStore::UpdateLater, QWidgetBackingStore::BufferInvalid);

1422

}

1423

void QWidgetPrivate::invalidateBuffer(const QRect &rect)

1424

{

1425

QWidget * const q = q_func();

1426

1427

QTLWExtra *tlwExtra = q->window()->d_func()->maybeTopData();

1428

if (discardInvalidateBufferRequest(q, tlwExtra) || rect.isEmpty())

return;

QRect wRect(rect);

wRect &= clipRect();

if (wRect.isEmpty())

return;

if (graphicsEffect || !extra || !extra->hasMask) {

1437

tlwExtra->backingStoreTracker->markDirty(wRect, q,

1438

QWidgetBackingStore::UpdateLater, QWidgetBackingStore::BufferInvalid);

return;

}

QRegion wRgn(extra->mask);

wRgn &= wRect;

if (wRgn.isEmpty())

return;

tlwExtra->backingStoreTracker->markDirty(wRgn, q,

1448

QWidgetBackingStore::UpdateLater, QWidgetBackingStore::BufferInvalid);

1449

}

1450

1451

void QWidgetPrivate::repaint_sys(const QRegion &rgn)

1452

{

1453

if (data.in_destructor

data.in_destructor	Description
TRUE	never evaluated
FALSE	never evaluated

)

1454

return;

never executed: return;

1455

1456

QWidget * const q = q_func();

1457

if (discardSyncRequest(q, maybeTopData())

discardSyncReq...aybeTopData())	Description
TRUE	never evaluated
FALSE	never evaluated

)

1458

return;

never executed: return;

1459

1460

if (q->testAttribute(Qt::WA_StaticContents)

q->testAttribu...taticContents)	Description
TRUE	never evaluated
FALSE	never evaluated

) {

1461

if (!extra

!extra	Description
TRUE	never evaluated
FALSE	never evaluated

)

1462

createExtra();

never executed: createExtra();

1463

extra->staticContentsSize = data.crect.size();

1464

}

never executed: end of block

1465

1466

QPaintEngine *engine = q->paintEngine();

const bool noPartialUpdateSupport = (engine

engine	Description
TRUE	never evaluated
FALSE	never evaluated

&& (engine->type() == QPaintEngine::OpenGL

engine->type()...Engine::OpenGL	Description
TRUE	never evaluated
FALSE	never evaluated

1472

|| engine->type() == QPaintEngine::OpenGL2

engine->type()...ngine::OpenGL2	Description
TRUE	never evaluated
FALSE	never evaluated

))

1473

&& (usesDoubleBufferedGLContext

usesDoubleBufferedGLContext	Description
TRUE	never evaluated
FALSE	never evaluated

|| q->autoFillBackground()

q->autoFillBackground()	Description
TRUE	never evaluated
FALSE	never evaluated

);

1474

QRegion toBePainted(noPartialUpdateSupport ? q->rect() : rgn);

toBePainted &= clipRect();

1483

clipToEffectiveMask(toBePainted);

1484

if (toBePainted.isEmpty()

toBePainted.isEmpty()	Description
TRUE	never evaluated
FALSE	never evaluated

)

1485

return;

never executed: return;

1486

1487

1488

bool flushed = QWidgetBackingStore::flushPaint(q, toBePainted);

1489

1490

1491

drawWidget(q, toBePainted, QPoint(), QWidgetPrivate::DrawAsRoot | QWidgetPrivate::DrawPaintOnScreen, 0);

1492

1493

1494

if (flushed

flushed	Description
TRUE	never evaluated
FALSE	never evaluated

)

1495

QWidgetBackingStore::unflushPaint(q, toBePainted);

never executed: QWidgetBackingStore::unflushPaint(q, toBePainted);

1496

1497

1498

if (__builtin_expect(!!(

__builtin_expe...ive()), false)	Description
TRUE	never evaluated
FALSE	never evaluated

q->paintingActive())()), false)

__builtin_expe...ive()), false)	Description
TRUE	never evaluated
FALSE	never evaluated

)

1499

QMessageLogger(__FILE__, 16671673, __PRETTY_FUNCTION__).warning("QWidget::repaint: It is dangerous to leave painters active on a widget outside of the PaintEvent");

never executed:

QMessageLogger(__FILE__, 1673, __PRETTY_FUNCTION__).warning("QWidget::repaint: It is dangerous to leave painters active on a widget outside of the PaintEvent");

1500

}

never executed: end of block

Generated by Squish Coco Non-Commercial 4.3.0-BETA-master-30-08-2018-4cb69e9