Merge branch 'f/LEGACY-0-Setting-up-patches-installation-and-activation' of LotRO_Legacy/Legacy_v2 into dev

src/Legacy/legacyapplication.cpp

@@ -84,6 +84,11 @@ bool LegacyApplication::init()
     }
 
     qDebug() << "Initialising fonts and resources";
+    QDir::setCurrent(QApplication::applicationDirPath());
+    if (!FileSystem::folderExists("backup")) {
+        QDir dir;
+        dir.mkdir("backup");
+    }
 
     QResource::registerResource(QApplication::applicationDirPath() + "/data01.gtr");
     QResource::registerResource(QApplication::applicationDirPath() + "/data02.gtr");

src/Legacy/models/lotrodatmanager.cpp

@@ -7,13 +7,110 @@
 
 Q_DECLARE_METATYPE(LOTRO_DAT::DatLocaleManager::LOCALE)
 Q_DECLARE_METATYPE(LotroDatManager::Category)
+Q_DECLARE_METATYPE(LotroDatManager::Status)
 
 
+void debug::ClientLocalDatStatusChangedHandler(DatStatus::ProgressInfo info) {
+    if (info.status == DatStatus::DAT_STATUS::E_FREE) {
+        std::cout << "CLIENT_LOCAL: operation finished" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_BACKUP_CREATING) {
+        std::cout << "CLIENT_LOCAL: creating backup " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_BACKUP_REMOVING) {
+        std::cout << "CLIENT_LOCAL: removing backup " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_BACKUP_RESTORING) {
+        std::cout << "CLIENT_LOCAL: restoring backup " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_COMMITING) {
+        std::cout << "CLIENT_LOCAL: applying locales " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_EXTRACTING) {
+        std::cout << "CLIENT_LOCAL: extracting data " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_GATHERING_INFO) {
+        std::cout << "CLIENT_LOCAL: gathering info " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_INITIALISING) {
+        std::cout << "CLIENT_LOCAL: initialising " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_PATCHING) {
+        std::cout << "CLIENT_LOCAL: applying patch " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+}
+
+void debug::ClientGeneralDatStatusChangedHandler(DatStatus::ProgressInfo info) {
+    if (info.status == DatStatus::DAT_STATUS::E_FREE) {
+        std::cout << "CLIENT_GENERAL: operation finished" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_BACKUP_CREATING) {
+        std::cout << "CLIENT_GENERAL: creating backup " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_BACKUP_REMOVING) {
+        std::cout << "CLIENT_GENERAL: removing backup " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_BACKUP_RESTORING) {
+        std::cout << "CLIENT_GENERAL: restoring backup " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_COMMITING) {
+        std::cout << "CLIENT_GENERAL: applying locales " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_EXTRACTING) {
+        std::cout << "CLIENT_GENERAL: extracting data " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_GATHERING_INFO) {
+        std::cout << "CLIENT_GENERAL: gathering info " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_INITIALISING) {
+        std::cout << "CLIENT_GENERAL: initialising " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+    if (info.status == DatStatus::DAT_STATUS::E_PATCHING) {
+        std::cout << "CLIENT_GENERAL: applying patch " << info.percentage << "% "
+        << "(" << info.finished_parts << "/" << info.total_parts << ")" << std::endl;
+        return;
+    }
+}
+
 LotroDatManager::LotroDatManager(QObject *parent) :
     QObject(parent) {
 
-    qRegisterMetaType<LOTRO_DAT::DatLocaleManager::LOCALE>();
-    client_local_file_.GetStatusModule().AddStatusChangedCallbackFunction(file_status_updated_callback_);
+    qRegisterMetaType<Status>("Status");
+    qRegisterMetaType<LOTRO_DAT::DatLocaleManager::LOCALE>("LOCALE");
+    client_local_file_.GetStatusModule().AddStatusChangedCallbackFunction(client_local_status_updated_callback_);
+    client_general_file_.GetStatusModule().AddStatusChangedCallbackFunction(client_general_status_updated_callback_);
 }
 
 LotroDatManager::~LotroDatManager()
@@ -83,6 +180,10 @@ void LotroDatManager::initializeManager()
         return;
     }
 
+    qDebug() << "LotroDatManager initialisation successfull! Dat files: "
+             << QString::fromStdString(client_general_file_.GetIO().GetFilename().value)
+             << QString::fromStdString(client_local_file_.GetIO().GetFilename().value);
+
     emit operationFinished("initializeManager", {}, true);
 }
 
@@ -196,12 +297,16 @@ void LotroDatManager::enableCategory(QString patch_name, LotroDatManager::Catego
         emit operationFinished("enableCategory", {patch_name, category}, false);
         return;
     }
+    client_local_file_.GetFileSystem().CommitDirectories();
+    client_local_file_.GetLocaleManager().CommitLocales();
 
     if (client_general_file_.GetLocaleManager().EnableCategory(category).result != LOTRO_DAT::SUCCESS) {
         emit errorOccured("enableCategory", {patch_name, category}, "ErrorEnableCategoryClientGeneral");
         emit operationFinished("enableCategory", {patch_name, category}, false);
         return;
     }
+    client_general_file_.GetFileSystem().CommitDirectories();
+    client_general_file_.GetLocaleManager().CommitLocales();
 
     emit operationFinished("enableCategory", {patch_name, category});
 }

src/Legacy/models/lotrodatmanager.h

@@ -11,6 +11,13 @@
 
 using LOTRO_DAT::DatStatus;
 
+namespace debug {
+
+void ClientLocalDatStatusChangedHandler(DatStatus::ProgressInfo info);
+
+void ClientGeneralDatStatusChangedHandler(DatStatus::ProgressInfo info);
+}
+
 class LotroDatManager : public QObject
 {
     Q_OBJECT
@@ -70,9 +77,17 @@ signals:
 private:
     LOTRO_DAT::DatFile client_local_file_;
     LOTRO_DAT::DatFile client_general_file_;
-    const LOTRO_DAT::DatStatus::Callback file_status_updated_callback_ = [&](Status status) {
+
+    const LOTRO_DAT::DatStatus::Callback client_local_status_updated_callback_ = [&](Status status) {
         emit statusChanged(status);
+        debug::ClientLocalDatStatusChangedHandler(status);
     };
+
+    const LOTRO_DAT::DatStatus::Callback client_general_status_updated_callback_ = [&](Status status) {
+        emit statusChanged(status);
+        debug::ClientGeneralDatStatusChangedHandler(status);
+    };
+
 };
 
 #endif // LEGACYAPP_H

src/Legacy/models/patch/graphicspatch.cpp

@@ -89,6 +89,8 @@ void GraphicsPatch::download()
 
         qInfo() << *this << ": beginning download of file " << target_filename;
 
+        Settings::setValue("DatabaseNeedInstall/" + db_name, true);
+
         Downloader* downloader = new Downloader();
         downloader->setUrl(Settings::getValue(settings_prefix + "/url").toUrl());
         downloader->targetFile = target_file;
@@ -105,18 +107,23 @@ void GraphicsPatch::download()
 
 void GraphicsPatch::install()
 {
-    emit operationFinished(E_INSTALL, this);
-    return;
-
     installLoadscreens();
 
     foreach (QString db_name, QStringList({"image", "texture"})) {
+        if (!Settings::getValue("DatabaseNeedInstall/" + db_name).toBool()) {
+            continue;
+        }
+
         ++elapsed_patches_to_install_;
         QMetaObject::invokeMethod(lotro_mgr_, "installPatch", Qt::QueuedConnection,
                                   Q_ARG(QString, getPatchName() + "_" + db_name),
                                   Q_ARG(QString, Settings::getValue("PatchDatabases/" + db_name + "/path").toString())
                                   );
     }
+
+    if (elapsed_patches_to_install_ == 0) {
+        emit operationFinished(E_INSTALL, this);
+    }
 }
 
 void GraphicsPatch::activate()
@@ -188,6 +195,9 @@ void GraphicsPatch::onLotroDatManagerOperationFinished(QString operation_name, Q
             emit errorOccured(E_INSTALL, this, "Database " + args[0].toString() + " (" + args[1].toString() + ") was not installed due to Legacy core error.");
         }
 
+        QString db_name = args[0].toString().split('_').at(1);
+        Settings::setValue("DatabaseNeedInstall/" + db_name, false);
+
         --elapsed_patches_to_install_;
         if (!elapsed_patches_to_install_) {
             is_being_patched_by_lotro_dat_manager_ = false;
@@ -209,7 +219,7 @@ void GraphicsPatch::onLotroDatManagerOperationFinished(QString operation_name, Q
     }
 }
 
-void GraphicsPatch::onLotroDatManagerOperationStarted(QString operation_name, QVector<QVariant> args)
+void GraphicsPatch::onLotroDatManagerOperationStarted(QString, QVector<QVariant> args)
 {
     if (args.size() == 0 || !args[0].toString().contains(getPatchName())) {
         return;
@@ -229,6 +239,10 @@ void GraphicsPatch::onLotroDatManagerStatusChanged(LotroDatManager::Status statu
 
 void GraphicsPatch::installLoadscreens()
 {
+    if (!Settings::getValue("DatabaseNeedInstall/loadscreen").toBool()) {
+        return;
+    }
+
     QString locale_prefix = Settings::getValue("Lotro/original_locale").toString();
 
     const QStringList loadscreens_filenames = {
@@ -260,9 +274,10 @@ void GraphicsPatch::installLoadscreens()
     QString logo_path = Settings::getValue("Lotro/game_path").toString() + "/raw/" + (locale_prefix == "English" ? "en" : locale_prefix) + "/logo/";
 
     for (size_t i = 0; i < qMin(size_t(loadscreens_filenames.size()), database.CountRows()); ++i) {
+        data = database.GetNextFile();
         QFile::remove(logo_path + loadscreens_filenames[i] + "_ru");
 
-        if (!data.binary_data.WriteToFile((logo_path + loadscreens_filenames[i] + "_ru").toStdString())) {
+        if (!data.binary_data.WriteToFile((logo_path + loadscreens_filenames[i] + "_ru").toLocal8Bit())) {
             qWarning() << patch_name_ << "Cannot write to file " << logo_path + loadscreens_filenames[i];
         }
 

src/Legacy/models/patch/soundspatch.cpp

@@ -89,6 +89,8 @@ void SoundsPatch::download()
 
         qInfo() << *this << ": beginning download of file " << target_filename;
 
+        Settings::setValue("DatabaseNeedInstall/" + db_name, true);
+
         Downloader* downloader = new Downloader();
         downloader->setUrl(Settings::getValue(settings_prefix + "/url").toUrl());
         downloader->targetFile = target_file;
@@ -105,16 +107,21 @@ void SoundsPatch::download()
 
 void SoundsPatch::install()
 {
-    emit operationFinished(E_INSTALL, this);
-    return;
-
     foreach (QString db_name, QStringList({"sound"})) {
+        if (!Settings::getValue("DatabaseNeedInstall/" + db_name).toBool()) {
+            continue;
+        }
+
         ++elapsed_patches_to_install_;
         QMetaObject::invokeMethod(lotro_mgr_, "installPatch", Qt::QueuedConnection,
                                   Q_ARG(QString, getPatchName() + "_" + db_name),
                                   Q_ARG(QString, Settings::getValue("PatchDatabases/" + db_name + "/path").toString())
                                   );
     }
+
+    if (elapsed_patches_to_install_ == 0) {
+        emit operationFinished(E_INSTALL, this);
+    }
 }
 
 void SoundsPatch::activate()
@@ -170,6 +177,8 @@ void SoundsPatch::onLotroDatManagerOperationFinished(QString operation_name, QVe
             qCritical() << *this << "Database " + args[0].toString() + " (" + args[1].toString() + ") was not installed due to Legacy core error.";
             emit errorOccured(E_INSTALL, this, "Database " + args[0].toString() + " (" + args[1].toString() + ") was not installed due to Legacy core error.");
         }
+        QString db_name = args[0].toString().split('_').at(1);
+        Settings::setValue("DatabaseNeedInstall/" + db_name, false);
 
         --elapsed_patches_to_install_;
         if (!elapsed_patches_to_install_) {
@@ -192,7 +201,7 @@ void SoundsPatch::onLotroDatManagerOperationFinished(QString operation_name, QVe
     }
 }
 
-void SoundsPatch::onLotroDatManagerOperationStarted(QString operation_name, QVector<QVariant> args)
+void SoundsPatch::onLotroDatManagerOperationStarted(QString, QVector<QVariant> args)
 {
     if (args.size() == 0 || !args[0].toString().contains(getPatchName())) {
         return;

src/Legacy/models/patch/textspatch.cpp

@@ -89,6 +89,8 @@ void TextsPatch::download()
 
         qInfo() << *this << ": beginning download of file " << target_filename;
 
+        Settings::setValue("DatabaseNeedInstall/" + db_name, true);
+
         Downloader* downloader = new Downloader();
         downloader->setUrl(Settings::getValue(settings_prefix + "/url").toUrl());
         downloader->targetFile = target_file;
@@ -105,16 +107,21 @@ void TextsPatch::download()
 
 void TextsPatch::install()
 {
-    emit operationFinished(E_INSTALL, this);
-    return;
-
     foreach (QString db_name, databases_names) {
+        if (!Settings::getValue("DatabaseNeedInstall/" + db_name).toBool()) {
+            continue;
+        }
+
         ++elapsed_patches_to_install_;
         QMetaObject::invokeMethod(lotro_mgr_, "installPatch", Qt::QueuedConnection,
                                   Q_ARG(QString, getPatchName() + "_" + db_name),
                                   Q_ARG(QString, Settings::getValue("PatchDatabases/" + db_name + "/path").toString())
                                   );
     }
+
+    if (elapsed_patches_to_install_ == 0) {
+        emit operationFinished(E_INSTALL, this);
+    }
 }
 
 void TextsPatch::activate()
@@ -199,6 +206,9 @@ void TextsPatch::onLotroDatManagerOperationFinished(QString operation_name, QVec
             emit errorOccured(E_INSTALL, this, "Database " + args[0].toString() + " (" + args[1].toString() + ") was not installed due to Legacy core error.");
         }
 
+        QString db_name = args[0].toString().split('_').at(1);
+        Settings::setValue("DatabaseNeedInstall/" + db_name, false);
+
         --elapsed_patches_to_install_;
         if (!elapsed_patches_to_install_) {
             is_being_patched_by_lotro_dat_manager_ = false;
@@ -220,7 +230,7 @@ void TextsPatch::onLotroDatManagerOperationFinished(QString operation_name, QVec
     }
 }
 
-void TextsPatch::onLotroDatManagerOperationStarted(QString operation_name, QVector<QVariant> args)
+void TextsPatch::onLotroDatManagerOperationStarted(QString, QVector<QVariant> args)
 {
     if (args.size() == 0 || !args[0].toString().contains(getPatchName())) {
         return;

src/Legacy/models/patchlist.cpp

@@ -95,6 +95,11 @@ QList<Patch *> PatchList::getPatchList()
     return {texts_patch_, graphics_patch_, sounds_patch_, videos_patch_};
 }
 
+LotroDatManager *PatchList::getManager()
+{
+    return lotro_mgr_;
+}
+
 void PatchList::onPatchOperationProgressChanged(Patch::OperationProgress operation_progress, Patch *patch)
 {
     patch_operations_status_[patch] = operation_progress;

src/Legacy/models/patchlist.h

@@ -22,6 +22,7 @@ public:
 
     QList<Patch *> getPatchList();
 
+    LotroDatManager* getManager();
 signals:
     void progressChanged(Patch::OperationProgress total_status);
     void patchOperationsStarted();

src/Legacy/models/settings.cpp

@@ -35,14 +35,25 @@ QMap<QString, QVariant> defaults = {
 
     // Flags, meaning that database is fresh and needs to be installed
 
-    {"DatabaseUpdated/text", false},           // TextsPatch
-    {"DatabaseUpdated/font", false},           // TextsPatch
-    {"DatabaseUpdated/image", false},          // GraphicsPatch
-    {"DatabaseUpdated/loadscreen", false},     // GraphicsPatch
-    {"DatabaseUpdated/texture", false},        // GraphicsPatch
-    {"DatabaseUpdated/sound", false},          // SoundsPatch
-    {"DatabaseUpdated/video", false},          // VideosPatch
-    {"DatabaseUpdated/micro", false},          // MircoPatch
+    {"DatabaseNeedInstall/text", false},           // TextsPatch
+    {"DatabaseNeedInstall/font", false},           // TextsPatch
+    {"DatabaseNeedInstall/image", false},          // GraphicsPatch
+    {"DatabaseNeedInstall/loadscreen", false},     // GraphicsPatch
+    {"DatabaseNeedInstall/texture", false},        // GraphicsPatch
+    {"DatabaseNeedInstall/sound", false},          // SoundsPatch
+    {"DatabaseNeedInstall/video", false},          // VideosPatch
+    {"DatabaseNeedInstall/micro", false},          // MircoPatch
+
+    // Flags, meaning that database was installed and needs to be activated
+
+    {"DatabaseNeedActivate/text", false},           // TextsPatch
+    {"DatabaseNeedActivate/font", false},           // TextsPatch
+    {"DatabaseNeedActivate/image", false},          // GraphicsPatch
+    {"DatabaseNeedActivate/loadscreen", false},     // GraphicsPatch
+    {"DatabaseNeedActivate/texture", false},        // GraphicsPatch
+    {"DatabaseNeedActivate/sound", false},          // SoundsPatch
+    {"DatabaseNeedActivate/video", false},          // VideosPatch
+    {"DatabaseNeedActivate/micro", false},          // MircoPatch
 
     // Localisation components
     {"Components/texts_main", false},          // TextsPatch

src/Legacy/widgets/chooseversiondialog.cpp

@@ -5,7 +5,8 @@
 #include "widgets/mainwindow.h"
 #include "constants.h"
 
-ChooseVersionDialog::ChooseVersionDialog(QWidget *parent) :
+ChooseVersionDialog::ChooseVersionDialog(LotroDatManager* mgr, QWidget *parent) :
+    mgr_(mgr),
     QWidget(parent),
     ui(new Ui::ChooseVersionDialog)
 {
@@ -41,14 +42,14 @@ void ChooseVersionDialog::on_start_patched_clicked()
 {
     ui->wait_widget->show();
     ui->cancel_widget->hide();
-//    QMetaObject::invokeMethod(lotro_manager, "StartGame", Qt::QueuedConnection, Q_ARG(LOTRO_DAT::DatLocaleManager::LOCALE, LOTRO_DAT::DatLocaleManager::PATCHED));
+    QMetaObject::invokeMethod(mgr_, "startGame", Qt::QueuedConnection, Q_ARG(LOTRO_DAT::DatLocaleManager::LOCALE, LOTRO_DAT::DatLocaleManager::PATCHED));
 }
 
 void ChooseVersionDialog::on_start_original_clicked()
 {
     ui->wait_widget->show();
     ui->cancel_widget->hide();
-//    QMetaObject::invokeMethod(lotro_manager, "StartGame", Qt::QueuedConnection, Q_ARG(LOTRO_DAT::DatLocaleManager::LOCALE, LOTRO_DAT::DatLocaleManager::ORIGINAL));
+    QMetaObject::invokeMethod(mgr_, "startGame", Qt::QueuedConnection, Q_ARG(LOTRO_DAT::DatLocaleManager::LOCALE, LOTRO_DAT::DatLocaleManager::ORIGINAL));
 }
 
 void ChooseVersionDialog::on_cancel_clicked()

src/Legacy/widgets/chooseversiondialog.h

@@ -4,6 +4,7 @@
 #include <QDialog>
 #include <QMouseEvent>
 #include <QSettings>
+#include "models/lotrodatmanager.h"
 
 class PatchDownloader;
 class LotroDatManager;
@@ -17,7 +18,7 @@ class ChooseVersionDialog : public QWidget
     Q_OBJECT
 
 public:
-    explicit ChooseVersionDialog(QWidget *parent = 0);
+    explicit ChooseVersionDialog(LotroDatManager* mgr, QWidget *parent = 0);
     ~ChooseVersionDialog();
 
 public slots:
@@ -43,6 +44,7 @@ signals:
 private:
     Ui::ChooseVersionDialog *ui;
     QPoint dragPosition;
+    LotroDatManager* mgr_;
 };
 
 #endif // CHOOSEVERSIONDIALOG_H

src/Legacy/widgets/mainwindow.cpp

@@ -69,7 +69,7 @@ MainWindow::MainWindow(PatchList *legacy_patches, QWidget *parent)
 
     qDebug() << __FUNCTION__ << "Initialising additional frames...";
 
-    choose_locale_dialog_ = new ChooseVersionDialog(this);
+    choose_locale_dialog_ = new ChooseVersionDialog(legacy_patches_->getManager(), this);
     choose_locale_dialog_->resize(size());
     choose_locale_dialog_->hide();
     connect(choose_locale_dialog_, &ChooseVersionDialog::cancelled, choose_locale_dialog_, &ChooseVersionDialog::hide);
@@ -376,6 +376,22 @@ void MainWindow::closeEvent(QCloseEvent *event)
     event->ignore();
 }
 
+void MainWindow::showChooseVersionDialog()
+{
+//    QGraphicsBlurEffect *effect = new QGraphicsBlurEffect();
+//    effect->setBlurRadius(10);
+//    effect->setBlurHints(QGraphicsBlurEffect::QualityHint);
+//    ui->content_area->setGraphicsEffect(effect);
+    choose_locale_dialog_->show();
+}
+
+void MainWindow::hideChooseVersionDialog()
+{
+//    ui->content_area->setGraphicsEffect(nullptr);
+    choose_locale_dialog_->hide();
+}
+
+
 void MainWindow::on_minimizeButton_clicked()
 {
     setWindowState(Qt::WindowMinimized);

src/Legacy/widgets/mainwindow.h

@@ -39,6 +39,9 @@ protected:
     virtual void closeEvent(QCloseEvent *event) override;
 
 public slots:
+    void showChooseVersionDialog();
+    void hideChooseVersionDialog();
+
     void showMessageDialog(QObject* emitter, QString message, QString ok_button_text = "Ок", QString cancel_button_text = "Отмена");
     void updateFontSizes();
 

src/Legacy/widgets/statuswidget.cpp

@@ -1,5 +1,4 @@
 #include "statuswidget.h"
-#include "ui_statuswidget.h"
 
 #include "models/patchlist.h"
 
@@ -271,6 +270,12 @@ void StatusWidget::onPatchTotalProgressChanged(Patch::OperationProgress operatio
     updateStatusBar(operation_progress);
 }
 
+void StatusWidget::on_game_button_clicked()
+{
+    MainWindow* window = qobject_cast<MainWindow*>(parentWidget()->parentWidget()->parentWidget());
+    window->showChooseVersionDialog();
+}
+
 void StatusWidget::onPatchProgressChanged(Patch::OperationProgress progress, Patch *patch)
 {
     QString label_name = patch->getPatchName().toLower() + "_status";
@@ -300,6 +305,7 @@ void StatusWidget::onPatchProgressChanged(Patch::OperationProgress progress, Pat
     }
 }
 
+
 void StatusWidget::updateStatusBar(Patch::OperationProgress progress)
 {
     if (last_statusbar_update_time_.elapsed() > 500) {

src/Legacy/widgets/statuswidget.h

@@ -8,6 +8,8 @@
 #include <QPropertyAnimation>
 #include <QGraphicsOpacityEffect>
 
+#include "ui_statuswidget.h"
+
 #include "models/patchlist.h"
 
 namespace Ui {
@@ -46,6 +48,8 @@ private slots:
     void onPatchTotalProgressChanged(Patch::OperationProgress operation_progress);
     void onPatchProgressChanged(Patch::OperationProgress progress, Patch* patch);
 
+    void on_game_button_clicked();
+
 private:
     void updateStatusBar(Patch::OperationProgress progress);