MnemonicAttached::MnemonicAttached(QObject *parent)
: QObject(parent)
{
QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent);
if (parentItem) {
if (parentItem->window()) {
m_window = parentItem->window();
m_window->installEventFilter(this);
}
connect(parentItem, &QQuickItem::windowChanged, this,
[this](QQuickWindow *window) {
if (m_window) {
QWindow *renderWindow = QQuickRenderControl::renderWindowFor(m_window);
if (renderWindow) {
renderWindow->removeEventFilter(this);
} else {
m_window->removeEventFilter(this);
}
}
m_window = window;
if (m_window) {
QWindow *renderWindow = QQuickRenderControl::renderWindowFor(m_window);
//renderWindow means the widget is rendering somewhere else, like a QQuickWidget
if (renderWindow && renderWindow != m_window) {
renderWindow->installEventFilter(this);
} else {
m_window->installEventFilter(this);
}
}
});
}
}
QWindow *QuickTestEvent::eventWindow(QObject *item)
{
QQuickItem *quickItem = qobject_cast<QQuickItem *>(item);
if (quickItem)
return quickItem->window();
QQuickItem *testParentitem = qobject_cast<QQuickItem *>(parent());
if (testParentitem)
return testParentitem->window();
return 0;
}
void QuickItemModel::itemReparented()
{
QQuickItem *item = qobject_cast<QQuickItem*>(sender());
if (!item || item->window() != m_window)
return;
QQuickItem* sourceParent = m_childParentMap.value(item);
Q_ASSERT(sourceParent);
const QModelIndex sourceParentIndex = indexForItem(sourceParent);
QVector<QQuickItem*> &sourceSiblings = m_parentChildMap[sourceParent];
QVector<QQuickItem*>::iterator sit = std::lower_bound(sourceSiblings.begin(), sourceSiblings.end(), item);
Q_ASSERT(sit != sourceSiblings.end() && *sit == item);
const int sourceRow = std::distance(sourceSiblings.begin(), sit);
QQuickItem* destParent = item->parentItem();
Q_ASSERT(destParent);
const QModelIndex destParentIndex = indexForItem(destParent);
QVector<QQuickItem*> &destSiblings = m_parentChildMap[destParent];
QVector<QQuickItem*>::iterator dit = std::lower_bound(destSiblings.begin(), destSiblings.end(), item);
const int destRow = std::distance(destSiblings.begin(), dit);
beginMoveRows(sourceParentIndex, sourceRow, sourceRow, destParentIndex, destRow);
destSiblings.insert(dit, item);
sourceSiblings.erase(sit);
m_childParentMap.insert(item, destParent);
endMoveRows();
}
void QuickItemModel::objectAdded(QObject* obj)
{
Q_ASSERT(thread() == QThread::currentThread());
QQuickItem *item = qobject_cast<QQuickItem*>(obj);
if (!item)
return;
if (item->window() != m_window)
return; // item for a different scene
if (m_childParentMap.contains(item))
return; // already known
QQuickItem *parentItem = item->parentItem();
if (parentItem) {
// add parent first, if we don't know that yet
if (!m_childParentMap.contains(parentItem))
objectAdded(parentItem);
}
connectItem(item);
const QModelIndex index = indexForItem(parentItem);
Q_ASSERT(index.isValid() || !parentItem);
QVector<QQuickItem*> &children = m_parentChildMap[parentItem];
QVector<QQuickItem*>::iterator it = std::lower_bound(children.begin(), children.end(), obj);
const int row = std::distance(children.begin(), it);
beginInsertRows(index, row, row);
children.insert(it, item);
m_childParentMap.insert(item, parentItem);
endInsertRows();
}
void IconDialog::open()
{
if (m_dialog->isVisible()) {
return;
}
QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent());
QQuickWindow *parentWindow = (parentItem ? parentItem->window() : qobject_cast<QQuickWindow *>(parent()));
if (m_modality == Qt::NonModal) {
m_dialog->setModal(false);
} else if (m_modality == Qt::WindowModal) {
m_dialog->winId(); // needed to get the windowHandle prior to showing
m_dialog->windowHandle()->setTransientParent(parentWindow);
m_dialog->setModal(false); // WindowModal does not unset the overall modality
} else if (m_modality == Qt::ApplicationModal) {
m_dialog->setModal(true);
}
m_dialog->setWindowModality(m_modality);
m_dialog->setup(KIconLoader::NoGroup, KIconLoader::Application, false, m_iconSize, m_user);
m_dialog->show();
}
QImage ImageHandler::extractQImage(QObject *imageObj, int offsetX, int offsetY, int width, int height)
{
QImage img;
#if defined(QZXING_QML)
#if QT_VERSION >= 0x050000
QQuickItem *item = qobject_cast<QQuickItem *>(imageObj);
if (!item || !item->window()->isVisible()) {
return QImage();
}
QTime timer;
timer.start();
QSharedPointer<QQuickItemGrabResult> result = item->grabToImage();
pendingGrabbersLocker.lockForWrite();
pendingGrabbers << result.data();
pendingGrabbersLocker.unlock();
connect(result.data(), &QQuickItemGrabResult::ready, this, &ImageHandler::imageGrabberReady);
while (timer.elapsed() < 1000) {
pendingGrabbersLocker.lockForRead();
if (!pendingGrabbers.contains(result.data())) {
pendingGrabbersLocker.unlock();
break;
}
pendingGrabbersLocker.unlock();
qApp->processEvents();
QThread::yieldCurrentThread();
}
img = result->image();
#else
QGraphicsObject *item = qobject_cast<QGraphicsObject*>(imageObj);
if (!item) {
return QImage();
}
img = QImage(item->boundingRect().size().toSize(), QImage::Format_RGB32);
img.fill(QColor(255, 255, 255).rgb());
QPainter painter(&img);
QStyleOptionGraphicsItem styleOption;
item->paint(&painter, &styleOption);
#endif
#endif //defined(QZXING_QML)
if (offsetX < 0)
offsetX = 0;
if (offsetY < 0)
offsetY = 0;
if (width < 0)
width = 0;
if (height < 0)
height = 0;
if (offsetX || offsetY || width || height)
return img.copy(offsetX, offsetY, width, height);
else
return img;
}
void QuickItemModel::itemUpdated()
{
QQuickItem *item = qobject_cast<QQuickItem*>(sender());
if (!item || item->window() != m_window)
return;
const QModelIndex left = indexForItem(item);
const QModelIndex right = left.sibling(left.row(), columnCount() - 1);
emit dataChanged(left, right);
}
static QQmlPrivate::AutoParentResult qquickitem_autoParent(QObject *obj, QObject *parent)
{
// When setting a parent (especially during dynamic object creation) in QML,
// also try to set up the analogous item/window relationship.
QQuickItem *parentItem = qmlobject_cast<QQuickItem *>(parent);
if (parentItem) {
QQuickItem *item = qmlobject_cast<QQuickItem *>(obj);
if (item) {
// An Item has another Item
item->setParentItem(parentItem);
return QQmlPrivate::Parented;
} else if (parentItem->window()) {
QQuickWindow *win = qmlobject_cast<QQuickWindow *>(obj);
if (win) {
// A Window inside an Item should be transient for that item's window
win->setTransientParent(parentItem->window());
return QQmlPrivate::Parented;
}
}
return QQmlPrivate::IncompatibleObject;
} else {
QQuickWindow *parentWindow = qmlobject_cast<QQuickWindow *>(parent);
if (parentWindow) {
QQuickWindow *win = qmlobject_cast<QQuickWindow *>(obj);
if (win) {
// A Window inside a Window should be transient for it
win->setTransientParent(parentWindow);
return QQmlPrivate::Parented;
} else {
QQuickItem *item = qmlobject_cast<QQuickItem *>(obj);
if (item) {
// The parent of an Item inside a Window is actually the implicit content Item
item->setParentItem(parentWindow->contentItem());
return QQmlPrivate::Parented;
}
}
return QQmlPrivate::IncompatibleObject;
}
}
return QQmlPrivate::IncompatibleParent;
}
QWindow* TestService::eventWindow(QObject* _item)
{
QQuickItem* item = qobject_cast<QQuickItem*>(_item);
if (item && item->window())
return item->window();
QWindow* window = qobject_cast<QQuickWindow*>(_item);
if (!window && _item->parent())
window = eventWindow(_item->parent());
if (!window)
window = qobject_cast<QQuickWindow*>(m_targetWindow);
if (window)
{
window->requestActivate();
std::cout << window->title().toStdString();
return window;
}
item = qobject_cast<QQuickItem*>(m_targetWindow);
if (item)
return item->window();
return 0;
}
QT_BEGIN_NAMESPACE
QQuickAnimatorProxyJob::QQuickAnimatorProxyJob(QAbstractAnimationJob *job, QObject *item)
: m_controller(0)
, m_job(job)
, m_internalState(State_Stopped)
, m_jobManagedByController(false)
{
m_isRenderThreadProxy = true;
m_animation = qobject_cast<QQuickAbstractAnimation *>(item);
setLoopCount(job->loopCount());
// Instead of setting duration to job->duration() we need to set it to -1 so that
// it runs as long as the job is running on the render thread. If we gave it
// an explicit duration, it would be stopped, potentially stopping the RT animation
// prematurely.
// This means that the animation driver will tick on the GUI thread as long
// as the animation is running on the render thread, but this overhead will
// be negligiblie compared to animating and re-rendering the scene on the render thread.
m_duration = -1;
QObject *ctx = findAnimationContext(m_animation);
if (!ctx) {
qWarning("QtQuick: unable to find animation context for RT animation...");
return;
}
QQuickWindow *window = qobject_cast<QQuickWindow *>(ctx);
if (window) {
setWindow(window);
} else {
QQuickItem *item = qobject_cast<QQuickItem *>(ctx);
if (item->window())
setWindow(item->window());
connect(item, SIGNAL(windowChanged(QQuickWindow*)), this, SLOT(windowChanged(QQuickWindow*)));
}
}
QPlatformColorDialogHelper *QQuickQColorDialog::helper()
{
QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent());
if (parentItem)
m_parentWindow = parentItem->window();
if (!m_dlgHelper) {
m_dlgHelper = new QColorDialogHelper();
connect(m_dlgHelper, SIGNAL(currentColorChanged(QColor)), this, SLOT(setCurrentColor(QColor)));
connect(m_dlgHelper, SIGNAL(colorSelected(QColor)), this, SLOT(setColor(QColor)));
connect(m_dlgHelper, SIGNAL(accept()), this, SLOT(accept()));
connect(m_dlgHelper, SIGNAL(reject()), this, SLOT(reject()));
}
return m_dlgHelper;
}
QPlatformDialogHelper *QQuickQMessageBox::helper()
{
QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent());
if (parentItem)
m_parentWindow = parentItem->window();
if (!QQuickAbstractMessageDialog::m_dlgHelper) {
QMessageBoxHelper* helper = new QMessageBoxHelper();
QQuickAbstractMessageDialog::m_dlgHelper = helper;
// accept() shouldn't be emitted. reject() happens only if the dialog is
// dismissed by closing the window rather than by one of its button widgets.
connect(helper, SIGNAL(accept()), this, SLOT(accept()));
connect(helper, SIGNAL(reject()), this, SLOT(reject()));
connect(helper, SIGNAL(clicked(QPlatformDialogHelper::StandardButton,QPlatformDialogHelper::ButtonRole)),
this, SLOT(click(QPlatformDialogHelper::StandardButton,QPlatformDialogHelper::ButtonRole)));
}
return QQuickAbstractMessageDialog::m_dlgHelper;
}
void MockupKeyEventDispatcher::sendKeyToFocusItem(const QString &keyText)
{
if (!m_focusItem) {
return;
}
// special handling for Backspace (send a QKeyEvent to the receiving text element)
if (keyText == QString("\x7F")) {
QKeyEvent event(QEvent::KeyPress, Qt::Key_Backspace, Qt::NoModifier);
QQuickItem *receiver = qobject_cast<QQuickItem *>(m_focusItem);
receiver->window()->sendEvent(receiver, &event);
// send the typed character to the text field using QInputMethodEvent::setCommitString()
} else {
QInputMethodEvent ev;
ev.setCommitString(keyText);
QCoreApplication::sendEvent(m_focusItem,&ev);
}
}
QPlatformFontDialogHelper *QQuickPlatformFontDialog::helper()
{
QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent());
if (parentItem)
m_parentWindow = parentItem->window();
if ( !m_dlgHelper && QGuiApplicationPrivate::platformTheme()->
usePlatformNativeDialog(QPlatformTheme::FontDialog) ) {
m_dlgHelper = static_cast<QPlatformFontDialogHelper *>(QGuiApplicationPrivate::platformTheme()
->createPlatformDialogHelper(QPlatformTheme::FontDialog));
if (!m_dlgHelper)
return m_dlgHelper;
connect(m_dlgHelper, SIGNAL(accept()), this, SLOT(accept()));
connect(m_dlgHelper, SIGNAL(reject()), this, SLOT(reject()));
connect(m_dlgHelper, SIGNAL(currentFontChanged(QFont)), this, SLOT(setFont(QFont)));
connect(m_dlgHelper, SIGNAL(fontSelected(QFont)), this, SLOT(setFont(QFont)));
}
return m_dlgHelper;
}
QPlatformFileDialogHelper *QQuickPlatformFileDialog::helper()
{
QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent());
if (parentItem)
m_parentWindow = parentItem->window();
if ( !m_dlgHelper && QGuiApplicationPrivate::platformTheme()->
usePlatformNativeDialog(QPlatformTheme::FileDialog) ) {
m_dlgHelper = static_cast<QPlatformFileDialogHelper *>(QGuiApplicationPrivate::platformTheme()
->createPlatformDialogHelper(QPlatformTheme::FileDialog));
if (!m_dlgHelper)
return m_dlgHelper;
m_dlgHelper->setOptions(m_options);
connect(m_dlgHelper, SIGNAL(directoryEntered(QUrl)), this, SIGNAL(folderChanged()));
connect(m_dlgHelper, SIGNAL(filterSelected(QString)), this, SIGNAL(filterSelected()));
connect(m_dlgHelper, SIGNAL(accept()), this, SLOT(accept()));
connect(m_dlgHelper, SIGNAL(reject()), this, SLOT(reject()));
}
return m_dlgHelper;
}
QPlatformMessageDialogHelper *QQuickPlatformMessageDialog::helper()
{
QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent());
if (parentItem)
m_parentWindow = parentItem->window();
if ( !m_dlgHelper && QGuiApplicationPrivate::platformTheme()->
usePlatformNativeDialog(QPlatformTheme::MessageDialog) ) {
m_dlgHelper = static_cast<QPlatformMessageDialogHelper *>(QGuiApplicationPrivate::platformTheme()
->createPlatformDialogHelper(QPlatformTheme::MessageDialog));
if (!m_dlgHelper)
return m_dlgHelper;
// accept() shouldn't be emitted. reject() happens only if the dialog is
// dismissed by closing the window rather than by one of its button widgets.
connect(m_dlgHelper, SIGNAL(accept()), this, SLOT(accept()));
connect(m_dlgHelper, SIGNAL(reject()), this, SLOT(reject()));
connect(m_dlgHelper, SIGNAL(clicked(QPlatformDialogHelper::StandardButton,QPlatformDialogHelper::ButtonRole)),
this, SLOT(click(QPlatformDialogHelper::StandardButton,QPlatformDialogHelper::ButtonRole)));
}
return m_dlgHelper;
}
void ScreenshotService::getScreenshot(TasCommandModel& model, TasResponse& response)
{
QListIterator<TasTarget*> i(model.targetList());
QString errorMsg = PARSE_ERROR;
QImage screenshot;
QString pictureFormat = "PNG";
while (i.hasNext()) {
TasTarget* commandTarget = i.next();
QString targetId = commandTarget->id();
QString targetType = commandTarget->type();
TasCommand* command = commandTarget->findCommand("Screenshot");
// are required for command completion
if (targetId.isEmpty() || targetType.isEmpty() || !command) {
continue;
}
if (!command->parameter("format").isEmpty()) {
pictureFormat = command->parameter("format");
}
if (!isFormatSupported(pictureFormat)) {
errorMsg = "Given format " + pictureFormat + "is not supported. Supported formats are: PNG, JPEG and BMP.";
break;
}
bool draw = (command->parameter("draw") == "true");
QWidget* widget = 0;
QQuickWindow* qtQuickWindow = 0;
WId winId = 0;
QRect rect(0,0,-1,-1);
errorMsg = "Taking screenshot failed!";
if (targetType == TYPE_GRAPHICS_VIEW) {
//TasLogger::logger()->debug("TYPE_GRAPHICS_VIEW Target id:" + targetId);
QGraphicsItem* item = findGraphicsItem(targetId);
if (item) {
QGraphicsView* view = getViewForItem(item);
if(view) {
ItemLocationDetails locationDetails = TestabilityUtils::getItemLocationDetails(item);
rect = QRect(locationDetails.windowPoint.x(),
locationDetails.windowPoint.y(),
locationDetails.width,
locationDetails.height);
if (draw) {
widget = view->window();
} else {
winId = view->window()->winId();
}
} else {
errorMsg = "Could not find a GraphicsView for the GraphicsItem!";
}
} else {
errorMsg = "Could not find the GraphicsItem!";
}
} else if (targetType == TYPE_STANDARD_VIEW) {
//TasLogger::logger()->debug("TYPE_STANDARD_VIEW about to find widget Target id:" + targetId);
widget = findWidget(targetId);
if (widget) {
if ((widget->isWindow() && !draw) || widget->inherits("QDesktopWidget")) {
winId = widget->winId();
widget = 0;
} else if (!draw) {
QPoint point = widget->mapToGlobal(QPoint(0,0));
QPoint windowPoint = widget->window()->mapFromGlobal(point);
rect = QRect(windowPoint.x(),
windowPoint.y(),
widget->rect().width(),
widget->rect().width());
winId = widget->window()->winId();
widget = 0;
}
} else {
TasLogger::logger()->debug("ScreenshotService::executeService application has no visible ui!");
errorMsg = "Application has no visible ui!";
}
} else if (targetType == TYPE_QSCENEGRAPH) {
QQuickItem* item = TestabilityUtils::findQuickItem(targetId);
if (item) {
QPointF offset = item->mapToScene(QPointF(0,0));
rect = QRect(-offset.x(), -offset.y(), item->width(), item->height());
qtQuickWindow = item->window();
}
} else {
//TasLogger::logger()->debug("TYPE_APPLICATION_VIEW about to find application window Target id:" + targetId);
widget = getApplicationWidget();
if (!widget) {
QWindow *window = getApplicationWindow();
//in case no window false, return the desktop
qtQuickWindow = qobject_cast<QQuickWindow *>(window);
if (!window) {
widget = qApp->desktop();
}
}
}
if (widget) {
screenshot = widget->grab(rect).toImage();
if (!screenshot.isNull()) {
screenshot.setText("tas_id", objectId(widget));
}
} else if (qtQuickWindow) {
screenshot = qtQuickWindow->grabWindow();
if (!screenshot.isNull()) {
screenshot.setText("tas_id", objectId(qtQuickWindow));
}
} else if (winId) {
screenshot = QPixmap::grabWindow(winId, rect.x(), rect.y(), rect.width(), rect.height()).toImage();
if (!screenshot.isNull()) {
screenshot.setText("tas_id", QString::number(winId));
}
}
break;
}
if (!screenshot.isNull()) {
QByteArray bytes;
QBuffer buffer(&bytes);
buffer.open(QIODevice::WriteOnly);
screenshot.save(&buffer, pictureFormat.toLatin1());
response.setData(bytes);
buffer.close();
} else {
response.setErrorMessage(errorMsg);
}
}
void FileSaveDialog::open()
{
if (!valid()) return;
QQuickItem *parent = this->parentItem();
Q_ASSERT(parent);
QQuickWindow *window = parent->window();
Q_ASSERT(window);
m_parentWindow = window;
m_options->setFileMode(QFileDialogOptions::AnyFile);
m_options->setAcceptMode(QFileDialogOptions::AcceptSave);
m_options->setWindowTitle(title());
m_options->setNameFilters(nameFilters());
/*
* Mac:
* Set filename incl. directory via setInitiallySelectedFiles()
*
* Windows:
* Set filename via setInitiallySelectedFiles() and let Windows choose the directory.
* Default directory: C:\\Users\XYZ\Downloads
*
* Gnome:
* Set directory via QPlatformFileDialogHelper::setDirectory() and leave
* filename empty, since QGtk2FileDialogHelper can not set non-existing filenames.
*
*/
const QString folder = QStandardPaths::writableLocation(QStandardPaths::DownloadLocation);
const QString name = filename();
#ifdef Q_OS_OSX
QUrl initialSelection = QUrl::fromLocalFile(QFileInfo(folder, name).absoluteFilePath());
qDebug() << "Initial file:" << initialSelection;
m_options->setInitiallySelectedFiles(QList<QUrl>() << initialSelection);
#endif
#ifdef Q_OS_WIN
qDebug() << "Initial filename:" << name;
m_options->setInitiallySelectedFiles(QList<QUrl>() << QUrl::fromLocalFile(name));
#endif
#ifdef Q_OS_LINUX
#if (QT_VERSION >= QT_VERSION_CHECK(5, 3, 2))
// Wohoo, big fix! https://codereview.qt-project.org/91501
QUrl initialSelection = QUrl::fromLocalFile(QFileInfo(folder, name).absoluteFilePath());
qDebug() << "Initial file:" << initialSelection;
m_options->setInitiallySelectedFiles(QList<QUrl>() << initialSelection);
#else
qDebug() << "Initial directory:" << folder;
m_dlgHelper->setDirectory(QUrl::fromLocalFile(folder));
#endif
#endif
m_dlgHelper->setOptions(m_options);
m_dlgHelper->setFilter(); // applyOptions();
Qt::WindowFlags flags = Qt::Dialog;
if (!title().isEmpty()) flags |= Qt::WindowTitleHint;
m_visible = m_dlgHelper->show(flags, m_modality, m_parentWindow);
}
void tst_applicationwindow::attachedProperties()
{
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("attachedProperties.qml"));
QScopedPointer<QObject> object(component.create());
QVERIFY2(!object.isNull(), qPrintable(component.errorString()));
QQuickApplicationWindow *window = qobject_cast<QQuickApplicationWindow *>(object.data());
QVERIFY(window);
QQuickItem *childControl = object->property("childControl").value<QQuickItem *>();
QVERIFY(childControl);
QCOMPARE(childControl->property("attached_window").value<QQuickApplicationWindow *>(), window);
QCOMPARE(childControl->property("attached_contentItem").value<QQuickItem *>(), window->contentItem());
QCOMPARE(childControl->property("attached_activeFocusControl").value<QQuickItem *>(), window->activeFocusControl());
QCOMPARE(childControl->property("attached_header").value<QQuickItem *>(), window->header());
QCOMPARE(childControl->property("attached_footer").value<QQuickItem *>(), window->footer());
QCOMPARE(childControl->property("attached_overlay").value<QQuickItem *>(), window->overlay());
QQuickItem *childItem = object->property("childItem").value<QQuickItem *>();
QVERIFY(childItem);
QCOMPARE(childItem->property("attached_window").value<QQuickApplicationWindow *>(), window);
QCOMPARE(childItem->property("attached_contentItem").value<QQuickItem *>(), window->contentItem());
QCOMPARE(childItem->property("attached_activeFocusControl").value<QQuickItem *>(), window->activeFocusControl());
QCOMPARE(childItem->property("attached_header").value<QQuickItem *>(), window->header());
QCOMPARE(childItem->property("attached_footer").value<QQuickItem *>(), window->footer());
QCOMPARE(childItem->property("attached_overlay").value<QQuickItem *>(), window->overlay());
QObject *childObject = object->property("childObject").value<QObject *>();
QVERIFY(childObject);
QVERIFY(!childObject->property("attached_window").value<QQuickApplicationWindow *>());
QVERIFY(!childObject->property("attached_contentItem").value<QQuickItem *>());
QVERIFY(!childObject->property("attached_activeFocusControl").value<QQuickItem *>());
QVERIFY(!childObject->property("attached_header").value<QQuickItem *>());
QVERIFY(!childObject->property("attached_footer").value<QQuickItem *>());
QVERIFY(!childObject->property("attached_overlay").value<QQuickItem *>());
QQuickWindow *childWindow = object->property("childWindow").value<QQuickWindow *>();
QVERIFY(childWindow);
QVERIFY(!childWindow->property("attached_window").value<QQuickApplicationWindow *>());
QVERIFY(!childWindow->property("attached_contentItem").value<QQuickItem *>());
QVERIFY(!childWindow->property("attached_activeFocusControl").value<QQuickItem *>());
QVERIFY(!childWindow->property("attached_header").value<QQuickItem *>());
QVERIFY(!childWindow->property("attached_footer").value<QQuickItem *>());
QVERIFY(!childWindow->property("attached_overlay").value<QQuickItem *>());
QQuickItem *childWindowControl = object->property("childWindowControl").value<QQuickItem *>();
QVERIFY(childWindowControl);
QVERIFY(!childWindowControl->property("attached_window").value<QQuickApplicationWindow *>());
QVERIFY(!childWindowControl->property("attached_contentItem").value<QQuickItem *>());
QVERIFY(!childWindowControl->property("attached_activeFocusControl").value<QQuickItem *>());
QVERIFY(!childWindowControl->property("attached_header").value<QQuickItem *>());
QVERIFY(!childWindowControl->property("attached_footer").value<QQuickItem *>());
QVERIFY(!childWindowControl->property("attached_overlay").value<QQuickItem *>());
QQuickItem *childWindowItem = object->property("childWindowItem").value<QQuickItem *>();
QVERIFY(childWindowItem);
QVERIFY(!childWindowItem->property("attached_window").value<QQuickApplicationWindow *>());
QVERIFY(!childWindowItem->property("attached_contentItem").value<QQuickItem *>());
QVERIFY(!childWindowItem->property("attached_activeFocusControl").value<QQuickItem *>());
QVERIFY(!childWindowItem->property("attached_header").value<QQuickItem *>());
QVERIFY(!childWindowItem->property("attached_footer").value<QQuickItem *>());
QVERIFY(!childWindowItem->property("attached_overlay").value<QQuickItem *>());
QObject *childWindowObject = object->property("childWindowObject").value<QObject *>();
QVERIFY(childWindowObject);
QVERIFY(!childWindowObject->property("attached_window").value<QQuickApplicationWindow *>());
QVERIFY(!childWindowObject->property("attached_contentItem").value<QQuickItem *>());
QVERIFY(!childWindowObject->property("attached_activeFocusControl").value<QQuickItem *>());
QVERIFY(!childWindowObject->property("attached_header").value<QQuickItem *>());
QVERIFY(!childWindowObject->property("attached_footer").value<QQuickItem *>());
QVERIFY(!childWindowObject->property("attached_overlay").value<QQuickItem *>());
QQuickApplicationWindow *childAppWindow = object->property("childAppWindow").value<QQuickApplicationWindow *>();
QVERIFY(childAppWindow);
QVERIFY(!childAppWindow->property("attached_window").value<QQuickApplicationWindow *>());
QVERIFY(!childAppWindow->property("attached_contentItem").value<QQuickItem *>());
QVERIFY(!childAppWindow->property("attached_activeFocusControl").value<QQuickItem *>());
QVERIFY(!childAppWindow->property("attached_header").value<QQuickItem *>());
QVERIFY(!childAppWindow->property("attached_footer").value<QQuickItem *>());
QVERIFY(!childAppWindow->property("attached_overlay").value<QQuickItem *>());
QQuickItem *childAppWindowControl = object->property("childAppWindowControl").value<QQuickItem *>();
QVERIFY(childAppWindowControl);
QCOMPARE(childAppWindowControl->property("attached_window").value<QQuickApplicationWindow *>(), childAppWindow);
QCOMPARE(childAppWindowControl->property("attached_contentItem").value<QQuickItem *>(), childAppWindow->contentItem());
QCOMPARE(childAppWindowControl->property("attached_activeFocusControl").value<QQuickItem *>(), childAppWindow->activeFocusControl());
QCOMPARE(childAppWindowControl->property("attached_header").value<QQuickItem *>(), childAppWindow->header());
QCOMPARE(childAppWindowControl->property("attached_footer").value<QQuickItem *>(), childAppWindow->footer());
QCOMPARE(childAppWindowControl->property("attached_overlay").value<QQuickItem *>(), childAppWindow->overlay());
QQuickItem *childAppWindowItem = object->property("childAppWindowItem").value<QQuickItem *>();
QVERIFY(childAppWindowItem);
QCOMPARE(childAppWindowItem->property("attached_window").value<QQuickApplicationWindow *>(), childAppWindow);
QCOMPARE(childAppWindowItem->property("attached_contentItem").value<QQuickItem *>(), childAppWindow->contentItem());
QCOMPARE(childAppWindowItem->property("attached_activeFocusControl").value<QQuickItem *>(), childAppWindow->activeFocusControl());
QCOMPARE(childAppWindowItem->property("attached_header").value<QQuickItem *>(), childAppWindow->header());
QCOMPARE(childAppWindowItem->property("attached_footer").value<QQuickItem *>(), childAppWindow->footer());
QCOMPARE(childAppWindowItem->property("attached_overlay").value<QQuickItem *>(), childAppWindow->overlay());
QObject *childAppWindowObject = object->property("childAppWindowObject").value<QObject *>();
QVERIFY(childAppWindowObject);
QVERIFY(!childAppWindowObject->property("attached_window").value<QQuickApplicationWindow *>());
QVERIFY(!childAppWindowObject->property("attached_contentItem").value<QQuickItem *>());
QVERIFY(!childAppWindowObject->property("attached_activeFocusControl").value<QQuickItem *>());
QVERIFY(!childAppWindowObject->property("attached_header").value<QQuickItem *>());
QVERIFY(!childAppWindowObject->property("attached_footer").value<QQuickItem *>());
QVERIFY(!childAppWindowObject->property("attached_overlay").value<QQuickItem *>());
window->show();
window->requestActivate();
QVERIFY(QTest::qWaitForWindowActive(window));
QVERIFY(!childControl->hasActiveFocus());
childControl->forceActiveFocus();
QTRY_VERIFY(childControl->hasActiveFocus());
QCOMPARE(window->activeFocusItem(), childControl);
QCOMPARE(childControl->property("attached_activeFocusControl").value<QQuickItem *>(), childControl);
QQuickItem *header = new QQuickItem;
window->setHeader(header);
QCOMPARE(window->header(), header);
QCOMPARE(childControl->property("attached_header").value<QQuickItem *>(), header);
QQuickItem *footer = new QQuickItem;
window->setFooter(footer);
QCOMPARE(window->footer(), footer);
QCOMPARE(childControl->property("attached_footer").value<QQuickItem *>(), footer);
childAppWindow->show();
childAppWindow->requestActivate();
QVERIFY(QTest::qWaitForWindowActive(childAppWindow));
QVERIFY(!childAppWindowControl->hasActiveFocus());
childAppWindowControl->forceActiveFocus();
QTRY_VERIFY(childAppWindowControl->hasActiveFocus());
QCOMPARE(childAppWindow->activeFocusItem(), childAppWindowControl);
QCOMPARE(childAppWindowControl->property("attached_activeFocusControl").value<QQuickItem *>(), childAppWindowControl);
childControl->setParentItem(childAppWindow->contentItem());
QCOMPARE(childControl->window(), childAppWindow);
QCOMPARE(childControl->property("attached_window").value<QQuickApplicationWindow *>(), childAppWindow);
QCOMPARE(childControl->property("attached_contentItem").value<QQuickItem *>(), childAppWindow->contentItem());
QCOMPARE(childControl->property("attached_activeFocusControl").value<QQuickItem *>(), childAppWindow->activeFocusControl());
QCOMPARE(childControl->property("attached_header").value<QQuickItem *>(), childAppWindow->header());
QCOMPARE(childControl->property("attached_footer").value<QQuickItem *>(), childAppWindow->footer());
QCOMPARE(childControl->property("attached_overlay").value<QQuickItem *>(), childAppWindow->overlay());
childItem->setParentItem(childAppWindow->contentItem());
QCOMPARE(childItem->window(), childAppWindow);
QCOMPARE(childItem->property("attached_window").value<QQuickApplicationWindow *>(), childAppWindow);
QCOMPARE(childItem->property("attached_contentItem").value<QQuickItem *>(), childAppWindow->contentItem());
QCOMPARE(childItem->property("attached_activeFocusControl").value<QQuickItem *>(), childAppWindow->activeFocusControl());
QCOMPARE(childItem->property("attached_header").value<QQuickItem *>(), childAppWindow->header());
QCOMPARE(childItem->property("attached_footer").value<QQuickItem *>(), childAppWindow->footer());
QCOMPARE(childItem->property("attached_overlay").value<QQuickItem *>(), childAppWindow->overlay());
childControl->setParentItem(Q_NULLPTR);
QVERIFY(!childControl->window());
QVERIFY(!childControl->property("attached_window").value<QQuickApplicationWindow *>());
QVERIFY(!childControl->property("attached_contentItem").value<QQuickItem *>());
QVERIFY(!childControl->property("attached_activeFocusControl").value<QQuickItem *>());
QVERIFY(!childControl->property("attached_header").value<QQuickItem *>());
QVERIFY(!childControl->property("attached_footer").value<QQuickItem *>());
QVERIFY(!childControl->property("attached_overlay").value<QQuickItem *>());
childItem->setParentItem(Q_NULLPTR);
QVERIFY(!childItem->window());
QVERIFY(!childItem->property("attached_window").value<QQuickApplicationWindow *>());
QVERIFY(!childItem->property("attached_contentItem").value<QQuickItem *>());
QVERIFY(!childItem->property("attached_activeFocusControl").value<QQuickItem *>());
QVERIFY(!childItem->property("attached_header").value<QQuickItem *>());
QVERIFY(!childItem->property("attached_footer").value<QQuickItem *>());
QVERIFY(!childItem->property("attached_overlay").value<QQuickItem *>());
// ### A temporary workaround to unblock the CI until the crash caused
// by https://codereview.qt-project.org/#/c/108517/ has been fixed...
window->hide();
qApp->processEvents();
}
