} else if (mimeType == u"text/html"_s) {

mimeData->setHtml(text);

} else if (mimeType == u"text/uri-list"_s) {

} else if (mimeType.startsWith(u"text/"_s)) {

if (qsizetype charsetIdx = mimeType.lastIndexOf(u";charset="_s); charsetIdx != -1) {

charsetIdx += sizeof(";charset=") - 1;

d->pressed = false;

d->scrollingPhase = false;

d->draggingEnding();

returnToBounds();

d->lastPosTime = -1;

d->stealMouse = false;

{

Q_Q(QQuickGridView);

return false;

int modelIndex = change.index;

}

}

if (d->pix.isLoading()) {

if (d->progress != 0.0) {

d->progress = 0.0;

if (itemPrivate)

itemPrivate->extra.value().layoutDirectionAttached = this;

else

}

QQuickLayoutMirroringAttached * QQuickLayoutMirroringAttached::qmlAttachedProperties(QObject *object)

QT_BEGIN_NAMESPACE

Q_LOGGING_CATEGORY(lcItemViewDelegateLifecycle, "qt.quick.itemview.lifecycle")

// Default cacheBuffer for all views.

#ifndef QML_VIEW_DEFAULTCACHEBUFFER

this, SLOT(modelUpdated(QQmlChangeSet,bool)));

if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(d->model))

QObjectPrivate::connect(dataModel, &QQmlDelegateModel::delegateChanged, d, &QQuickItemViewPrivate::applyDelegateChange);

}

emit modelChanged();

d->moveReason = QQuickItemViewPrivate::Other;

int oldCount = dataModel->count();

dataModel->setDelegate(delegate);

if (oldCount != dataModel->count())

}

emit delegateChanged();

d->delegateValidated = false;

void QQuickItemViewPrivate::applyDelegateChange()

{

releaseVisibleItems(QQmlDelegateModel::NotReusable);

updateSectionCriteria();

refill();

moveReason = QQuickItemViewPrivate::SetIndex;

}

}

void QQuickItemViewPrivate::itemGeometryChanged(QQuickItem *item, QQuickGeometryChange change,

const QRectF &oldGeometry)

{

d->updateTrackedItem();

}

d->moveReason = QQuickItemViewPrivate::Other;

#if QT_CONFIG(quick_viewtransitions)

if (d->transitioner && d->transitioner->populateTransition)

d->forceLayoutPolish();

d->fixupPosition();

}

if (d->model && d->model->count())

}

if (currentItem) {

if (currentItem->attached)

currentItem->attached->setIsCurrentItem(false);

currentIndex = modelIndex;

emit q->currentIndexChanged();

emit q->currentItemChanged();

releasePendingTransition.clear();

#endif

emit q->currentItemChanged();

createHighlight(onDestruction);

trackedItem = nullptr;

Q_Q(QQuickItemView);

if (!model || !model->isValid() || !q->isComponentComplete())

return;

return;

if (!model->count()) {

updateHeader();

}

if (prevCount != itemCount)

} while (currentChanges.hasPendingChanges() || bufferedChanges.hasPendingChanges());

storeFirstVisibleItemPosition();

}

// viewBounds contains bounds before any add/remove/move operation to the view

QRectF viewBounds(q->contentX(), q->contentY(), q->width(), q->height());

clear();

setPosition(contentStartOffset());

updateViewport();

if (currentChanges.currentRemoved && currentItem) {

if (currentItem->item && currentItem->attached)

currentItem->attached->setIsCurrentItem(false);

emit q->currentItemChanged();

}

if (!currentIndexCleared)

updateSections();

if (prevItemCount != itemCount)

if (!visibleAffected && viewportChanged)

updateViewport();

return flags != QQmlInstanceModel::Referenced;

}

{

}

QQuickItem *QQuickItemViewPrivate::createComponentItem(QQmlComponent *component, qreal zValue, bool createDefault) const

void mirrorChange() override;

FxViewItem *createItem(int modelIndex,QQmlIncubator::IncubationMode incubationMode = QQmlIncubator::AsynchronousIfNested);

virtual bool releaseItem(FxViewItem *item, QQmlInstanceModel::ReusableFlag reusableFlag);

QQuickItem *createComponentItem(QQmlComponent *component, qreal zValue, bool createDefault = false) const;

virtual void initializeComponentItem(QQuickItem *) const;

releaseItem(item, reusableFlag);

}

virtual QQuickItemViewAttached *getAttachedObject(const QObject *) const { return nullptr; }

QPointer<QQmlInstanceModel> model;

QQuickItemViewPrivate::fixup(data, minExtent, maxExtent);

return;

}

pos = qBound(-minExtent, pos, -maxExtent);

qreal dist = qAbs(data.move + pos);

int modelIndex = change.index;

int count = change.count;

return false;

qreal tempPos = isContentFlowReversed() ? -position()-size() : position();

continue;

}

if (index == 0)

insertResult->changedFirstItem = true;

if (change.isMove()) {

{

auto inheritedMask = m_requestedPalette.isAllocated() ? m_requestedPalette->resolveMask() | palette.resolveMask()

: palette.resolveMask();

QPalette parentPalette = m_requestedPalette.isAllocated() ? m_requestedPalette->resolve(palette) : palette;

parentPalette.setResolveMask(inheritedMask);

void QQuickPathViewPrivate::clear()

{

for (QQuickItem *p : std::as_const(items))

releaseItem(p);

? ((idx % d->modelCount) + d->modelCount) % d->modelCount

: 0;

if (d->model && (idx != d->currentIndex || !d->currentItem)) {

if (QQuickPathViewAttached *att = d->attached(d->currentItem))

att->setIsCurrentItem(false);

}

d->moveReason = QQuickPathViewPrivate::SetIndex;

d->currentIndex = idx;

if (d->modelCount) {

}

if (oldCurrentIdx != d->currentIndex)

emit currentIndexChanged();

emit currentItemChanged();

}

}

startPos = d->highlightRangeStart;

// With no items, then "end" is just off the top so we populate via append

endIdx = (qRound(d->modelCount - d->offset) - 1) % d->modelCount;

endPos = d->positionOfIndex(endIdx);

}

//Append

} else if (d->currentItem) {

if (QQuickPathViewAttached *att = d->attached(d->currentItem))

att->setIsCurrentItem(true);

}

d->currentIndex = qMin(r.index, d->modelCount - r.count - 1);

currentChanged = true;

if (currentItem) {

if (QQuickPathViewAttached *att = attached(currentItem))

att->setIsCurrentItem(false);

}

int oldCurrentIndex = currentIndex;

currentIndex = idx;

}

QQuickItem *getItem(int modelIndex, qreal z = 0, bool async=false);

void releaseItem(QQuickItem *item);

QQuickPathViewAttached *attached(QQuickItem *item);

QQmlOpenMetaObjectType *attachedType();

{

Q_D(QQuickShaderEffect);

d->inDestructor = true;

}

/*!

QQuickShaderEffectPrivate::~QQuickShaderEffectPrivate()

{

}

void QQuickShaderEffectPrivate::setFragmentShader(const QUrl &fileUrl)

//restore any absolute geometry changed by the state's anchors

QQuickAnchors::Anchors stateVAnchors = d->anchorSet->d_func()->usedAnchors & QQuickAnchors::Vertical_Mask;

QQuickAnchors::Anchors origVAnchors = targetPrivate->anchors()->usedAnchors() & QQuickAnchors::Vertical_Mask;

QQuickAnchors::Anchors stateHAnchors = d->anchorSet->d_func()->usedAnchors & QQuickAnchors::Horizontal_Mask;

QQuickAnchors::Anchors origHAnchors = targetPrivate->anchors()->usedAnchors() & QQuickAnchors::Horizontal_Mask;

const QRectF oldGeometry(d->target->position(), d->target->size());

bool stateSetWidth = (stateHAnchors &&

stateHAnchors != QQuickAnchors::LeftAnchor &&

stateHAnchors != QQuickAnchors::RightAnchor &&

stateHAnchors != QQuickAnchors::HCenterAnchor);

bool origSetWidth = (origHAnchors &&

origHAnchors != QQuickAnchors::LeftAnchor &&

origHAnchors != QQuickAnchors::RightAnchor &&

stateVAnchors != QQuickAnchors::BottomAnchor &&

stateVAnchors != QQuickAnchors::VCenterAnchor &&

stateVAnchors != QQuickAnchors::BaselineAnchor);

bool origSetHeight = (origVAnchors &&

origVAnchors != QQuickAnchors::TopAnchor &&

origVAnchors != QQuickAnchors::BottomAnchor &&

\qmlmethod real QtQuick::TableView::implicitColumnWidth(int column)

\since 6.2

*/

/*!

\qmlmethod real QtQuick::TableView::implicitRowHeight(int row)

\since 6.2

*/

/*!

Convenience function for doing:

\code

\endcode

A cell is simply a \l point that combines row and column into

a single type.

\note \c {point.x} will map to the column, and \c {point.y} will map to the row.

*/

/*!

const int nextTopRow = nextVisibleEdgeIndexAroundLoadedTable(Qt::TopEdge);

const int nextBottomRow = nextVisibleEdgeIndexAroundLoadedTable(Qt::BottomEdge);

if (syncHorizontally) {

const auto syncView_d = syncView->d_func();

origin.rx() = syncView_d->origin.x();

endExtent.rwidth() = syncView_d->endExtent.width();

} else if (nextLeftColumn == kEdgeIndexAtEnd) {

// There are no more columns to load on the left side of the table.

// In that case, we ensure that the origin match the beginning of the table.

}

}

origin.rx() = loadedTableOuterRect.left();

} else if (loadedTableOuterRect.left() <= origin.x() + cellSpacing.width()) {

// The table rect is at the origin, or outside, but we still have more

// visible columns to the left. So we try to guesstimate how much space

const qreal remainingSpacing = columnsRemaining * cellSpacing.width();

const qreal estimatedRemainingWidth = remainingColumnWidths + remainingSpacing;

origin.rx() = loadedTableOuterRect.left() - estimatedRemainingWidth;

} else if (nextRightColumn == kEdgeIndexAtEnd) {

// There are no more columns to load on the right side of the table.

// In that case, we ensure that the end of the content view match the end of the table.

}

}

endExtent.rwidth() = loadedTableOuterRect.right() - q->contentWidth();

} else if (loadedTableOuterRect.right() >= q->contentWidth() + endExtent.width() - cellSpacing.width()) {

// The right-most column is outside the end of the content view, and we

// still have more visible columns in the model. This can happen if the application

const qreal estimatedRemainingWidth = remainingColumnWidths + remainingSpacing;

const qreal pixelsOutsideContentWidth = loadedTableOuterRect.right() - q->contentWidth();

endExtent.rwidth() = pixelsOutsideContentWidth + estimatedRemainingWidth;

}

if (syncVertically) {

const auto syncView_d = syncView->d_func();

origin.ry() = syncView_d->origin.y();

endExtent.rheight() = syncView_d->endExtent.height();

} else if (nextTopRow == kEdgeIndexAtEnd) {

// There are no more rows to load on the top side of the table.

// In that case, we ensure that the origin match the beginning of the table.

}

}

origin.ry() = loadedTableOuterRect.top();

} else if (loadedTableOuterRect.top() <= origin.y() + cellSpacing.height()) {

// The table rect is at the origin, or outside, but we still have more

// visible rows at the top. So we try to guesstimate how much space

const qreal remainingSpacing = rowsRemaining * cellSpacing.height();

const qreal estimatedRemainingHeight = remainingRowHeights + remainingSpacing;

origin.ry() = loadedTableOuterRect.top() - estimatedRemainingHeight;

} else if (nextBottomRow == kEdgeIndexAtEnd) {

// There are no more rows to load on the bottom side of the table.

// In that case, we ensure that the end of the content view match the end of the table.

}

}

endExtent.rheight() = loadedTableOuterRect.bottom() - q->contentHeight();

} else if (loadedTableOuterRect.bottom() >= q->contentHeight() + endExtent.height() - cellSpacing.height()) {

// The bottom-most row is outside the end of the content view, and we

// still have more visible rows in the model. This can happen if the application

const qreal estimatedRemainingHeight = remainingRowHeigts + remainingSpacing;

const qreal pixelsOutsideContentHeight = loadedTableOuterRect.bottom() - q->contentHeight();

endExtent.rheight() = pixelsOutsideContentHeight + estimatedRemainingHeight;

}

if (tableMovedHorizontally || tableMovedVertically) {

}

}

// updateBeginningEnd() will let the new extents take effect. This will also change the

// visualArea of the flickable, which again will cause any attached scrollbars to adjust

// the position of the handle. Note the latter will cause the viewport to move once more.

updateBeginningEnd();

}

}

q->setRightMargin(syncView->rightMargin());

updateContentWidth();

}

}

q->setBottomMargin(syncView->bottomMargin());

updateContentHeight();

}

}

auto syncChild_d = syncChild->d_func();

if (syncChild_d->syncHorizontally)

w = qMax(w, syncChild->width());

h = qMax(h, syncChild->height());

}

, layoutTextElided(false), textHasChanged(true), needToUpdateLayout(false), formatModifiesFontSize(false)

, polishSize(false)

, updateSizeRecursionGuard(false)

{

implicitAntialiasing = true;

}

break;

case ItemDevicePixelRatioHasChanged:

// Native rendering optimizes for a given pixel grid, so its results must not be scaled.

// Text layout code respects the current device pixel ratio automatically, we only need

// to rerun layout after the ratio changed.

Q_D(QQuickText);

if (d->text.isEmpty()) {

delete oldNode;

return nullptr;

}

}

}

// The font caches have now been initialized on the render thread, so they have to be

// invalidated before we can use them from the main thread again.

invalidateFontCaches();

bool formatModifiesFontSize:1;

bool polishSize:1; // Workaround for problem with polish called after updateSize (QTBUG-42636)

bool updateSizeRecursionGuard:1;

static const QChar elideChar;

static const int largeTextSizeThreshold;

if (d->setHAlign(align, true) && isComponentComplete()) {

d->updateDefaultTextOption();

updateSize();

}

}

if (!hAlignImplicit && (hAlign == QQuickTextEdit::AlignRight || hAlign == QQuickTextEdit::AlignLeft)) {

updateDefaultTextOption();

q->updateSize();

emit q->effectiveHorizontalAlignmentChanged();

}

}

Q_UNUSED(value);

switch (change) {

case ItemDevicePixelRatioHasChanged:

// Native rendering optimizes for a given pixel grid, so its results must not be scaled.

// Text layout code respects the current device pixel ratio automatically, we only need

// to rerun layout after the ratio changed.

return oldNode;

}

if (!oldNode || d->updateType == QQuickTextEditPrivate::UpdateAll) {

delete oldNode;

oldNode = nullptr;

d->firstBlockInViewport = -1;

d->firstBlockPastViewport = -1;

while (!frames.isEmpty()) {

QTextFrame *textFrame = frames.takeFirst();

frames.append(textFrame->childFrames());

frameDecorationsEngine.addFrameDecorations(d->document, textFrame);

resetEngine(&engine, d->color, d->selectedTextColor, d->selectionColor);

if (textFrame->firstPosition() > textFrame->lastPosition()

}

break; // skip rest of blocks in this frame

}

d->renderedRegion = d->renderedRegion.united(coveredRegion);

}

}

bool createdNodeInView = false;

if (inView) {

if (!engine.hasContents()) {

node = d->createTextNode();

createdNodeInView = true;

updateNodeTransform(node, nodeOffset);

QList<int>::const_iterator lowerBound = std::lower_bound(frameBoundaries.constBegin(), frameBoundaries.constEnd(), block.next().position());

if (node && (currentNodeSize > nodeBreakingSize || lowerBound == frameBoundaries.constEnd() || *lowerBound > nodeStart)) {

currentNodeSize = 0;

if (!node->parent())

d->addCurrentTextNodeToRoot(&engine, rootNode, node, nodeIterator, nodeStart);

if (!createdNodeInView)

++it;

} // loop over blocks in frame

}

}

frameDecorationsEngine.addToSceneGraph(rootNode->frameDecorationsNode, QQuickText::Normal, QColor());

// Now prepend the frame decorations since we want them rendered first, with the text nodes and cursor in front.

it = textNodeMap.insert(it, TextNode(startPos, node));

++it;

root->appendChildNode(node);

}

QQuickTextNode *QQuickTextEditPrivate::createTextNode()

, selectByMouse(true), canPaste(false), canPasteValid(false), hAlignImplicit(true)

, textCached(true), inLayout(false), selectByKeyboard(false), selectByKeyboardSet(false)

, hadSelection(false), markdownText(false)

{

}

int lineCount;

int firstBlockInViewport = -1; // only for the autotest; can be wrong after scrolling sometimes

int firstBlockPastViewport = -1; // only for the autotest

QRectF renderedRegion;

enum UpdateType {

bool selectByKeyboardSet:1;

bool hadSelection : 1;

bool markdownText : 1;

static const int largeTextSizeThreshold;

};

if (d->sendMouseEventToInputContext(event))

return;

const bool isMouse = QQuickDeliveryAgentPrivate::isEventFromMouseOrTouchpad(event);

if (d->selectByMouse &&

(isMouse

// On a touchscreen or with a stylus, set cursor position and focus on release, not on press;

// if Flickable steals the grab in the meantime, the cursor won't move.

// Check d->hasSelectedText() to keep touch-and-hold word selection working.

d->moveCursor(d->positionAt(event->position()), false);

if (d->focusOnPress && qGuiApp->styleHints()->setFocusOnTouchRelease())

ensureActiveFocus(Qt::MouseFocusReason);

Q_UNUSED(value);

switch (change) {

case ItemDevicePixelRatioHasChanged:

// Native rendering optimizes for a given pixel grid, so its results must not be scaled.

// Text layout code respects the current device pixel ratio automatically, we only need

// to rerun layout after the ratio changed.

d->textLayoutDirty = false;

}

invalidateFontCaches();

return node;

, canRedo(false)

, hAlignImplicit(true)

, selectPressed(false)

, textLayoutDirty(true)

, persistentSelection(false)

, hasImState(false)

, inLayout(false)

, requireImplicitWidth(false)

, overwriteMode(false)

#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)

, selectByTouchDrag(false)

#endif

bool canRedo:1;

bool hAlignImplicit:1;

bool selectPressed:1;

bool textLayoutDirty:1;

bool persistentSelection:1;

bool hasImState : 1;

bool inLayout:1;

bool requireImplicitWidth:1;

bool overwriteMode:1;

#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)

bool selectByTouchDrag:1;

#endif

}

}

QSGGlyphNode *node = sg->sceneGraphContext()->createGlyphNode(sg, preferNativeGlyphNode, m_renderTypeQuality);

node->setOwnerElement(m_ownerElement);

void setRenderTypeQuality(int renderTypeQuality) { m_renderTypeQuality = renderTypeQuality; }

int renderTypeQuality() const { return m_renderTypeQuality; }

QPair<int, int> renderedLineRange() const { return { m_firstLineInViewport, m_firstLinePastViewport }; }

private:

int m_renderTypeQuality;

int m_firstLineInViewport = -1;

int m_firstLinePastViewport = -1;

friend class QQuickTextEdit;

friend class QQuickTextEditPrivate;

while (textPos < fragmentEnd) {

int blockRelativePosition = textPos - block.position();

QTextLine line = block.layout()->lineForTextPosition(blockRelativePosition);

if (!currentLine().isValid()

|| line.lineNumber() != currentLine().lineNumber()) {

setCurrentLine(line);

#include <private/qqmldebugserviceinterfaces_p.h>

#include <private/qqmldebugconnector_p.h>

#include <private/qsgdefaultrendercontext_p.h>

#if QT_CONFIG(opengl)

#include <private/qopengl_p.h>

#include <QOpenGLContext>

if (itemsToPolish.size() > itemsRemainingBeforeUpdatePolish) {

// Detected potential polish loop.

++numPolishLoopsInSequence;

// Start to warn about polish loop after 1000 consecutive polish loops

}

} else {

numPolishLoopsInSequence = 0;

{

Q_Q(QQuickWindow);

ensureCustomRenderTarget();

QRhiCommandBuffer *cb = nullptr;

invalidateFontData(contentItem);

}

forceUpdate(contentItem);

QSGRootNode *rootNode = new QSGRootNode;

: QSGRendererInterface::RenderMode2DNoDepthBuffer;

renderer = context->createRenderer(renderMode);

renderer->setRootNode(rootNode);

}

updateDirtyNodes();

// The confirmExitPopup allows user to save or discard the document,

// or to cancel the closing.

\endcode

*/

/*!