QuickWindowNodeInstance::Pointer QuickWindowNodeInstance::create(QObject *object)
{
QQuickWindow *quickWindow = qobject_cast<QQuickWindow*>(object);
Q_ASSERT(quickWindow);
Pointer instance(new QuickWindowNodeInstance(quickWindow));
instance->setHasContent(anyItemHasContent(quickWindow->contentItem()));
quickWindow->contentItem()->setFlag(QQuickItem::ItemHasContents, true);
static_cast<QQmlParserStatus*>(quickWindow->contentItem())->classBegin();
instance->populateResetHashes();
QQuickItemPrivate *privateItem = static_cast<QQuickItemPrivate*>(QObjectPrivate::get(quickWindow->contentItem()));
if (privateItem->window) {
if (!privateItem->parentItem)
QQuickWindowPrivate::get(privateItem->window)->parentlessItems.remove(quickWindow->contentItem());
privateItem->derefWindow();
privateItem->window = 0;
}
return instance;
}
void Highlight::adjust()
{
if (!m_item)
return;
bool success = false;
m_transform = m_item->itemTransform(0, &success);
if (!success)
m_transform = QTransform();
setSize(QSizeF(m_item->width(), m_item->height()));
qreal scaleFactor = 1;
QPointF originOffset = QPointF(0,0);
QQuickWindow *view = m_item->window();
if (view->contentItem()) {
scaleFactor = view->contentItem()->scale();
originOffset -= view->contentItem()->position();
}
// The scale transform for the overlay needs to be cancelled
// as the Item's transform which will be applied to the painter
// takes care of it.
parentItem()->setScale(1/scaleFactor);
setPosition(originOffset);
update();
}
void tst_applicationwindow::defaultFocus()
{
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("defaultFocus.qml"));
QObject* created = component.create();
QScopedPointer<QObject> cleanup(created);
Q_UNUSED(cleanup);
QVERIFY(created);
QQuickWindow* window = qobject_cast<QQuickWindow*>(created);
QVERIFY(window);
window->show();
window->requestActivate();
QVERIFY(QTest::qWaitForWindowActive(window));
QVERIFY(QGuiApplication::focusWindow() == window);
QQuickItem* contentItem = window->contentItem();
QVERIFY(contentItem);
QVERIFY(contentItem->hasActiveFocus());
// A single item in an ApplicationWindow with focus: true should receive focus.
QQuickItem* item = findItem<QQuickItem>(window->contentItem(), "item");
QVERIFY(item);
QVERIFY(item->hasFocus());
QVERIFY(item->hasActiveFocus());
}
void tst_applicationwindow::activeFocusOnTab2()
{
QQmlEngine engine;
QQmlComponent component(&engine);
component.loadUrl(testFileUrl("activefocusontab.qml"));
QObject* created = component.create();
QScopedPointer<QObject> cleanup(created);
QVERIFY(created);
QQuickWindow* window = qobject_cast<QQuickWindow*>(created);
QVERIFY(window);
window->show();
window->requestActivate();
QVERIFY(QTest::qWaitForWindowActive(window));
QVERIFY(QGuiApplication::focusWindow() == window);
QQuickItem* contentItem = window->contentItem();
QVERIFY(contentItem);
QVERIFY(contentItem->hasActiveFocus());
QQuickItem* item = findItem<QQuickItem>(window->contentItem(), "sub2");
QVERIFY(item);
QVERIFY(!item->hasActiveFocus());
// BackTab: contentItem->sub2
QKeyEvent key(QEvent::KeyPress, Qt::Key_Tab, Qt::ShiftModifier, "", false, 1);
QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
item = findItem<QQuickItem>(window->contentItem(), "sub2");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// BackTab: sub2->sub1
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::ShiftModifier, "", false, 1);
QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
item = findItem<QQuickItem>(window->contentItem(), "sub1");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
// BackTab: sub1->sub2
key = QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::ShiftModifier, "", false, 1);
QGuiApplication::sendEvent(window, &key);
QVERIFY(key.isAccepted());
item = findItem<QQuickItem>(window->contentItem(), "sub2");
QVERIFY(item);
QVERIFY(item->hasActiveFocus());
}
void Highlight::setItem(QQuickItem *item)
{
if (m_item)
m_item->disconnect(this);
if (item) {
connect(item, SIGNAL(xChanged()), SLOT(adjust()));
connect(item, SIGNAL(yChanged()), SLOT(adjust()));
connect(item, SIGNAL(widthChanged()), SLOT(adjust()));
connect(item, SIGNAL(heightChanged()), SLOT(adjust()));
connect(item, SIGNAL(rotationChanged()), SLOT(adjust()));
connect(item, SIGNAL(transformOriginChanged(TransformOrigin)),
SLOT(adjust()));
}
QQuickWindow *view = item->window();
QQuickItem * contentItem = view->contentItem();
if (contentItem) {
connect(contentItem, SIGNAL(xChanged()), SLOT(adjust()));
connect(contentItem, SIGNAL(yChanged()), SLOT(adjust()));
connect(contentItem, SIGNAL(widthChanged()), SLOT(adjust()));
connect(contentItem, SIGNAL(heightChanged()), SLOT(adjust()));
connect(contentItem, SIGNAL(rotationChanged()), SLOT(adjust()));
connect(contentItem, SIGNAL(transformOriginChanged(TransformOrigin)),
SLOT(adjust()));
}
m_item = item;
setContentsSize(view->size());
adjust();
}
void Highlight::setItem(QQuickItem *item)
{
if (m_item)
m_item->disconnect(this);
if (item) {
connect(item, &QQuickItem::xChanged, this, &Highlight::adjust);
connect(item, &QQuickItem::yChanged, this, &Highlight::adjust);
connect(item, &QQuickItem::widthChanged, this, &Highlight::adjust);
connect(item, &QQuickItem::heightChanged, this, &Highlight::adjust);
connect(item, &QQuickItem::rotationChanged, this, &Highlight::adjust);
connect(item, &QQuickItem::transformOriginChanged, this, &Highlight::adjust);
}
QQuickWindow *view = item->window();
QQuickItem * contentItem = view->contentItem();
if (contentItem) {
connect(contentItem, &QQuickItem::xChanged, this, &Highlight::adjust);
connect(contentItem, &QQuickItem::yChanged, this, &Highlight::adjust);
connect(contentItem, &QQuickItem::widthChanged, this, &Highlight::adjust);
connect(contentItem, &QQuickItem::heightChanged, this, &Highlight::adjust);
connect(contentItem, &QQuickItem::rotationChanged, this, &Highlight::adjust);
connect(contentItem, &QQuickItem::transformOriginChanged, this, &Highlight::adjust);
}
m_item = item;
setContentsSize(view->size());
adjust();
}
void Compositor::onXdgToplevelCreated(QWaylandXdgToplevel *toplevel, QWaylandXdgSurface *shellSurface)
//void Compositor::onXdgSurfaceCreated(QWaylandXdgSurface *shellSurface)
{
unsigned int windowId = mNextWindowId++;
QWaylandSurface *surface = shellSurface->surface();
qDebug() << Q_FUNC_INFO << "windowId" << windowId << surface;
QQuickWindow *defaultOutputWindow = static_cast<QQuickWindow*>(defaultOutput()->window());
CompositorWindow *window = new CompositorWindow(windowId, defaultOutputWindow->contentItem());
window->setOutput(defaultOutput()); //useful ?
window->setFlag(QQuickItem::ItemIsFocusScope, true);
// window->setUseTextureAlpha(true);
window->initialize(shellSurface);
window->setSize(surface->size());
window->setTouchEventsEnabled(true);
mWindows.insert(windowId, window);
connect(window, &CompositorWindow::readyChanged, this, &Compositor::windowIsReady);
connect(window, &QWaylandQuickItem::surfaceDestroyed, this, &Compositor::onSurfaceDestroyed);
window->sendWindowIdToClient();
}
bool QuickInspector::eventFilter(QObject *receiver, QEvent *event)
{
if (event->type() == QEvent::MouseButtonRelease) {
QMouseEvent *mouseEv = static_cast<QMouseEvent*>(event);
if (mouseEv->button() == Qt::LeftButton &&
mouseEv->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier)) {
QQuickWindow *window = qobject_cast<QQuickWindow*>(receiver);
if (window && window->contentItem()) {
QQuickItem *item = recursiveChiltAt(window->contentItem(), mouseEv->pos());
m_probe->selectObject(item);
}
}
}
return QObject::eventFilter(receiver, event);
}
void WindowManager::registerQuickItem( QQuickItem* item )
{
if ( !item ) return;
QQuickWindow *window = item->window();
if (window) {
QQuickItem *contentItem = window->contentItem();
contentItem->setAcceptedMouseButtons( Qt::LeftButton );
contentItem->removeEventFilter( this );
contentItem->installEventFilter( this );
}
}
void QQuickPopupWindow::show()
{
qreal posx = x();
qreal posy = y();
// transientParent may not be a QQuickWindow when embedding into widgets
if (QWindow *tp = transientParent()) {
if (m_parentItem) {
QPointF pos = m_parentItem->mapToItem(m_parentItem->window()->contentItem(), QPointF(posx, posy));
posx = pos.x();
posy = pos.y();
}
QPoint tlwOffset = tp->mapToGlobal(QPoint());
posx += tlwOffset.x();
posy += tlwOffset.y();
} else if (m_parentItem && m_parentItem->window()) {
QPoint offset;
QQuickWindow *quickWindow = m_parentItem->window();
QWindow *renderWindow = QQuickRenderControl::renderWindowFor(quickWindow, &offset);
QPointF pos = m_parentItem->mapToItem(quickWindow->contentItem(), QPointF(posx, posy));
posx = pos.x();
posy = pos.y();
QPoint parentWindowOffset = (renderWindow ? renderWindow : quickWindow)->mapToGlobal(QPoint());
posx += offset.x() + parentWindowOffset.x();
posy += offset.y() + parentWindowOffset.y();
}
if (m_contentItem) {
qreal initialWidth = qMax(qreal(1), m_contentItem->width());
qreal initialHeight = qMax(qreal(1), m_contentItem->height());
setGeometry(posx, posy, initialWidth, initialHeight);
} else {
setPosition(posx, posy);
}
emit geometryChanged();
if (!qobject_cast<QQuickPopupWindow *>(transientParent())) { // No need for parent menu windows
if (QQuickWindow *w = qobject_cast<QQuickWindow *>(transientParent())) {
if (QQuickItem *mg = w->mouseGrabberItem())
mg->ungrabMouse();
} else if (m_parentItem && m_parentItem->window()) {
if (QQuickItem *mg = m_parentItem->window()->mouseGrabberItem())
mg->ungrabMouse();
}
}
QQuickWindow::show();
setMouseGrabEnabled(true); // Needs to be done after calling show()
setKeyboardGrabEnabled(true);
}
QAccessibleInterface *QAccessibleQuickItem::parent() const
{
QQuickItem *parent = item()->parentItem();
if (parent) {
QQuickWindow *window = item()->window();
// Jump out to the scene widget if the parent is the root item.
// There are two root items, QQuickWindow::rootItem and
// QQuickView::declarativeRoot. The former is the true root item,
// but is not a part of the accessibility tree. Check if we hit
// it here and return an interface for the scene instead.
if (window && (parent == window->contentItem())) {
return QAccessible::queryAccessibleInterface(window);
} else {
return QAccessible::queryAccessibleInterface(parent);
}
}
return 0;
}
void tst_StatusIndicator::benchmarkCreation()
{
QFETCH(bool, active);
QQuickWindow window;
window.resize(240, 240);
window.create();
QQmlEngine engine;
// TODO: fix
QString path = QString::fromLatin1(SRCDIR "/LotsOfIndicators%1.qml").arg(active ? "Active" : "Inactive");
QQmlComponent component(&engine, QUrl::fromLocalFile(path));
QVERIFY2(!component.isError(), qPrintable(component.errorString()));
QVERIFY(component.isReady());
QBENCHMARK {
QQuickItem *root = qobject_cast<QQuickItem*>(component.create());
root->setParentItem(window.contentItem());
window.grabWindow();
}
}
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;
}
void popupWindow::show() {
qreal posx = x();
qreal posy = y();
// transientParent may not be a QQuickWindow when embedding into widgets
if (QWindow *tp = transientParent()) {
if (m_pParentItem) {
QPointF pos = m_pParentItem->mapToItem(m_pParentItem->window()->contentItem(), QPointF());
posx = pos.x();
posy = pos.y();
}
QPoint tlwOffset = tp->mapToGlobal(QPoint());
posx += tlwOffset.x();
posy += tlwOffset.y();
} else if (m_pParentItem && m_pParentItem->window()) {
QPoint offset;
QQuickWindow *quickWindow = m_pParentItem->window();
QWindow *renderWindow = QQuickRenderControl::renderWindowFor(quickWindow, &offset);
QPointF pos = m_pParentItem->mapToItem(quickWindow->contentItem(), QPointF(posx, posy));
posx = pos.x();
posy = pos.y();
QPoint parentWindowOffset = (renderWindow ? renderWindow : quickWindow)->mapToGlobal(QPoint());
posx += offset.x() + parentWindowOffset.x();
posy += offset.y() + parentWindowOffset.y();
}
setGeometry(posx + m_xOffset, posy + m_yOffset, width(), height());
emit geometryChanged();
m_mouseMoved = false;
QQuickWindow::show();
setMouseGrabEnabled(true); // Needs to be done after calling show()
//setKeyboardGrabEnabled(true);
}
Main::Main(Marsyas::MarSystem * system)
{
root_system = system;
//qRegisterMetaType<Marsyas::MarSystem*>();
qmlRegisterType<MarSystemView>("Marsyas", 1, 0, "MarSystemView");
qmlRegisterType<MarSystemViewAttached>();
qmlRegisterType<MarSystemControlView>("Marsyas", 1, 0, "MarSystemControlView");
QQmlEngine *engine = new QQmlEngine(this);
//engine->rootContext()->setContextProperty("myModel", QVariant::fromValue<QObject*>(model));
engine->rootContext()->setContextProperty("mySystem", QVariant::fromValue(system));
#if 0
QQmlComponent component(&engine,
QString("main.qml"));
if (component.status() != QQmlComponent::Ready) {
qCritical("Not ready!");
return 1;
}
QObject *root_view = component.create();
if (!root_view)
return 1;
root_view->setProperty("model", QVariant::fromValue<QObject*>(model));
//root_view->setProperty("index");
//root_view->setProperty("text", QString::fromStdString(system->getPrefix()));
QQuickWindow *window = new QQuickWindow();
root_view->setParent( window->contentItem() );
window->show();
#endif
toolbar = new QToolBar();
QAction *tick_action = toolbar->addAction("Tick");
connect( tick_action, SIGNAL(triggered()), this, SLOT(tickSystem()) );
///////////////////
system_view = new QQuickView(engine, 0);
system_view->setColor( QApplication::palette().color(QPalette::Window) );
system_view->setSource(QUrl::fromLocalFile("/home/jakob/programming/marsyas/src/qt5apps/inspector/main.qml"));
system_view->setResizeMode(QQuickView::SizeRootObjectToView);
QWidget *marsystem_widget = QWidget::createWindowContainer(system_view);
marsystem_widget->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
controls_widget = new ControlsWidget;
controls_widget->setSystem(system);
//controls_widget->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Preferred );
realvec_widget = new RealvecWidget;
realvec_widget->setSystem(system);
//realvec_widget->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Preferred );
QObject::connect( controls_widget, SIGNAL(controlClicked(QString)),
realvec_widget, SLOT(displayControl(QString)) );
QSplitter *data_splitter = new QSplitter();
data_splitter->setOrientation( Qt::Vertical );
data_splitter->addWidget( controls_widget );
data_splitter->addWidget( realvec_widget );
QSplitter *splitter = new QSplitter();
splitter->addWidget( marsystem_widget );
splitter->addWidget( data_splitter );
QVBoxLayout *column = new QVBoxLayout();
column->addWidget(toolbar);
column->addWidget(splitter);
QWidget *window = new QWidget();
window->setLayout(column);
window->resize(1000, 600);
window->show();
//window->showMaximized();
QObject *system_item = system_view->rootObject();
if (system_item) {
QObject::connect( system_item, SIGNAL(clicked(QString)),
this, SLOT(systemClicked(QString)) );
}
else {
qWarning("Could not find top system item!");
}
QShortcut *quit_shortcut = new QShortcut(QString("Ctrl+Q"), splitter);
QObject::connect( quit_shortcut, SIGNAL(activated()), qApp, SLOT(quit()) );
}
int main(int argc, char *argv[]) {
const QString runGuardName = getRunGuardName();
Helpers::RunGuard guard(runGuardName);
if (!guard.tryToRun()) {
std::cerr << "Xpiks is already running";
return -1;
}
// will call curl_global_init and cleanup
Conectivity::CurlInitHelper curlInitHelper;
Q_UNUSED(curlInitHelper);
// will init thread-unsafe XMP toolkit
MetadataIO::Exiv2InitHelper exiv2InitHelper;
Q_UNUSED(exiv2InitHelper);
const char *highDpiEnvironmentVariable = setHighDpiEnvironmentVariable();
qRegisterMetaTypeStreamOperators<Models::ProxySettings>("ProxySettings");
qRegisterMetaType<Common::SpellCheckFlags>("Common::SpellCheckFlags");
initQSettings();
Helpers::AppSettings appSettings;
ensureUserIdExists(&appSettings);
Suggestion::LocalLibrary localLibrary;
QString appDataPath = XPIKS_USERDATA_PATH;
if (!appDataPath.isEmpty()) {
QDir appDataDir(appDataPath);
QString libraryFilePath = appDataDir.filePath(Constants::LIBRARY_FILENAME);
localLibrary.setLibraryPath(libraryFilePath);
} else {
std::cerr << "AppDataPath is empty!";
}
#ifdef WITH_LOGS
const QString &logFileDir = QDir::cleanPath(appDataPath + QDir::separator() + "logs");
if (!logFileDir.isEmpty()) {
QDir dir(logFileDir);
if (!dir.exists()) {
bool created = QDir().mkpath(logFileDir);
Q_UNUSED(created);
}
QString time = QDateTime::currentDateTimeUtc().toString("ddMMyyyy-hhmmss-zzz");
QString logFilename = QString("xpiks-qt-%1.log").arg(time);
QString logFilePath = dir.filePath(logFilename);
Helpers::Logger &logger = Helpers::Logger::getInstance();
logger.setLogFilePath(logFilePath);
}
#endif
QMLExtensions::ColorsModel colorsModel;
Models::LogsModel logsModel(&colorsModel);
logsModel.startLogging();
#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
qSetMessagePattern("%{time hh:mm:ss.zzz} %{type} T#%{threadid} %{function} - %{message}");
#endif
qInstallMessageHandler(myMessageHandler);
LOG_INFO << "Log started. Today is" << QDateTime::currentDateTimeUtc().toString("dd.MM.yyyy");
LOG_INFO << "Xpiks" << XPIKS_VERSION_STRING << "-" << STRINGIZE(BUILDNUMBER);
#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
LOG_INFO << QSysInfo::productType() << QSysInfo::productVersion() << QSysInfo::currentCpuArchitecture();
#else
#ifdef Q_OS_WIN
LOG_INFO << QLatin1String("Windows Qt<5.4");
#elsif Q_OS_DARWIN
LOG_INFO << QLatin1String("OS X Qt<5.4");
#else
LOG_INFO << QLatin1String("LINUX Qt<5.4");
#endif
#endif
QApplication app(argc, argv);
LOG_INFO << "Working directory of Xpiks is:" << QDir::currentPath();
LOG_DEBUG << "Extra files search locations:" << QStandardPaths::standardLocations(XPIKS_DATA_LOCATION_TYPE);
if (highDpiEnvironmentVariable) {
qunsetenv(highDpiEnvironmentVariable);
}
localLibrary.loadLibraryAsync();
QString userId = appSettings.value(QLatin1String(Constants::USER_AGENT_ID)).toString();
userId.remove(QRegExp("[{}-]."));
Models::ArtworksRepository artworkRepository;
Models::ArtItemsModel artItemsModel;
Models::CombinedArtworksModel combinedArtworksModel;
Models::UploadInfoRepository uploadInfoRepository;
Warnings::WarningsService warningsService;
Models::SettingsModel settingsModel;
settingsModel.readAllValues();
Encryption::SecretsManager secretsManager;
UndoRedo::UndoRedoManager undoRedoManager;
Models::ZipArchiver zipArchiver;
Suggestion::KeywordsSuggestor keywordsSuggestor(&localLibrary);
Models::FilteredArtItemsProxyModel filteredArtItemsModel;
filteredArtItemsModel.setSourceModel(&artItemsModel);
Models::RecentDirectoriesModel recentDirectorieModel;
Conectivity::FtpCoordinator *ftpCoordinator = new Conectivity::FtpCoordinator(settingsModel.getMaxParallelUploads());
Models::ArtworkUploader artworkUploader(ftpCoordinator);
SpellCheck::SpellCheckerService spellCheckerService;
SpellCheck::SpellCheckSuggestionModel spellCheckSuggestionModel;
MetadataIO::BackupSaverService metadataSaverService;
Warnings::WarningsModel warningsModel;
warningsModel.setSourceModel(&artItemsModel);
warningsModel.setWarningsSettingsModel(warningsService.getWarningsSettingsModel());
Models::LanguagesModel languagesModel;
AutoComplete::AutoCompleteModel autoCompleteModel;
AutoComplete::AutoCompleteService autoCompleteService(&autoCompleteModel);
QMLExtensions::ImageCachingService imageCachingService;
Models::FindAndReplaceModel replaceModel(&colorsModel);
Models::DeleteKeywordsViewModel deleteKeywordsModel;
Conectivity::UpdateService updateService(&settingsModel);
MetadataIO::MetadataIOCoordinator metadataIOCoordinator;
#if defined(QT_NO_DEBUG) && !defined(TELEMETRY_DISABLED)
const bool telemetryEnabled = appSettings.value(Constants::USER_STATISTICS, true).toBool();
#else
const bool telemetryEnabled = false;
#endif
Conectivity::TelemetryService telemetryService(userId, telemetryEnabled);
Plugins::PluginManager pluginManager;
Plugins::PluginsWithActionsModel pluginsWithActions;
pluginsWithActions.setSourceModel(&pluginManager);
Helpers::HelpersQmlWrapper helpersQmlWrapper;
LOG_INFO << "Models created";
Commands::CommandManager commandManager;
commandManager.InjectDependency(&artworkRepository);
commandManager.InjectDependency(&artItemsModel);
commandManager.InjectDependency(&filteredArtItemsModel);
commandManager.InjectDependency(&combinedArtworksModel);
commandManager.InjectDependency(&artworkUploader);
commandManager.InjectDependency(&uploadInfoRepository);
commandManager.InjectDependency(&warningsService);
commandManager.InjectDependency(&secretsManager);
commandManager.InjectDependency(&undoRedoManager);
commandManager.InjectDependency(&zipArchiver);
commandManager.InjectDependency(&keywordsSuggestor);
commandManager.InjectDependency(&settingsModel);
commandManager.InjectDependency(&recentDirectorieModel);
commandManager.InjectDependency(&spellCheckerService);
commandManager.InjectDependency(&spellCheckSuggestionModel);
commandManager.InjectDependency(&metadataSaverService);
commandManager.InjectDependency(&telemetryService);
commandManager.InjectDependency(&updateService);
commandManager.InjectDependency(&logsModel);
commandManager.InjectDependency(&localLibrary);
commandManager.InjectDependency(&metadataIOCoordinator);
commandManager.InjectDependency(&pluginManager);
commandManager.InjectDependency(&languagesModel);
commandManager.InjectDependency(&colorsModel);
commandManager.InjectDependency(&autoCompleteService);
commandManager.InjectDependency(&imageCachingService);
commandManager.InjectDependency(&replaceModel);
commandManager.InjectDependency(&deleteKeywordsModel);
commandManager.InjectDependency(&helpersQmlWrapper);
commandManager.ensureDependenciesInjected();
keywordsSuggestor.initSuggestionEngines();
// other initializations
secretsManager.setMasterPasswordHash(appSettings.value(Constants::MASTER_PASSWORD_HASH, "").toString());
uploadInfoRepository.initFromString(appSettings.value(Constants::UPLOAD_HOSTS, "").toString());
recentDirectorieModel.deserializeFromSettings(appSettings.value(Constants::RECENT_DIRECTORIES, "").toString());
commandManager.connectEntitiesSignalsSlots();
languagesModel.initFirstLanguage();
languagesModel.loadLanguages();
telemetryService.setInterfaceLanguage(languagesModel.getCurrentLanguage());
qmlRegisterType<Helpers::ClipboardHelper>("xpiks", 1, 0, "ClipboardHelper");
qmlRegisterType<QMLExtensions::TriangleElement>("xpiks", 1, 0, "TriangleElement");
QQmlApplicationEngine engine;
Helpers::GlobalImageProvider *globalProvider = new Helpers::GlobalImageProvider(QQmlImageProviderBase::Image);
QMLExtensions::CachingImageProvider *cachingProvider = new QMLExtensions::CachingImageProvider(QQmlImageProviderBase::Image);
cachingProvider->setImageCachingService(&imageCachingService);
QQmlContext *rootContext = engine.rootContext();
rootContext->setContextProperty("artItemsModel", &artItemsModel);
rootContext->setContextProperty("artworkRepository", &artworkRepository);
rootContext->setContextProperty("combinedArtworks", &combinedArtworksModel);
rootContext->setContextProperty("appSettings", &appSettings);
rootContext->setContextProperty("secretsManager", &secretsManager);
rootContext->setContextProperty("undoRedoManager", &undoRedoManager);
rootContext->setContextProperty("keywordsSuggestor", &keywordsSuggestor);
rootContext->setContextProperty("settingsModel", &settingsModel);
rootContext->setContextProperty("filteredArtItemsModel", &filteredArtItemsModel);
rootContext->setContextProperty("helpersWrapper", &helpersQmlWrapper);
rootContext->setContextProperty("recentDirectories", &recentDirectorieModel);
rootContext->setContextProperty("metadataIOCoordinator", &metadataIOCoordinator);
rootContext->setContextProperty("pluginManager", &pluginManager);
rootContext->setContextProperty("pluginsWithActions", &pluginsWithActions);
rootContext->setContextProperty("warningsModel", &warningsModel);
rootContext->setContextProperty("languagesModel", &languagesModel);
rootContext->setContextProperty("i18", &languagesModel);
rootContext->setContextProperty("Colors", &colorsModel);
rootContext->setContextProperty("acSource", &autoCompleteModel);
rootContext->setContextProperty("replaceModel", &replaceModel);
#ifdef QT_DEBUG
QVariant isDebug(true);
#else
QVariant isDebug(false);
#endif
rootContext->setContextProperty("debug", isDebug);
engine.addImageProvider("global", globalProvider);
engine.addImageProvider("cached", cachingProvider);
LOG_DEBUG << "About to load main view...";
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
LOG_DEBUG << "Main view loaded";
pluginManager.getUIProvider()->setQmlEngine(&engine);
QQuickWindow *window = qobject_cast<QQuickWindow *>(engine.rootObjects().at(0));
pluginManager.getUIProvider()->setRoot(window->contentItem());
#ifdef QT_DEBUG
if (argc > 1) {
QList<QUrl> pathes;
for (int i = 1; i < argc; ++i) {
pathes.append(QUrl::fromLocalFile(QString::fromUtf8(argv[i])));
}
commandManager.addInitialArtworks(pathes);
}
#endif
commandManager.afterConstructionCallback();
return app.exec();
}