void tst_qquickfocusscope::nested()
{
QQuickView *view = new QQuickView;
view->setSource(testFileUrl("test2.qml"));
QQuickFocusScope *item1 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item1"));
QQuickFocusScope *item2 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item2"));
QQuickFocusScope *item3 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item3"));
QQuickFocusScope *item4 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item4"));
QQuickFocusScope *item5 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item5"));
QVERIFY(item1 != 0);
QVERIFY(item2 != 0);
QVERIFY(item3 != 0);
QVERIFY(item4 != 0);
QVERIFY(item5 != 0);
view->show();
view->requestActivate();
QTest::qWaitForWindowActive(view);
QTRY_VERIFY(view == qGuiApp->focusWindow());
QVERIFY(item1->hasActiveFocus() == true);
QVERIFY(item2->hasActiveFocus() == true);
QVERIFY(item3->hasActiveFocus() == true);
QVERIFY(item4->hasActiveFocus() == true);
QVERIFY(item5->hasActiveFocus() == true);
delete view;
}
void tst_qquickfocusscope::signalEmission()
{
QQuickView *view = new QQuickView;
view->setSource(testFileUrl("signalEmission.qml"));
QQuickRectangle *item1 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item1"));
QQuickRectangle *item2 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item2"));
QQuickRectangle *item3 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item3"));
QQuickRectangle *item4 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item4"));
QVERIFY(item1 != 0);
QVERIFY(item2 != 0);
QVERIFY(item3 != 0);
QVERIFY(item4 != 0);
view->show();
view->requestActivate();
QTest::qWaitForWindowActive(view);
QTRY_VERIFY(view == qGuiApp->focusWindow());
QVariant blue(QColor("blue"));
QVariant red(QColor("red"));
item1->setFocus(true);
QCOMPARE(item1->property("color"), red);
QCOMPARE(item2->property("color"), blue);
QCOMPARE(item3->property("color"), blue);
QCOMPARE(item4->property("color"), blue);
item2->setFocus(true);
QCOMPARE(item1->property("color"), blue);
QCOMPARE(item2->property("color"), red);
QCOMPARE(item3->property("color"), blue);
QCOMPARE(item4->property("color"), blue);
item3->setFocus(true);
QCOMPARE(item1->property("color"), blue);
QCOMPARE(item2->property("color"), red);
QCOMPARE(item3->property("color"), red);
QCOMPARE(item4->property("color"), blue);
item4->setFocus(true);
QCOMPARE(item1->property("color"), blue);
QCOMPARE(item2->property("color"), red);
QCOMPARE(item3->property("color"), blue);
QCOMPARE(item4->property("color"), red);
item4->setFocus(false);
QCOMPARE(item1->property("color"), blue);
QCOMPARE(item2->property("color"), red);
QCOMPARE(item3->property("color"), blue);
QCOMPARE(item4->property("color"), blue);
delete view;
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
// If you want to use an engine, this shows how to get an UI Element!:
// QQmlApplicationEngine engine;
// engine.load(QUrl(QStringLiteral("qrc:/game.qml")));
// QObject root = engine.rootObjects().first();
// QObject element = root.findChild("element");
// element.setProperty("color","red");
//Creating Objects from Qml in C++ with QQuickView
//http://stackoverflow.com/questions/14092319/create-qml-element-in-c
QQuickView view;
//Background
view.setResizeMode(QQuickView::SizeRootObjectToView);
view.setSource(QUrl("qrc:///game.qml"));
//Spaceshuttle
QQmlComponent component(view.engine(), QUrl("qrc:///shuttle.qml"));
QObject *shuttle = component.create();
//Components are only drawn if parent is somehow related to the root view
QQmlProperty::write(shuttle, "parent", QVariant::fromValue<QObject*>(view.rootObject()));
//some sample "Astroids" - ( wrong Image ;) )
QVector<QObject*> astroids(0);
for(int i = 0; i < 5; i++){
QQmlComponent fireballComponent(view.engine(), QUrl("qrc:///fireball.qml"));
astroids.append(fireballComponent.create());
QQmlProperty::write(astroids[i], "parent", QVariant::fromValue<QObject*>(view.rootObject()));
QQmlProperty::write(astroids[i], "x", i*50);
QQmlProperty::write(astroids[i], "y", i*50);
}
//QQmlEngine::setObjectOwnership(object, QQmlEngine::CppOwnership);
qDebug() << shuttle->property("id").toString();
Logger logger;
logger.setQObject(shuttle);
QObject::connect(shuttle, SIGNAL(xChanged()), &logger, SLOT(showCoordinates()));
view.show();
return app.exec();
}
void tst_qquickfocusscope::textEdit()
{
QQuickView *view = new QQuickView;
view->setSource(testFileUrl("test5.qml"));
QQuickFocusScope *item0 = findItem<QQuickFocusScope>(view->rootObject(), QLatin1String("item0"));
QQuickTextEdit *item1 = findItem<QQuickTextEdit>(view->rootObject(), QLatin1String("item1"));
QQuickRectangle *item2 = findItem<QQuickRectangle>(view->rootObject(), QLatin1String("item2"));
QQuickTextEdit *item3 = findItem<QQuickTextEdit>(view->rootObject(), QLatin1String("item3"));
QVERIFY(item0 != 0);
QVERIFY(item1 != 0);
QVERIFY(item2 != 0);
QVERIFY(item3 != 0);
view->show();
view->requestActivate();
QTest::qWaitForWindowActive(view);
QTRY_VERIFY(view == qGuiApp->focusWindow());
QVERIFY(item0->hasActiveFocus() == true);
QVERIFY(item1->hasActiveFocus() == true);
QVERIFY(item2->hasActiveFocus() == false);
QVERIFY(item3->hasActiveFocus() == false);
QTest::keyClick(view, Qt::Key_Right);
QVERIFY(item0->hasActiveFocus() == true);
QVERIFY(item1->hasActiveFocus() == true);
QVERIFY(item2->hasActiveFocus() == false);
QVERIFY(item3->hasActiveFocus() == false);
QTest::keyClick(view, Qt::Key_Right);
QTest::keyClick(view, Qt::Key_Right);
QTest::keyClick(view, Qt::Key_Right);
QTest::keyClick(view, Qt::Key_Right);
QTest::keyClick(view, Qt::Key_Right);
QVERIFY(item0->hasActiveFocus() == true);
QVERIFY(item1->hasActiveFocus() == false);
QVERIFY(item2->hasActiveFocus() == true);
QVERIFY(item3->hasActiveFocus() == false);
QTest::keyClick(view, Qt::Key_Down);
QVERIFY(item0->hasActiveFocus() == false);
QVERIFY(item1->hasActiveFocus() == false);
QVERIFY(item2->hasActiveFocus() == false);
QVERIFY(item3->hasActiveFocus() == true);
delete view;
}
void tst_qquickspritesequence::test_framerateAdvance()
{
QQuickView *window = new QQuickView(0);
window->setSource(testFileUrl("advance.qml"));
window->show();
QVERIFY(QTest::qWaitForWindowExposed(window));
QVERIFY(window->rootObject());
QQuickSpriteSequence* sprite = window->rootObject()->findChild<QQuickSpriteSequence*>("sprite");
QVERIFY(sprite);
QTRY_COMPARE(sprite->currentSprite(), QLatin1String("secondState"));
delete window;
}
/*------------------------------------------------------------------------------
| main
+-----------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
QApplication::setAttribute(Qt::AA_ShareOpenGLContexts, true);
QApplication a(argc, argv);
QStringList args = a.arguments();
const bool opengl = !args.contains("--no-opengl");
args.removeAll("--no-opengl");
if (opengl) {
qDebug("QML QtWebEngine...");
QQuickView* view = new QQuickView;
view->setSource(QUrl("qrc:/poc_main.qml"));
view->showFullScreen();
QObject* o = view->rootObject()->findChild<QObject*>("webEngineView");
o->setProperty("url", args.at(1));
}
else {
qDebug("Widget QtWebEngine...");
QWebEngineView* view = new QWebEngineView;
view->load(QUrl(args.at(1)));
view->show();
}
return a.exec();
}
MsmWindow::MsmWindow(QWidget *parent) :
QMainWindow(parent)
{
// Prepare the view area
stackedWidget = new QStackedWidget(this);
setCentralWidget(stackedWidget);
QQuickView *view = new QQuickView();
menuView = QWidget::createWindowContainer(view, this);
menuView->setFocusPolicy(Qt::TabFocus);
view->setSource(QUrl("qrc:/qml/main.qml"));
stackedWidget->addWidget(menuView);
stackedWidget->setCurrentWidget(menuView);
moduleView = new ModuleView();
stackedWidget->addWidget(moduleView);
QQuickItem *rootObject = view->rootObject();
QQuickItem::connect(rootObject, SIGNAL(itemClicked(QString)),
this, SLOT(loadModule(QString)));
ModuleView::connect(moduleView, &ModuleView::closeRequest,
[=]() {
moduleView->resolveChanges();
moduleView->closeModules();
stackedWidget->setCurrentWidget(menuView);
});
init();
readPositionSettings();
}
void tst_qquickcustomaffector::test_move()
{
QQuickView* view = createView(testFileUrl("move.qml"), 600);
QQuickParticleSystem* system = view->rootObject()->findChild<QQuickParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
QVERIFY(extremelyFuzzyCompare(system->groupData[0]->size(), 500, 10));
for (QQuickParticleData *d : qAsConst(system->groupData[0]->data)) {
if (d->t == -1)
continue; //Particle data unused
if (!d->stillAlive(system))
continue; //parameters no longer get set once you die
QVERIFY2(myFuzzyCompare(d->curX(system), 50.0), QByteArray::number(d->curX(system)));
QVERIFY2(myFuzzyCompare(d->curY(system), 50.0), QByteArray::number(d->curY(system)));
QVERIFY2(myFuzzyCompare(d->curVX(system), 50.0), QByteArray::number(d->curVX(system)));
QVERIFY2(myFuzzyCompare(d->curVY(system), 50.0), QByteArray::number(d->curVY(system)));
QVERIFY2(myFuzzyCompare(d->curAX(), 50.0), QByteArray::number(d->curAX()));
QVERIFY2(myFuzzyCompare(d->curAY(), 50.0), QByteArray::number(d->curAY()));
QCOMPARE(d->lifeSpan, 0.5f);
QCOMPARE(d->size, 32.f);
QCOMPARE(d->endSize, 32.f);
QVERIFY2(myFuzzyLEQ(d->t, ((qreal)system->timeInt/1000.0)),
QString::fromLatin1("%1 <= %2 / 1000").arg(d->t).arg(system->timeInt).toUtf8());
}
delete view;
}
int main(int argc, char **argv)
{
QGuiApplication app(argc, argv);
qmlRegisterType<QVTKFrameBufferObjectItem>("VtkQuick", 1, 0, "VtkRenderWindow");
QQuickView view;
view.setSource(QUrl("qrc:///main.qml"));
QList<QVTKFrameBufferObjectItem*> vtkItems = view.rootObject()->findChildren<QVTKFrameBufferObjectItem*>();
// For demonstration: Add a cone to the scene of each QVTKFrameBufferObjectItem
Q_FOREACH(QVTKFrameBufferObjectItem *vtkItem, vtkItems)
{
vtkGenericOpenGLRenderWindow *r_win = vtkItem->GetRenderWindow();
vtkSmartPointer<vtkConeSource> cone = vtkSmartPointer<vtkConeSource>::New();
//cone->SetHeight(3.0);
//cone->SetRadius(1.0);
cone->SetResolution(100);
vtkSmartPointer<vtkPolyDataMapper> coneMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
coneMapper->SetInputConnection(cone->GetOutputPort());
vtkSmartPointer<vtkActor> coneActor = vtkSmartPointer<vtkActor>::New();
coneActor->SetMapper(coneMapper);
vtkSmartPointer<vtkRenderer> ren1 = vtkSmartPointer<vtkRenderer>::New();
ren1->AddActor(coneActor);
r_win->AddRenderer(ren1);
}
void tst_qquickpointdirection::test_basic()
{
QQuickView* view = createView(testFileUrl("basic.qml"), 600);
QQuickParticleSystem* system = view->rootObject()->findChild<QQuickParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
QVERIFY(extremelyFuzzyCompare(system->groupData[0]->size(), 500, 10));
for (QQuickParticleData *d : qAsConst(system->groupData[0]->data)) {
if (d->t == -1)
continue; //Particle data unused
QCOMPARE(d->x, 0.f);
QCOMPARE(d->y, 0.f);
QCOMPARE(d->vx, 100.f);
QCOMPARE(d->vy, 100.f);
QVERIFY(d->ax >= 0.f);
QVERIFY(d->ax <= 200.f);
QVERIFY(d->ay >= 0.f);
QVERIFY(d->ay <= 200.f);
QCOMPARE(d->lifeSpan, 0.5f);
QCOMPARE(d->size, 32.f);
QCOMPARE(d->endSize, 32.f);
QVERIFY(myFuzzyLEQ(d->t, ((qreal)system->timeInt/1000.0)));
}
delete view;
}
int main(int argc, char **argv)
{
QGuiApplication *app = SailfishApp::application(argc, argv);
qmlRegisterType<Mainview>("harbour.monav", 1, 0, "Mainview");
qmlRegisterType<TapMenu>("harbour.monav", 1, 0, "TapMenu");
qmlRegisterType<MapPackages>("harbour.monav", 1, 0, "MapPackages");
qmlRegisterType<Bookmarks>("harbour.monav", 1, 0, "Bookmarks");
qmlRegisterType<PaintWidget>("harbour.monav", 1, 0, "PaintWidget");
qmlRegisterType<WorldMapChooser>("harbour.monav", 1, 0, "WorldMapChooser");
QQuickView *view = SailfishApp::createView();
view->setSource(SailfishApp::pathTo("qml/Main.qml"));
view->show();
view->setResizeMode(QQuickView::SizeRootObjectToView);
QObject *object = (QObject *) view->rootObject();
Mainview *mainview = object->findChild<Mainview *>("mainview");
mainview->init();
app->connect( app, SIGNAL(aboutToQuit()), MapData::instance(), SLOT(cleanup()) );
app->connect( app, SIGNAL(aboutToQuit()), RoutingLogic::instance(), SLOT(cleanup()) );
app->connect( app, SIGNAL(aboutToQuit()), Logger::instance(), SLOT(cleanup()) );
app->connect( app, SIGNAL(aboutToQuit()), mainview, SLOT(cleanup()) );
return app->exec();
}
void tst_QQuickGraphicsInfo::testProperties()
{
QQuickView view;
view.setSource(QUrl("data/basic.qml"));
view.show();
QVERIFY(QTest::qWaitForWindowExposed(&view));
QSignalSpy spy(&view, SIGNAL(sceneGraphInitialized()));
spy.wait();
QObject* obj = view.rootObject();
QVERIFY(obj);
QSGRendererInterface *rif = view.rendererInterface();
const int expectedAPI = rif ? rif->graphicsApi() : QSGRendererInterface::Unknown;
QCOMPARE(obj->property("api").toInt(), expectedAPI);
#if QT_CONFIG(opengl)
if (expectedAPI == QSGRendererInterface::OpenGL) {
QCOMPARE(obj->property("shaderType").toInt(), int(QSGRendererInterface::GLSL));
QVERIFY(view.openglContext());
QSurfaceFormat format = view.openglContext()->format();
QCOMPARE(obj->property("majorVersion").toInt(), format.majorVersion());
QCOMPARE(obj->property("minorVersion").toInt(), format.minorVersion());
QCOMPARE(obj->property("profile").toInt(), static_cast<int>(format.profile()));
QCOMPARE(obj->property("renderableType").toInt(), static_cast<int>(format.renderableType()));
}
#endif
}
void tst_qquickcustomaffector::test_basic()
{
QQuickView* view = createView(testFileUrl("basic.qml"), 600);
QQuickParticleSystem* system = view->rootObject()->findChild<QQuickParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
QVERIFY(extremelyFuzzyCompare(system->groupData[0]->size(), 500, 10));
for (QQuickParticleData *d : qAsConst(system->groupData[0]->data)) {
if (d->t == -1)
continue; //Particle data unused
//in CI the whole simulation often happens at once, so dead particles end up missing out
if (!d->stillAlive(system))
continue; //parameters no longer get set once you die
QCOMPARE(d->x, 100.f);
QCOMPARE(d->y, 100.f);
QCOMPARE(d->vx, 100.f);
QCOMPARE(d->vy, 100.f);
QCOMPARE(d->ax, 100.f);
QCOMPARE(d->ay, 100.f);
QCOMPARE(d->lifeSpan, 0.5f);
QCOMPARE(d->size, 100.f);
QCOMPARE(d->endSize, 100.f);
QCOMPARE(d->autoRotate, 1.f);
QCOMPARE(d->color.r, (uchar)0);
QCOMPARE(d->color.g, (uchar)255);
QCOMPARE(d->color.b, (uchar)0);
QCOMPARE(d->color.a, (uchar)0);
QVERIFY(myFuzzyLEQ(d->t, ((qreal)system->timeInt/1000.0)));
}
delete view;
}
void Fix8Log::aboutSlot()
{
QDialog *aboutDialog = new QDialog();
QVBoxLayout *aboutLayout = new QVBoxLayout(0);
QDialogButtonBox *dialogButtonBox = new QDialogButtonBox();
dialogButtonBox->addButton(QDialogButtonBox::Ok);
connect(dialogButtonBox,SIGNAL(clicked(QAbstractButton*)),
aboutDialog,SLOT(close()));
QQuickView *aboutView = new QQuickView(QUrl("qrc:qml/helpAbout.qml"));
QQuickItem *qmlObject = aboutView->rootObject();
qmlObject->setProperty("color",aboutDialog->palette().color(QPalette::Window));
qmlObject->setProperty("bgColor",aboutDialog->palette().color(QPalette::Window));
qmlObject->setProperty("version",QString::number(Globals::version));
aboutView->setResizeMode(QQuickView::SizeRootObjectToView);
QWidget *aboutWidget = QWidget::createWindowContainer(aboutView,0);
aboutWidget->setPalette(aboutDialog->palette());
aboutWidget->setAutoFillBackground(false);
aboutDialog->setLayout(aboutLayout);
aboutLayout->addWidget(aboutWidget,1);
aboutLayout->addWidget(dialogButtonBox,0);
aboutDialog->resize(500,400);
aboutDialog->setWindowTitle(GUI::Globals::appName);
aboutDialog->exec();
aboutDialog->deleteLater();
}
void MainWindow::updateView()
{
QSurfaceFormat format;
format.setDepthBufferSize(16);
format.setStencilBufferSize(8);
if (m_transparent)
format.setAlphaBufferSize(8);
if (m_checkboxMultiSample->isChecked())
format.setSamples(4);
State state = m_radioView->isChecked() ? UseWindow : UseWidget;
if (m_format == format && m_state == state)
return;
m_format = format;
m_state = state;
QString text = m_currentRootObject
? m_currentRootObject->property("currentText").toString()
: QStringLiteral("Hello Qt");
QUrl source("qrc:qquickviewcomparison/test.qml");
if (m_state == UseWindow) {
QQuickView *quickView = new QQuickView;
// m_transparent is not supported here since many systems have problems with semi-transparent child windows
quickView->setFormat(m_format);
quickView->setResizeMode(QQuickView::SizeRootObjectToView);
connect(quickView, &QQuickView::statusChanged, this, &MainWindow::onStatusChangedView);
connect(quickView, &QQuickView::sceneGraphError, this, &MainWindow::onSceneGraphError);
quickView->setSource(source);
m_currentRootObject = quickView->rootObject();
switchTo(QWidget::createWindowContainer(quickView));
} else if (m_state == UseWidget) {
QQuickWidget *quickWidget = new QQuickWidget;
if (m_transparent) {
quickWidget->setClearColor(Qt::transparent);
quickWidget->setAttribute(Qt::WA_TranslucentBackground);
}
quickWidget->setFormat(m_format);
quickWidget->setResizeMode(QQuickWidget::SizeRootObjectToView);
connect(quickWidget, &QQuickWidget::statusChanged, this, &MainWindow::onStatusChangedWidget);
connect(quickWidget, &QQuickWidget::sceneGraphError, this, &MainWindow::onSceneGraphError);
quickWidget->setSource(source);
m_currentRootObject = quickWidget->rootObject();
switchTo(quickWidget);
}
if (m_currentRootObject) {
m_currentRootObject->setProperty("currentText", text);
m_currentRootObject->setProperty("multisample", m_checkboxMultiSample->isChecked());
m_currentRootObject->setProperty("translucency", m_transparent);
}
m_overlayLabel->raise();
}
void HtmlEditor::on_actionTextShadow_triggered()
{
QQuickView* view = new QQuickView(QUrl::fromLocalFile(qmlFilePath("text_shadow.qml")));
view->setTitle(tr("Text Shadow"));
view->setColor(palette().window().color());
connect(view->rootObject(), SIGNAL(accepted(QString)), SLOT(formatTextShadow(QString)));
connect(view->engine(), SIGNAL(quit()), view, SLOT(close()));
view->show();
}
void tst_qquickspritesequence::test_huge()
{
/* Merely tests that it doesn't crash, as waiting for it to complete
(or even having something to watch) would bloat CI.
The large allocations of memory involved and separate codepath does make
a doesn't crash test worthwhile.
*/
QQuickView *window = new QQuickView(0);
window->setSource(testFileUrl("huge.qml"));
window->show();
QVERIFY(QTest::qWaitForWindowExposed(window));
QVERIFY(window->rootObject());
QQuickSpriteSequence* sprite = window->rootObject()->findChild<QQuickSpriteSequence*>("sprite");
QVERIFY(sprite);
delete window;
}
void tst_qquickfocusscope::noParentFocus()
{
QQuickView *view = new QQuickView;
view->setSource(testFileUrl("chain.qml"));
QVERIFY(view->rootObject());
view->show();
view->requestActivate();
QTest::qWaitForWindowActive(view);
QTRY_VERIFY(view == qGuiApp->focusWindow());
QVERIFY(view->rootObject()->property("focus1") == false);
QVERIFY(view->rootObject()->property("focus2") == false);
QVERIFY(view->rootObject()->property("focus3") == true);
QVERIFY(view->rootObject()->property("focus4") == true);
QVERIFY(view->rootObject()->property("focus5") == true);
delete view;
}
QQuickItem *PaperManager::createPaper()
{
QVariant parent = QVariant::fromValue<QQuickItem*>(this);
QVariant res;
QQuickView *view = static_cast<QQuickView*>(window());
QMetaObject::invokeMethod( view->rootObject(), "createPaper", Q_RETURN_ARG(QVariant, res), Q_ARG(QVariant,parent));
return res.value<QQuickItem*>();
}
void tst_qquickfocusscope::qtBug13380()
{
QQuickView *view = new QQuickView;
view->setSource(testFileUrl("qtBug13380.qml"));
view->show();
QVERIFY(view->rootObject());
view->requestActivate();
qApp->processEvents();
QVERIFY(QTest::qWaitForWindowExposed(view));
QTRY_VERIFY(view == qGuiApp->focusWindow());
QVERIFY(view->rootObject()->property("noFocus").toBool());
view->rootObject()->setProperty("showRect", true);
QVERIFY(view->rootObject()->property("noFocus").toBool());
delete view;
}
void tst_qquickcustomaffector::test_affectedSignal()
{
QQuickView* view = createView(testFileUrl("affectedSignal.qml"), 600);
QQuickParticleSystem* system = view->rootObject()->findChild<QQuickParticleSystem*>("system");
ensureAnimTime(600, system->m_animation);
QCOMPARE(system->property("resultX1").toInt(), 0);
QCOMPARE(system->property("resultY1").toInt(), 100);
QCOMPARE(system->property("resultX2").toInt(), 1234);
QCOMPARE(system->property("resultY2").toInt(), 1234);
delete view;
}
void tst_qquickanimatedsprite::test_runningChangedSignal()
{
QQuickView *window = new QQuickView(0);
window->setSource(testFileUrl("runningChange.qml"));
window->show();
QVERIFY(QTest::qWaitForWindowExposed(window));
QVERIFY(window->rootObject());
QQuickAnimatedSprite* sprite = window->rootObject()->findChild<QQuickAnimatedSprite*>("sprite");
QVERIFY(sprite);
QVERIFY(!sprite->running());
QSignalSpy runningChangedSpy(sprite, SIGNAL(runningChanged(bool)));
sprite->setRunning(true);
QTRY_COMPARE(runningChangedSpy.count(), 1);
QTRY_VERIFY(!sprite->running());
QTRY_COMPARE(runningChangedSpy.count(), 2);
delete window;
}
void tst_qquickspritesequence::test_properties()
{
QQuickView *window = new QQuickView(0);
window->setSource(testFileUrl("basic.qml"));
window->show();
QVERIFY(QTest::qWaitForWindowExposed(window));
QVERIFY(window->rootObject());
QQuickSpriteSequence* sprite = window->rootObject()->findChild<QQuickSpriteSequence*>("sprite");
QVERIFY(sprite);
QVERIFY(sprite->running());
QVERIFY(sprite->interpolate());
sprite->setRunning(false);
QVERIFY(!sprite->running());
sprite->setInterpolate(false);
QVERIFY(!sprite->interpolate());
delete window;
}
Papyrus *PaperManager::getPapyrus()
{
if( p->papyrus )
return p->papyrus;
QVariant res;
QQuickView *view = static_cast<QQuickView*>(window());
QMetaObject::invokeMethod( view->rootObject(), "getPapyrus", Q_RETURN_ARG(QVariant, res));
p->papyrus = res.value<Papyrus*>();
return p->papyrus;
}
main_page::main_page(QWidget *parent, QWidget * context) :
QWidget(parent),
ui(new Ui::main_page)
{
ui->setupUi(parent);
xiamiapi::IGenericArray *recommend_list;
this->context = context;
auto api = ((MainWindow *)(context))->api;
api->GetRecommendCollection(&recommend_list);
std::vector<CarouselCollectionModelObject> list_data;
for (uint64_t i = 0; i < recommend_list->length(); ++i)
{
xiamiapi::IXiamiCollectionInfo* info;
recommend_list->get_element(i)->QueryInterface(recommend_list->ElementIID(), (void **)&info);
std::string logo = info->get_logo();
// logo.replace(logo.rfind("_1"), 2, "_5");
list_data.push_back(CarouselCollectionModelObject{info->get_list_id(), logo.c_str(), info->get_collect_name()});
info->Release();
}
recommend_list->Release();
QQuickView *view = new QQuickView();
CarouselCollectionListViewModel * model = new CarouselCollectionListViewModel(parent);
model->setItem(std::move(list_data));
QQmlContext* ctxt = view->rootContext();
ctxt->setContextProperty("collectionModel", model);
api->GetRecommendPlaylist(&recommend_list);
std::vector<CarouselCollectionModelObject> playlist_data;
for (uint64_t i = 0; i < recommend_list->length(); ++i)
{
xiamiapi::IXiamiPlaylistInfo* info;
recommend_list->get_element(i)->QueryInterface(recommend_list->ElementIID(), (void **)&info);
std::string logo = info->get_album_logo();
logo.replace(logo.rfind("_1"), 2, "_5");
playlist_data.push_back(CarouselCollectionModelObject{info->get_album_id(), logo.c_str(), info->get_album_name()});
info->Release();
}
CarouselCollectionListViewModel * album_model = new CarouselCollectionListViewModel(parent);
album_model->setItem(std::move(playlist_data));
ctxt->setContextProperty("albumModel", album_model);
view->setSource(QUrl("qrc:/carousel.qml"));
QWidget *container = QWidget::createWindowContainer(view, this);
QObject *item = view->rootObject();
connect(item, SIGNAL(albumClicked(int)), this, SLOT(playAlbum(int)));
connect(item, SIGNAL(collectionClicked(int)), this, SLOT(playCollection(int)));
ui->horizontalLayout->addWidget(container);
}
int main(int argc, char** argv) {
// Initialize the Qt Application
QGuiApplication app(argc, argv);
// Register the HullRenderer QML Type
qmlRegisterType<HullRenderer>("com.nearce.HullRenderer", 1, 0, "HullRenderer");
// Establish the Qt Quick View
QQuickView view;
// Create the algorithm objecsts
GrahamScan grahamScan;
JarvisMarch jarvisMarch;
// Create the input genration objects
RandomPointInput randomPointInput(50, 1000);
CircularPointInput circularPointInput(50, 1000);
// Establish list of avalible alogrithms & inputs for the Hull Solver
QMap<QString, HullAlgorithm*> algorithms({
{grahamScan.name(), &grahamScan},
{jarvisMarch.name(), &jarvisMarch}
});
QMap<QString, DataInput*> inputs({
{randomPointInput.name(), &randomPointInput},
{circularPointInput.name(), &circularPointInput}
});
HullSolver solver(algorithms, inputs);
// Inject some C++ objects into the QML document structure
view.engine()->rootContext()->setContextProperty("random_input", &randomPointInput);
view.engine()->rootContext()->setContextProperty("circular_input", &circularPointInput);
view.engine()->rootContext()->setContextProperty("hull_solver", &solver);
// Establish a dynamicly resizing content resize policy & display the QML window
view.setResizeMode(QQuickView::SizeRootObjectToView);
view.setSource(QUrl("qrc:///resources/main.qml"));
view.showMaximized();
// Create a signal slot connection between the HullRenderer QML object
// and the hull solver in C++ for convience
HullRenderer* renderer = view.rootObject()->findChild<HullRenderer*>("renderer");
QObject::connect(&solver, SIGNAL(solutionFound(const HullTimeline&)),
renderer, SLOT(setTimeline(const HullTimeline&)));
return app.exec();
}
void tst_qquickanimatedsprite::test_properties()
{
QQuickView *window = new QQuickView(0);
window->setSource(testFileUrl("basic.qml"));
window->show();
QVERIFY(QTest::qWaitForWindowExposed(window));
QVERIFY(window->rootObject());
QQuickAnimatedSprite* sprite = window->rootObject()->findChild<QQuickAnimatedSprite*>("sprite");
QVERIFY(sprite);
QTRY_VERIFY(sprite->running());
QVERIFY(!sprite->paused());
QVERIFY(sprite->interpolate());
QCOMPARE(sprite->loops(), 30);
sprite->setRunning(false);
QVERIFY(!sprite->running());
sprite->setInterpolate(false);
QVERIFY(!sprite->interpolate());
delete window;
}
void tst_qquickanimatedsprite::test_frameChangedSignal()
{
QQuickView *window = new QQuickView(0);
window->setSource(testFileUrl("frameChange.qml"));
window->show();
QVERIFY(QTest::qWaitForWindowExposed(window));
QVERIFY(window->rootObject());
QQuickAnimatedSprite* sprite = window->rootObject()->findChild<QQuickAnimatedSprite*>("sprite");
QVERIFY(sprite);
QVERIFY(!sprite->running());
QVERIFY(!sprite->paused());
QCOMPARE(sprite->loops(), 3);
QCOMPARE(sprite->frameCount(), 6);
QSignalSpy frameChangedSpy(sprite, SIGNAL(currentFrameChanged(int)));
sprite->setRunning(true);
QTRY_COMPARE(frameChangedSpy.count(), 3*6);
QTRY_VERIFY(!sprite->running());
delete window;
}
int main(int argc, char **argv)
{
QGuiApplication app(argc, argv);
QQuickView view;
view.setResizeMode(QQuickView::SizeRootObjectToView);
view.setSource(QUrl(QStringLiteral("qrc:/qml/main.qml")));
QObject *rootObject = view.rootObject();
rootObject->setProperty("text1Text",QVariant("Open an url with schema pocintent://..."));
OpenUrlClient *openUrlClient = new OpenUrlClient(&view, rootObject);
view.engine()->rootContext()->setContextProperty(QLatin1String("openUrlClient"), openUrlClient);
view.show();
return app.exec();
}
void tst_QQuickAccessible::commonTests()
{
QFETCH(QString, accessibleRoleFileName);
qDebug() << "testing" << accessibleRoleFileName;
QQuickView *view = new QQuickView();
// view->setFixedSize(240,320);
view->setSource(testFileUrl(accessibleRoleFileName));
view->show();
// view->setFocus();
QVERIFY(view->rootObject() != 0);
QAccessibleInterface *iface = QAccessible::queryAccessibleInterface(view);
QVERIFY(iface);
delete view;
QTestAccessibility::clearEvents();
}
