int main(int argc, char *argv[]) {
Q_INIT_RESOURCE(resources);
QGuiApplication app(argc, argv);
app.setApplicationName("osmand-qt");
app.setApplicationVersion("0.1");
__CoreResourcesEmbeddedBundle__FakeReferences();
shared_ptr<const CoreResourcesEmbeddedBundle> bundle =
CoreResourcesEmbeddedBundle::loadFromCurrentExecutable();
InitializeCore(bundle);
qmlRegisterType<MapCanvas>("OsmAndQt", 1, 0, "MapCanvas");
qmlRegisterUncreatableType<Resources>("OsmAndQt", 1, 0, "Resources", "");
qmlRegisterUncreatableType<ResourceModel>("OsmAndQt", 1, 0, "ResourceModel", "");
Resources resources;
resources.downloadIfNecessary(QList<QString>()
<< "world_basemap.map.obf"
<< "austria_europe.map.obf"
);
QQmlApplicationEngine engine;
engine.rootContext()->setContextProperty("contextResources", &resources);
engine.load(QUrl("qrc:/src/Main.qml"));
qobject_cast<QQuickWindow *>(engine.rootObjects().value(0))->show();
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QStandardItemModel model;
model.appendRow(new QStandardItem("Norway"));
model.appendRow(new QStandardItem("Netherlands"));
model.appendRow(new QStandardItem("New Zealand"));
model.appendRow(new QStandardItem("Namibia"));
model.appendRow(new QStandardItem("Nicaragua"));
model.appendRow(new QStandardItem("North Korea"));
model.appendRow(new QStandardItem("Northern Cyprus "));
model.appendRow(new QStandardItem("Sweden"));
model.appendRow(new QStandardItem("Denmark"));
QStringList strings;
strings << "Norway" << "Sweden" << "Denmark";
QQmlApplicationEngine engine;
engine.rootContext()->setContextProperty("standardmodel", &model);
engine.rootContext()->setContextProperty("stringmodel", strings);
engine.load(QUrl("main.qml"));
QObject *topLevel = engine.rootObjects().value(0);
QQuickWindow *window = qobject_cast<QQuickWindow *>(topLevel);
if ( !window ) {
qWarning("Error: Your root item has to be a Window.");
return -1;
}
window->show();
return app.exec();
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
//test_handcontrol mytest_handcontrol;
handcontrol myhandcontrol;
//char video_name[] = "test.mp4";
//mytest_handcontrol.openFile(video_name);
//qmlRegisterType<handcontrol>("handcontrol", 1, 0, "Handcontrol");
engine.load(QUrl(QStringLiteral("qrc:/main_handcontrol.qml")));
QObject *root = engine.rootObjects()[0];
QObject *cameraComponent = root->findChild<QObject*>("camera");
QCamera *camera = qvariant_cast<QCamera*>(cameraComponent->property("mediaObject"));
myhandcontrol.setCamera(camera);
//myhandcontrol.setQMLCamera(qmlCamera);
//root->setProperty("frame_count", mytest_handcontrol.getNrOfFrames());
QObject::connect(root, SIGNAL(handcontrol_enable(int)),&myhandcontrol, SLOT(enable(int)));
QObject::connect(&myhandcontrol, SIGNAL(debugMessage(QVariant)),root, SLOT(print_debugMessage(QVariant)));
QObject::connect(&myhandcontrol, SIGNAL(errorMessage(QVariant)),root, SLOT(print_errorMessage(QVariant)));
QObject::connect(&myhandcontrol, SIGNAL(change_page(QVariant)),root, SLOT(count_page(QVariant)));
//engine.addImageProvider(QLatin1String("test_handcontrol"), &mytest_handcontrol);
qDebug()<<"From main thread: "<<QThread::currentThreadId();
return app.exec();
}
void MasterCatalogModel::setCurrentCatalog(CatalogModel *cat)
{
if (!_rootObject){
QQmlApplicationEngine *engine = dynamic_cast<QQmlApplicationEngine *>(_qmlcontext->engine());
if ( engine){
QObject *top = engine->rootObjects().value(0);
QObject *topLevel = top->findChild<QObject *>("mainwindow__mainui");
if ( topLevel){
_rootObject = topLevel;
}
}
}
if ( cat->url() == Catalog::DEFAULT_WORKSPACE){
Resource res = Ilwis::Resource(context()->workingCatalog()->resource().url().toString(), itCATALOG);
_lastCatalog = _currentCatalog;
_currentCatalog = new CatalogModel(res, CatalogModel::getCatalogType(res), this);
} else{
_lastCatalog = _currentCatalog;
_currentCatalog = cat;
if ( _rootObject){
QObject *obj = _rootObject->findChild<QObject *>("main_ui_catalogform");
if ( obj && cat->url().indexOf("file://") == 0){
obj->setProperty("currentFolder", cat->url());
}
}
}
ICatalog catalog(cat->url());
if ( catalog.isValid()){
context()->setWorkingCatalog(catalog);
mastercatalog()->addContainer(cat->url());
}
}
int main(int argc, char *argv[])
{
#ifdef Q_OS_IOS
QGuiApplication app(argc, argv);
#else
QApplication app(argc,argv);
#endif
QQmlApplicationEngine engine;
// Quick iOS Initialization
engine.addImportPath("qrc:///");
QuickIOS::registerTypes(); // It must be called before loaded any scene
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
QQuickWindow *window = qobject_cast<QQuickWindow *>(engine.rootObjects().first());
/// Setup the QQuickWindow instance to fit the iOS environment
QuickIOS::setupWindow(window);
QuickIOS::setStatusBarStyle(QuickIOS::StatusBarStyleDefault);
QISystemMessenger::instance()->sendMessage("activityIndicatorStart",QVariantMap());
printSystemInformation();
return app.exec();
}
void run_ui()
{
qmlRegisterType<QMLManager>("org.subsurfacedivelog.mobile", 1, 0, "QMLManager");
qmlRegisterType<QMLProfile>("org.subsurfacedivelog.mobile", 1, 0, "QMLProfile");
QQmlApplicationEngine engine;
engine.addImportPath("qrc://imports");
DiveListModel diveListModel;
QSortFilterProxyModel *sortModel = new QSortFilterProxyModel(0);
sortModel->setSourceModel(&diveListModel);
sortModel->setDynamicSortFilter(true);
sortModel->setSortRole(DiveListModel::DiveDateRole);
sortModel->sort(0, Qt::DescendingOrder);
QQmlContext *ctxt = engine.rootContext();
ctxt->setContextProperty("diveModel", sortModel);
engine.load(QUrl(QStringLiteral("qrc:///qml/main.qml")));
qqWindowObject = engine.rootObjects().value(0);
if (!qqWindowObject) {
fprintf(stderr, "can't create window object\n");
exit(1);
}
QQuickWindow *qml_window = qobject_cast<QQuickWindow *>(qqWindowObject);
qml_window->setIcon(QIcon(":/subsurface-mobile-icon"));
qqWindowObject->setProperty("messageText", QVariant("Subsurface mobile startup"));
#if !defined(Q_OS_ANDROID)
qml_window->setHeight(1200);
qml_window->setWidth(800);
#endif
qml_window->show();
qApp->exec();
}
int main(int argc, char *argv[])
{
QGuiApplication application(argc, argv);
QVariantMap parameters;
QStringList args(QCoreApplication::arguments());
if (parseArgs(args, parameters))
return 0;
if (!args.contains(QStringLiteral("osm.useragent")))
parameters[QStringLiteral("osm.useragent")] = QStringLiteral("QtLocation Mapviewer example");
QQmlApplicationEngine engine;
engine.addImportPath(QStringLiteral(":/imports"));
engine.load(QUrl(QStringLiteral("qrc:///mapviewer.qml")));
QObject::connect(&engine, SIGNAL(quit()), qApp, SLOT(quit()));
QObject *item = engine.rootObjects().first();
Q_ASSERT(item);
QMetaObject::invokeMethod(item, "initializeProviders",
Q_ARG(QVariant, QVariant::fromValue(parameters)));
return application.exec();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QQmlApplicationEngine engine;
engine.rootContext()->setContextProperty("ScreenW",1920);//1920x1080
engine.rootContext()->setContextProperty("ScreenH",1080);
DiceResultModel* model = new DiceResultModel();
engine.rootContext()->setContextProperty("_diceModel",model);
/* QTextDocument text(NULL);
CppHighLighter cppHighLighter(&text);
engine.rootContext()->setContextProperty("_hightedDoc",&text);*/
//engine.rootContext()->setContextProperty("CppHighLightedDocument",720);
QmlControler ctr;
ctr.setResultModel(model);
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
QList<QObject*> roots = engine.rootObjects();
QObject* root = roots.at(0);
QObject::connect(root,SIGNAL(rollDiceCmd(QString)),&ctr,SLOT(rollDice(QString)));
ctr.setEngine(&engine);
ctr.setVisible(true);
return app.exec();
}
int main(int argc, char **argv)
{
Application app(argc, argv);
app.setOrganizationName("liri-browser");
app.setOrganizationDomain("liri-browser.github.io");
app.setApplicationName("liri-browser");
// Load Translations
QTranslator qtTranslator;
qtTranslator.load("qt_" + QLocale::system().name(),
QLibraryInfo::location(QLibraryInfo::TranslationsPath));
app.installTranslator(&qtTranslator);
QTranslator translator;
translator.load("translations/" + QLocale::system().name());
app.installTranslator(&translator);
// Initialize QtWebEngine
QtWebEngine::initialize();
QQmlApplicationEngine appEngine;
//appEngine.rootContext()->setContextProperty("utils", &utils);
appEngine.load(QUrl("qrc:/qml/DesktopApplication.qml"));
QMetaObject::invokeMethod(appEngine.rootObjects().first(), "load");
return app.exec();
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
// set path where recorded data will be stored
qDebug() << "catalogPath: "<<Sbs2Common::setDefaultCatalogPath();
// set path where application data is stored
qDebug() << "rootAppPath: "<<Sbs2Common::setDefaultRootAppPath();
MyCallback* myCallback = new MyCallback();
//Sbs2FakeDataReader* sbs2DataReader = Sbs2FakeDataReader::New(myCallback,0);
Sbs2EmotivDataReader* sbs2DataReader = Sbs2EmotivDataReader::New(myCallback,0);
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
// Get access to the rectangle
QObject *rootObject = engine.rootObjects().first();
QObject *rect = rootObject->findChild<QObject*>("rect");
//QObject *rect = engine.findChild<QObject*>();
if (rect) {
QObject::connect(myCallback,SIGNAL(timeTick8()),rect,SLOT(timeTick()));
QObject::connect(myCallback,SIGNAL(valueSignal(QVariant)),rect,SLOT(channelValue(QVariant)));
QObject::connect(&app, SIGNAL(aboutToQuit()), sbs2DataReader, SLOT(aboutToQuit()));
QObject::connect(&engine, SIGNAL(quit()), &app, SLOT(quit()));
qDebug() << "succes";
} else {
qDebug() << "fail";
}
return app.exec();
}
int main(int argc, char *argv[])
{
QGuiApplication::setApplicationName("BaasExample");
QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
//#if defined(Q_OS_ANDROID)
//TODO : fix registering via registerFilterTypes() Q_COREAPP_STARTUP_FUNCTION (not called with Android?)
//registerFilterTypes();
//#endif
qmlRegisterSingletonType( QUrl("qrc:/qml/singleton/Assets.qml"),"BaaS.Example.Assets", 1, 0,"Assets");
#ifdef APPVERSION
engine.rootContext()->setContextProperty( "appVersion", QString( APPVERSION ));
#endif
engine.addImportPath("qrc:///");
engine.load(QUrl(QLatin1String("qrc:/main.qml")));
if (engine.rootObjects().isEmpty())
return -1;
return app.exec();
}
int Wimp::CreateMainWindow()
{
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
topLevel = engine.rootObjects().value(0);
window = qobject_cast<QQuickWindow *>(topLevel);
SetTitle("Hello QT");
return this->exec();
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QtWebEngine::initialize();
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
if (argc > 1)
{
QMetaObject::invokeMethod(engine.rootObjects().first(), "load", Q_ARG(QVariant, argv[1]));
}
else
{
QMetaObject::invokeMethod(engine.rootObjects().first(), "load", Q_ARG(QVariant, "http://www.google.com"));
}
return app.exec();
}
int main(int argc, char *argv[]) {
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
QThread *cameraThread = new QThread(&app);
cameraThread->start();
CameraCapturer *capturer = new CameraCapturer();
CameraImageProvider *imageProvider = new CameraImageProvider();
capturer->moveToThread(cameraThread);
imageProvider->moveToThread(cameraThread);
QObject::connect(capturer, static_cast<void (CameraCapturer::*)(QImage)>(
&CameraCapturer::frame),
imageProvider, &CameraImageProvider::setImage);
engine.addImageProvider("camera", imageProvider);
QThread *imageProcessingThread = new QThread(&app);
imageProcessingThread->start();
SquintDetector *squintDetector = new SquintDetector();
squintDetector->moveToThread(imageProcessingThread);
qRegisterMetaType<cv::Mat>("cv::Mat");
QObject::connect(capturer, static_cast<void (CameraCapturer::*)(cv::Mat)>(
&CameraCapturer::frame),
squintDetector, &SquintDetector::updateFrame);
capturer->startCapture(16);
engine.load(QUrl(QStringLiteral("qrc:///main.qml")));
QObject *mainWindow = engine.rootObjects()[0];
QObject *arkanoid = mainWindow->children()[0];
ArkanoidManager *aManager = new ArkanoidManager(arkanoid);
QObject::connect(squintDetector, &SquintDetector::leftEye,
aManager, &ArkanoidManager::leftEye);
QObject::connect(squintDetector, &SquintDetector::rightEye,
aManager, &ArkanoidManager::rightEye);
QObject::connect(squintDetector, &SquintDetector::noEye,
aManager, &ArkanoidManager::noEye);
QObject::connect(squintDetector, &SquintDetector::bothEyes,
aManager, &ArkanoidManager::bothEyes);
QObject::connect(&app, &QGuiApplication::aboutToQuit, [=]() {
// capturer->stopCapture();
// delete capturer;
// delete imageProvider;
// cameraThread->exit();
// delete squintDetector;
// imageProcessingThread->exit();
qDebug() << "bye";
});
return app.exec();
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
engine.load(QUrl(qApp->applicationDirPath() + QStringLiteral("/data/main.qml")));
if (engine.rootObjects().isEmpty())
return -1;
return app.exec();
}
Controller::Controller(QQmlApplicationEngine &engine):pRootObj(engine.rootObjects()[0]){
pMachine = new QStateMachine(&engine);
pMainMenuState = new QState(); //main menu
pGeoHuntState = new QState();
pMachine->setObjectName("stateMachineObject");
pClicker = pRootObj->findChild<QObject*>("stateSwitchClicker");
pMainMenu = pRootObj->findChild<QObject*>("mainMenuObject");
pMainMenuGrid = pMainMenu->findChild<QObject*>("gridObject");
pGeoHuntObject= pRootObj->findChild<QObject*>("cacheHuntObject");
pBackButtonObject = pRootObj->findChild<QObject*>("backButtonObject");
//main menu properties
pMainMenuState->assignProperty(pMainMenu, "z", 1);
pMainMenuState->assignProperty(pMainMenu, "visible", true);
pMainMenuState->assignProperty(pGeoHuntObject, "visible", false);
pMainMenuState->assignProperty(pGeoHuntObject, "z", 0);
pMainMenuState->assignProperty(pBackButtonObject, "visible", false);
pMainMenuState->assignProperty(pBackButtonObject, "z", 0);
//geo hunt properties
pGeoHuntState->assignProperty(pMainMenu, "z", 0);
pGeoHuntState->assignProperty(pMainMenu, "visible", false);
pGeoHuntState->assignProperty(pGeoHuntObject, "visible", true);
pGeoHuntState->assignProperty(pGeoHuntObject, "z", 1);
pGeoHuntState->assignProperty(pBackButtonObject, "visible", true);
pGeoHuntState->assignProperty(pBackButtonObject, "z", 1);
//transitions
pMainMenuState->addTransition(pMainMenuGrid->findChild<QObject*>("ghButton") , SIGNAL(clicked()), pGeoHuntState);
pGeoHuntState->addTransition(pBackButtonObject, SIGNAL(click()), pMainMenuState);
//init and start state machine
pMachine->addState(pMainMenuState);
pMachine->addState(pGeoHuntState);
pMachine->setInitialState(pMainMenuState);
pMachine->start();
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:///main.qml")));
QObject* root = engine.rootObjects().value(0);
if (QWindow *window = qobject_cast<QWindow *>(root))
window->show();
return app.exec();
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
//qmlRegisterType<NetworkComm>("Networking", 1, 0, "Networkcomm");
qmlRegisterType<FileIO, 1>("FileIO", 1, 0, "FileIO");
engine.load(QUrl("qrc:/main.qml"));
QObject *topLevel = engine.rootObjects().value(0);
QQuickWindow *window = qobject_cast<QQuickWindow *>(topLevel);
//engine.load(QUrl("qrc:/main.qml"));
window->show();
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/QML/desktopapplication.qml")));
QObject *rootObject = engine.rootObjects().first();
DesktopApplication desktopApp(rootObject);
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Vibrator vibrator;
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
QQuickWindow *window = qobject_cast<QQuickWindow *>(engine.rootObjects().first());
window->showFullScreen();
engine.rootContext()->setContextProperty("Vibrator", &vibrator);
return app.exec();
}
int main(int argc, char *argv[])
{
#ifdef Q_OS_LINUX
// When using QAudioOutput on linux/ALSA, we need to
// block SIGIO on all threads except the audio thread
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGIO);
pthread_sigmask(SIG_BLOCK, &set, nullptr);
#endif
qSetMessagePattern("[%{if-debug}D%{endif}%{if-warning}W%{endif}"
"%{if-critical}C%{endif}%{if-fatal}F%{endif}]"
"%{if-category} [%{category}]:%{endif} %{message}");
QGuiApplication a(argc, argv);
a.setApplicationName("Phoenix");
a.setApplicationVersion(PHOENIX_VERSION);
a.setOrganizationName("Phoenix");
// a.setOrganizationDomain("phoenix-emu.org");
QSettings settings;
qmlRegisterType<PhoenixWindow>("phoenix.window", 1, 0, "PhoenixWindow");
qmlRegisterType<CachedImage>("phoenix.image", 1, 0, "CachedImage");
qmlRegisterType<VideoItem>("phoenix.video", 1, 0, "VideoItem");
qmlRegisterType<GameLibraryModel>();
qmlRegisterType<PhoenixLibrary>("phoenix.library", 1, 0, "PhoenixLibrary");
qmlRegisterType<InputDeviceMapping>();
qmlRegisterType<InputDevice>();
qRegisterMetaType<retro_device_id>("retro_device_id");
qRegisterMetaType<int16_t>("int16_t");
qRegisterMetaType<InputDeviceEvent *>();
QQmlApplicationEngine engine;
// first, set the context properties
QQmlContext *rctx = engine.rootContext();
rctx->setContextProperty("inputmanager", &input_manager);
// then, load qml and display the window
engine.load(QUrl("qrc:/qml/main.qml"));
QObject *topLevel = engine.rootObjects().value(0);
QQuickWindow *window = qobject_cast<QQuickWindow *>(topLevel);
window->show();
input_manager.scanDevices();
return a.exec();
}
NotifyWidget::NotifyWidget(int id, const SnoreNotifier *parent) :
m_id(id),
m_parent(parent),
m_mem(QLatin1String("SnoreNotifyWidget_rev") + QString::number(SHARED_MEM_TYPE_REV()) + QLatin1String("_id") + QString::number(m_id)),
m_ready(true),
m_fontFamily(qApp->font().family())
{
#ifdef Q_OS_WIN
if (QSysInfo::windowsVersion() >= QSysInfo::WV_WINDOWS8) {
m_fontFamily = QStringLiteral("Segoe UI Symbol");
emit fontFamilyChanged();
}
#if QT_VERSION >= QT_VERSION_CHECK(5,5,0)
if (QSysInfo::windowsVersion() >= QSysInfo::WV_WINDOWS10) {
m_fontFamily = QStringLiteral("Segoe UI Emoji");
emit fontFamilyChanged();
}
#endif
#endif
QQmlApplicationEngine *engine = new QQmlApplicationEngine(this);
engine->rootContext()->setContextProperty(QStringLiteral("notifyWidget"), this);
engine->load(QUrl::fromEncoded("qrc:/notification.qml"));
m_window = qobject_cast<QQuickWindow *>(engine->rootObjects().value(0));
// TODO: It looks like there is a Qt bug which make some Windows with this flag invisible in some cases...(Tested: Kubuntu willy)
m_window->setFlags(Qt::WindowStaysOnTopHint | Qt::ToolTip
#ifdef Q_OS_MAC
// TODO: is this needed or is ToolTip working?
//| Qt::SubWindow
#endif
);
if (m_mem.create(sizeof(SHARED_MEM_TYPE))) {
m_mem.lock();
SHARED_MEM_TYPE *data = (SHARED_MEM_TYPE *)m_mem.data();
data->free = true;
data->date = QTime::currentTime().msecsSinceStartOfDay();
m_mem.unlock();
} else {
if (!m_mem.attach()) {
qCWarning(SNORE) << "Failed to atatche to shared mem";
} else {
m_mem.lock();
SHARED_MEM_TYPE *data = (SHARED_MEM_TYPE *)m_mem.data();
m_mem.unlock();
int elapsed = (QTime::currentTime().msecsSinceStartOfDay() - data->date) / 1000;
qCDebug(SNORE) << m_id << "State:" << data->free << "Time:" << elapsed << "Timeout:" << data->timeout;
}
}
}
int main(int argc, char **argv)
{
Application app(argc, argv);
QtWebEngine::initialize();
QQmlApplicationEngine appEngine;
Utils utils;
appEngine.rootContext()->setContextProperty("utils", &utils);
appEngine.load(QUrl("qrc:/ApplicationRoot.qml"));
QMetaObject::invokeMethod(appEngine.rootObjects().first(), "load", Q_ARG(QVariant, startupUrl()));
return app.exec();
}
int main(int argc, char *argv[])
{
QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
engine.rootContext()->setContextProperty("tableModel", new TableModel());
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
if (engine.rootObjects().isEmpty())
return -1;
return app.exec();
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
qmlRegisterType<Person>("TestComponents", 1, 0, "Person");
qmlRegisterType<QObjectListModel>("TestComponents", 1, 0, "QObjectListModel");
TestObject * testobject = new TestObject();
engine.rootContext()->setContextProperty("testobject", testobject);
engine.load(QUrl("qrc:/main.qml"));
QObject *topLevel = engine.rootObjects().value(0);
QQuickWindow *window = qobject_cast<QQuickWindow *>(topLevel);
window->show();
return app.exec();
}
int main(int argc, char *argv[])
{
//--------------------------------------------------------------------- register QML types
qmlRegisterType<PresentationPropertyHolder>("HKer", 1, 0, "PresentationPropertyHolder");
QGuiApplication app(argc, argv);
GeolocationManager geolocationManager;
ImageProcessor imageProcessor;
CameraControl cameraControl;
FlowController flowController;
flowController.setCameraControl(cameraControl);
flowController.setImageProcessor(imageProcessor);
QQmlApplicationEngine engine;
//----------------------------------------------------------------------------------------- associate context properties
//engine.rootContext()->setContextProperty("camera", camera.property("mediaObject"));
//----------------------------------------------------------------------------------------- setup qml
qputenv("QT_QUICK_CONTROLS_STYLE", "Flat");
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
//----------------------------------------------------------------------------------------- connect signals and slots
QObject* viewRoot = engine.rootObjects().first();
PresentationPropertyHolder* longitudeHolder = viewRoot->findChild<PresentationPropertyHolder*>("longitudeHolder");
QObject::connect(&geolocationManager, SIGNAL(longitudeUpdated(double)), longitudeHolder, SLOT(onUpdateContent(double)));
PresentationPropertyHolder* latitudeHolder = viewRoot->findChild<PresentationPropertyHolder*>("latitudeHolder");
QObject::connect(&geolocationManager, SIGNAL(latitudeUpdated(double)), latitudeHolder, SLOT(onUpdateContent(double)));
PresentationPropertyHolder* colourTextHolder = viewRoot->findChild<PresentationPropertyHolder*>("colourTextHolder");
QObject::connect(&flowController, SIGNAL(updateImageAnalysisStatus(QString)), colourTextHolder, SLOT(onUpdateContent(QString)));
PresentationPropertyHolder* colourValueHolder = viewRoot->findChild<PresentationPropertyHolder*>("colourValueHolder");
QObject::connect(&flowController, SIGNAL(updateIdentifiedColour(QColor)), colourValueHolder, SLOT(onUpdateContent(QColor)));
QObject::connect(viewRoot, SIGNAL(detectColourClicked()), &flowController, SLOT(onDetectColour()));
QObject::connect(viewRoot, SIGNAL(calibrateWhiteClicked()), &flowController, SLOT(onCalibrateWhite()));
//----------------------------------------------------------------- setup camera
QObject* cameraObj = viewRoot->findChild<QObject*>("camera");
QVariant cameraMediaObject = cameraObj->property("mediaObject");
QCamera* camera = qvariant_cast<QCamera*>(cameraMediaObject);
cameraControl.setupCamera(camera);
//----------------------------------------------- start the jobs
geolocationManager.startUpdates();
return app.exec();
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
QObject *item = engine.rootObjects().first();
MyClass myClass;
QObject::connect(item, SIGNAL(qmlSignal(QString)),
&myClass, SLOT(cppSlot(QString)));
return app.exec();
}
int main(int argc, char *argv[])
{
QGuiApplication::setAttribute(Qt::AA_UseOpenGLES);
QGuiApplication app(argc, argv);
QSize baseSize(1280,1024);
QSize screenSize(app.primaryScreen()->size());
if(!FKUtility::loadImageset("images",screenSize)){
qDebug("unable load images");
}
if(!FKUtility::loadImageset("skillIcons",screenSize)){
qDebug("unable load skillIcons");
}
FKUtility::ResourceLocator resources;
if(resources.load("music")!=FKUtility::ResourceLocator::loadingSuccess){
qDebug("unable load music resource");
}
if(!resources.load("models")!=FKUtility::ResourceLocator::loadingSuccess){
qDebug("unable load models resource");
}
if(!resources.load("sprites")!=FKUtility::ResourceLocator::loadingSuccess){
qDebug("unable load sprites resource");
}
qreal sizeSet=std::max(((qreal)screenSize.height())/((qreal)baseSize.height()),
((qreal)screenSize.width ())/((qreal)baseSize.width ()));
QQmlApplicationEngine engine;
ADD_QML_TYPE(BalancedComponent);
ADD_QML_TYPE(PlayerBase);
ADD_QML_TYPE(HeroObject);
ADD_QML_TYPE(PathMap);
ADD_QML_TYPE(PathFinder);
ADD_QML_ABSTRACT_TYPE(PathFinderAlgorithm);
ADD_QML_TYPE(PathFinderAStarAlgorithm);
engine.rootContext()->setContextProperty("sizeSet",sizeSet);
engine.rootContext()->setContextProperty("baseHeight",baseSize.height());
engine.rootContext()->setContextProperty("baseWidth",baseSize.width());
engine.load(QUrl(QStringLiteral("qrc:///main.qml")));
QMetaObject::invokeMethod(engine.rootObjects().at(0),"show");
return app.exec();
}
int main(int argc, char** argv)
{
QGuiApplication app(argc, argv);
qmlRegisterType<PrimeFinder>("sk.uniza.fri.qt", 1, 0, "PrimeFinder");
QQmlApplicationEngine engine;
engine.load(QUrl("qrc:///primes.qml"));
QObject* root = engine.rootObjects().value(0);
QQuickWindow* win = qobject_cast<QQuickWindow*>(root);
win->show();
return app.exec();
}
int main(int argc, char *argv[])
{
#if defined(Q_OS_WIN)
QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
#endif
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
if (engine.rootObjects().isEmpty())
return -1;
return app.exec();
}
