PrismLauncher/launcher/ui/MainWindow.cpp

1828 lines
62 KiB
C++
Raw Normal View History

2022-06-12 12:50:58 +01:00
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
2022-06-12 12:50:58 +01:00
* Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
* Copyright (C) 2023 TheKodeToad <TheKodeToad@proton.me>
2013-02-19 23:07:52 +00:00
*
2022-06-12 12:50:58 +01:00
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 3.
2013-01-09 18:22:22 +00:00
*
2022-06-12 12:50:58 +01:00
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
2013-03-11 21:19:17 +00:00
*
2022-06-12 12:50:58 +01:00
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
2013-01-09 18:22:22 +00:00
*
2022-06-12 12:50:58 +01:00
* This file incorporates work covered by the following copyright and
* permission notice:
2013-02-19 23:07:52 +00:00
*
2022-06-12 12:50:58 +01:00
* Copyright 2013-2021 MultiMC Contributors
2013-01-09 18:22:22 +00:00
*
2022-06-12 12:50:58 +01:00
* Authors: Andrew Okin
* Peterix
* Orochimarufan <orochimarufan.x3@gmail.com>
2013-03-11 21:19:17 +00:00
*
2022-06-12 12:50:58 +01:00
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
2013-01-09 18:22:22 +00:00
*
2022-06-12 12:50:58 +01:00
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
2013-01-09 18:22:22 +00:00
*/
2022-06-12 12:50:58 +01:00
2021-11-20 15:22:22 +00:00
#include "Application.h"
#include "BuildConfig.h"
#include "FileSystem.h"
2013-01-09 18:22:22 +00:00
#include "MainWindow.h"
#include "ui_MainWindow.h"
#include <QVariant>
#include <QUrl>
#include <QDir>
#include <QFileInfo>
#include <QKeyEvent>
#include <QAction>
#include <QActionGroup>
#include <QApplication>
#include <QButtonGroup>
#include <QHBoxLayout>
#include <QHeaderView>
#include <QMainWindow>
#include <QStatusBar>
#include <QToolBar>
#include <QWidget>
#include <QMenu>
#include <QMenuBar>
#include <QMessageBox>
#include <QFileDialog>
#include <QInputDialog>
#include <QLabel>
#include <QToolButton>
#include <QWidgetAction>
#include <QProgressDialog>
#include <QShortcut>
#include <BaseInstance.h>
#include <InstanceList.h>
#include <minecraft/MinecraftInstance.h>
#include <MMCZip.h>
#include <icons/IconList.h>
#include <java/JavaUtils.h>
#include <java/JavaInstallList.h>
#include <launch/LaunchTask.h>
#include <minecraft/auth/AccountList.h>
#include <SkinUtils.h>
#include <BuildConfig.h>
#include <net/NetJob.h>
#include <net/Download.h>
#include <news/NewsChecker.h>
#include <tools/BaseProfiler.h>
#include <updater/ExternalUpdater.h>
#include <DesktopServices.h>
#include "InstanceWindow.h"
#include "InstancePageProvider.h"
#include "JavaCommon.h"
#include "LaunchController.h"
#include "ui/instanceview/InstanceProxyModel.h"
#include "ui/instanceview/InstanceView.h"
#include "ui/instanceview/InstanceDelegate.h"
#include "ui/widgets/LabeledToolButton.h"
#include "ui/dialogs/NewInstanceDialog.h"
#include "ui/dialogs/NewsDialog.h"
#include "ui/dialogs/ProgressDialog.h"
#include "ui/dialogs/AboutDialog.h"
#include "ui/dialogs/CustomMessageBox.h"
#include "ui/dialogs/IconPickerDialog.h"
#include "ui/dialogs/CopyInstanceDialog.h"
#include "ui/dialogs/EditAccountDialog.h"
#include "ui/dialogs/ExportInstanceDialog.h"
#include "ui/dialogs/ExportPackDialog.h"
#include "ui/dialogs/ImportResourceDialog.h"
#include "ui/themes/ITheme.h"
#include "ui/themes/ThemeManager.h"
#include "minecraft/mod/tasks/LocalResourceParse.h"
#include "minecraft/mod/ModFolderModel.h"
#include "minecraft/mod/ShaderPackFolderModel.h"
#include "minecraft/WorldList.h"
#include "KonamiCode.h"
#include "InstanceImportTask.h"
#include "InstanceCopyTask.h"
#include "MMCTime.h"
namespace {
QString profileInUseFilter(const QString & profile, bool used)
{
if(used)
{
return QObject::tr("%1 (in use)").arg(profile);
}
else
{
return profile;
}
}
}
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow)
{
ui->setupUi(this);
setWindowIcon(APPLICATION->getThemedIcon("logo"));
setWindowTitle(APPLICATION->applicationDisplayName());
#ifndef QT_NO_ACCESSIBILITY
setAccessibleName(BuildConfig.LAUNCHER_DISPLAYNAME);
#endif
// instance toolbar stuff
2018-07-15 13:51:05 +01:00
{
// Qt doesn't like vertical moving toolbars, so we have to force them...
// See https://github.com/PolyMC/PolyMC/issues/493
connect(ui->instanceToolBar, &QToolBar::orientationChanged,
[=](Qt::Orientation) { ui->instanceToolBar->setOrientation(Qt::Vertical); });
2018-07-15 13:51:05 +01:00
// if you try to add a widget to a toolbar in a .ui file
// qt designer will delete it when you save the file >:(
changeIconButton = new LabeledToolButton(this);
2018-07-15 13:51:05 +01:00
changeIconButton->setObjectName(QStringLiteral("changeIconButton"));
2021-11-20 15:22:22 +00:00
changeIconButton->setIcon(APPLICATION->getThemedIcon("news"));
2018-07-15 13:51:05 +01:00
changeIconButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
connect(changeIconButton, &QToolButton::clicked, this, &MainWindow::on_actionChangeInstIcon_triggered);
ui->instanceToolBar->insertWidgetBefore(ui->actionLaunchInstance, changeIconButton);
2018-07-15 13:51:05 +01:00
renameButton = new LabeledToolButton(this);
2018-07-15 13:51:05 +01:00
renameButton->setObjectName(QStringLiteral("renameButton"));
renameButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
connect(renameButton, &QToolButton::clicked, this, &MainWindow::on_actionRenameInstance_triggered);
ui->instanceToolBar->insertWidgetBefore(ui->actionLaunchInstance, renameButton);
2018-07-15 13:51:05 +01:00
ui->instanceToolBar->insertSeparator(ui->actionLaunchInstance);
// restore the instance toolbar settings
auto const setting_name = QString("WideBarVisibility_%1").arg(ui->instanceToolBar->objectName());
if (!APPLICATION->settings()->contains(setting_name))
instanceToolbarSetting = APPLICATION->settings()->registerSetting(setting_name);
else
instanceToolbarSetting = APPLICATION->settings()->getSetting(setting_name);
ui->instanceToolBar->setVisibilityState(instanceToolbarSetting->get().toByteArray());
ui->instanceToolBar->addContextMenuAction(ui->newsToolBar->toggleViewAction());
ui->instanceToolBar->addContextMenuAction(ui->instanceToolBar->toggleViewAction());
ui->instanceToolBar->addContextMenuAction(ui->actionLockToolbars);
2018-07-15 13:51:05 +01:00
}
// set the menu for the folders help, accounts, and export tool buttons
2018-07-15 13:51:05 +01:00
{
auto foldersMenuButton = dynamic_cast<QToolButton*>(ui->mainToolBar->widgetForAction(ui->actionFoldersButton));
ui->actionFoldersButton->setMenu(ui->foldersMenu);
foldersMenuButton->setPopupMode(QToolButton::InstantPopup);
2018-07-15 13:51:05 +01:00
helpMenuButton = dynamic_cast<QToolButton*>(ui->mainToolBar->widgetForAction(ui->actionHelpButton));
ui->actionHelpButton->setMenu(new QMenu(this));
ui->actionHelpButton->menu()->addActions(ui->helpMenu->actions());
ui->actionHelpButton->menu()->removeAction(ui->actionCheckUpdate);
helpMenuButton->setPopupMode(QToolButton::InstantPopup);
2018-07-15 13:51:05 +01:00
auto accountMenuButton = dynamic_cast<QToolButton*>(ui->mainToolBar->widgetForAction(ui->actionAccountsButton));
accountMenuButton->setPopupMode(QToolButton::InstantPopup);
auto exportInstanceMenu = new QMenu(this);
exportInstanceMenu->addAction(ui->actionExportInstanceZip);
exportInstanceMenu->addAction(ui->actionExportInstanceMrPack);
exportInstanceMenu->addAction(ui->actionExportInstanceFlamePack);
ui->actionExportInstance->setMenu(exportInstanceMenu);
2018-07-15 13:51:05 +01:00
}
// hide, disable and show stuff
2018-07-15 13:51:05 +01:00
{
ui->actionReportBug->setVisible(!BuildConfig.BUG_TRACKER_URL.isEmpty());
ui->actionMATRIX->setVisible(!BuildConfig.MATRIX_URL.isEmpty());
ui->actionDISCORD->setVisible(!BuildConfig.DISCORD_URL.isEmpty());
ui->actionREDDIT->setVisible(!BuildConfig.SUBREDDIT_URL.isEmpty());
2018-07-15 13:51:05 +01:00
ui->actionCheckUpdate->setVisible(BuildConfig.UPDATER_ENABLED);
2018-07-15 13:51:05 +01:00
#ifndef Q_OS_MAC
ui->actionAddToPATH->setVisible(false);
#endif
// disabled until we have an instance selected
ui->instanceToolBar->setEnabled(false);
setInstanceActionsEnabled(false);
}
// add the toolbar toggles to the view menu
ui->viewMenu->addAction(ui->instanceToolBar->toggleViewAction());
ui->viewMenu->addAction(ui->newsToolBar->toggleViewAction());
2018-07-15 13:51:05 +01:00
updateThemeMenu();
updateMainToolBar();
2018-07-15 13:51:05 +01:00
// OSX magic.
setUnifiedTitleAndToolBarOnMac(true);
// Global shortcuts
{
// you can't set QKeySequence::StandardKey shortcuts in qt designer >:(
ui->actionAddInstance->setShortcut(QKeySequence::New);
ui->actionSettings->setShortcut(QKeySequence::Preferences);
ui->actionUndoTrashInstance->setShortcut(QKeySequence::Undo);
ui->actionDeleteInstance->setShortcuts({ QKeySequence(tr("Backspace")), QKeySequence::Delete });
ui->actionCloseWindow->setShortcut(QKeySequence::Close);
connect(ui->actionCloseWindow, &QAction::triggered, APPLICATION, &Application::closeCurrentWindow);
2018-07-15 13:51:05 +01:00
// FIXME: This is kinda weird. and bad. We need some kind of managed shutdown.
auto q = new QShortcut(QKeySequence::Quit, this);
connect(q, &QShortcut::activated, APPLICATION, &Application::quit);
2018-07-15 13:51:05 +01:00
}
// Konami Code
{
secretEventFilter = new KonamiCode(this);
connect(secretEventFilter, &KonamiCode::triggered, this, &MainWindow::konamiTriggered);
}
// Add the news label to the news toolbar.
{
m_newsChecker.reset(new NewsChecker(APPLICATION->network(), BuildConfig.NEWS_RSS_URL));
newsLabel = new QToolButton();
newsLabel->setIcon(APPLICATION->getThemedIcon("news"));
newsLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
newsLabel->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
newsLabel->setFocusPolicy(Qt::NoFocus);
ui->newsToolBar->insertWidget(ui->actionMoreNews, newsLabel);
QObject::connect(newsLabel, &QAbstractButton::clicked, this, &MainWindow::newsButtonClicked);
QObject::connect(m_newsChecker.get(), &NewsChecker::newsLoaded, this, &MainWindow::updateNewsLabel);
updateNewsLabel();
}
2018-07-15 13:51:05 +01:00
// Create the instance list widget
{
view = new InstanceView(ui->centralWidget);
2018-07-15 13:51:05 +01:00
view->setSelectionMode(QAbstractItemView::SingleSelection);
// FIXME: leaks ListViewDelegate
view->setItemDelegate(new ListViewDelegate(this));
view->setFrameShape(QFrame::NoFrame);
// do not show ugly blue border on the mac
view->setAttribute(Qt::WA_MacShowFocusRect, false);
view->installEventFilter(this);
view->setContextMenuPolicy(Qt::CustomContextMenu);
connect(view, &QWidget::customContextMenuRequested, this, &MainWindow::showInstanceContextMenu);
connect(view, &InstanceView::droppedURLs, this, &MainWindow::processURLs, Qt::QueuedConnection);
2018-07-15 13:51:05 +01:00
proxymodel = new InstanceProxyModel(this);
2021-11-20 15:22:22 +00:00
proxymodel->setSourceModel(APPLICATION->instances().get());
2018-07-15 13:51:05 +01:00
proxymodel->sort(0);
connect(proxymodel, &InstanceProxyModel::dataChanged, this, &MainWindow::instanceDataChanged);
view->setModel(proxymodel);
view->setSourceOfGroupCollapseStatus([](const QString & groupName)->bool {
2021-11-20 15:22:22 +00:00
return APPLICATION->instances()->isGroupCollapsed(groupName);
});
2021-11-20 15:22:22 +00:00
connect(view, &InstanceView::groupStateChanged, APPLICATION->instances().get(), &InstanceList::on_GroupStateChanged);
2018-07-15 13:51:05 +01:00
ui->horizontalLayout->addWidget(view);
}
// The cat background
{
// set the cat action priority here so you can still see the action in qt designer
ui->actionCAT->setPriority(QAction::LowPriority);
2021-11-20 15:22:22 +00:00
bool cat_enable = APPLICATION->settings()->get("TheCat").toBool();
2018-07-15 13:51:05 +01:00
ui->actionCAT->setChecked(cat_enable);
connect(ui->actionCAT, &QAction::toggled, this, &MainWindow::onCatToggled);
connect(APPLICATION, &Application::currentCatChanged, this, &MainWindow::onCatChanged);
2018-07-15 13:51:05 +01:00
setCatBackground(cat_enable);
}
// Lock toolbars
{
bool toolbarsLocked = APPLICATION->settings()->get("ToolbarsLocked").toBool();
ui->actionLockToolbars->setChecked(toolbarsLocked);
connect(ui->actionLockToolbars, &QAction::toggled, this, &MainWindow::lockToolbars);
lockToolbars(toolbarsLocked);
}
2018-07-15 13:51:05 +01:00
// start instance when double-clicked
connect(view, &InstanceView::activated, this, &MainWindow::instanceActivated);
2018-07-15 13:51:05 +01:00
// track the selection -- update the instance toolbar
connect(view->selectionModel(), &QItemSelectionModel::currentChanged, this, &MainWindow::instanceChanged);
// track icon changes and update the toolbar!
2021-11-20 15:22:22 +00:00
connect(APPLICATION->icons().get(), &IconList::iconUpdated, this, &MainWindow::iconUpdated);
2018-07-15 13:51:05 +01:00
// model reset -> selection is invalid. All the instance pointers are wrong.
2021-11-20 15:22:22 +00:00
connect(APPLICATION->instances().get(), &InstanceList::dataIsInvalid, this, &MainWindow::selectionBad);
2018-07-15 13:51:05 +01:00
// handle newly added instances
2021-11-20 15:22:22 +00:00
connect(APPLICATION->instances().get(), &InstanceList::instanceSelectRequest, this, &MainWindow::instanceSelectRequest);
// When the global settings page closes, we want to know about it and update our state
2021-11-20 15:22:22 +00:00
connect(APPLICATION, &Application::globalSettingsClosed, this, &MainWindow::globalSettingsClosed);
2018-07-15 13:51:05 +01:00
m_statusLeft = new QLabel(tr("No instance selected"), this);
m_statusCenter = new QLabel(tr("Total playtime: 0s"), this);
2018-07-15 13:51:05 +01:00
statusBar()->addPermanentWidget(m_statusLeft, 1);
2021-10-10 00:25:31 +01:00
statusBar()->addPermanentWidget(m_statusCenter, 0);
2018-07-15 13:51:05 +01:00
// Add "manage accounts" button, right align
QWidget *spacer = new QWidget();
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
ui->mainToolBar->insertWidget(ui->actionAccountsButton, spacer);
2018-07-15 13:51:05 +01:00
2022-05-09 08:20:53 +01:00
// Use undocumented property... https://stackoverflow.com/questions/7121718/create-a-scrollbar-in-a-submenu-qt
ui->accountsMenu->setStyleSheet("QMenu { menu-scrollable: 1; }");
2018-07-15 13:51:05 +01:00
repopulateAccountsMenu();
// Update the menu when the active account changes.
// Shouldn't have to use lambdas here like this, but if I don't, the compiler throws a fit.
// Template hell sucks...
connect(
2021-11-20 15:22:22 +00:00
APPLICATION->accounts().get(),
&AccountList::defaultAccountChanged,
[this] {
2021-11-20 15:22:22 +00:00
defaultAccountChanged();
}
);
connect(
2021-11-20 15:22:22 +00:00
APPLICATION->accounts().get(),
&AccountList::listChanged,
[this]
{
repopulateAccountsMenu();
}
);
2018-07-15 13:51:05 +01:00
// Show initial account
2021-11-20 15:22:22 +00:00
defaultAccountChanged();
2018-07-15 13:51:05 +01:00
// TODO: refresh accounts here?
2021-11-20 15:22:22 +00:00
// auto accounts = APPLICATION->accounts();
2018-07-15 13:51:05 +01:00
// load the news
{
m_newsChecker->reloadNews();
updateNewsLabel();
}
if (BuildConfig.UPDATER_ENABLED) {
2021-11-20 15:22:22 +00:00
bool updatesAllowed = APPLICATION->updatesAreAllowed();
2018-07-15 13:51:05 +01:00
updatesAllowedChanged(updatesAllowed);
connect(ui->actionCheckUpdate, &QAction::triggered, this, &MainWindow::checkForUpdates);
2018-07-15 13:51:05 +01:00
// set up the updater object.
auto updater = APPLICATION->updater();
if (updater) {
connect(updater.get(), &ExternalUpdater::canCheckForUpdatesChanged, this, &MainWindow::updatesAllowedChanged);
}
2018-07-15 13:51:05 +01:00
}
connect(ui->actionUndoTrashInstance, &QAction::triggered, this, &MainWindow::undoTrashInstance);
2021-11-20 15:22:22 +00:00
setSelectedInstanceById(APPLICATION->settings()->get("SelectedInstance").toString());
2018-07-15 13:51:05 +01:00
// removing this looks stupid
view->setFocus();
retranslateUi();
}
// macOS always has a native menu bar, so these fixes are not applicable
// Other systems may or may not have a native menu bar (most do not - it seems like only Ubuntu Unity does)
#ifndef Q_OS_MAC
void MainWindow::keyReleaseEvent(QKeyEvent *event)
{
if(event->key()==Qt::Key_Alt && !APPLICATION->settings()->get("MenuBarInsteadOfToolBar").toBool())
ui->menuBar->setVisible(!ui->menuBar->isVisible());
else
QMainWindow::keyReleaseEvent(event);
}
#endif
void MainWindow::retranslateUi()
{
if (m_selectedInstance) {
m_statusLeft->setText(m_selectedInstance->getStatusbarDescription());
} else {
m_statusLeft->setText(tr("No instance selected"));
}
ui->retranslateUi(this);
MinecraftAccountPtr defaultAccount = APPLICATION->accounts()->defaultAccount();
if(defaultAccount) {
auto profileLabel = profileInUseFilter(defaultAccount->profileName(), defaultAccount->isInUse());
ui->actionAccountsButton->setText(profileLabel);
}
changeIconButton->setToolTip(ui->actionChangeInstIcon->toolTip());
renameButton->setToolTip(ui->actionRenameInstance->toolTip());
// replace the %1 with the launcher display name in some actions
if (helpMenuButton->toolTip().contains("%1"))
helpMenuButton->setToolTip(helpMenuButton->toolTip().arg(BuildConfig.LAUNCHER_DISPLAYNAME));
for (auto action : ui->helpMenu->actions()) {
if (action->text().contains("%1"))
action->setText(action->text().arg(BuildConfig.LAUNCHER_DISPLAYNAME));
if (action->toolTip().contains("%1"))
action->setToolTip(action->toolTip().arg(BuildConfig.LAUNCHER_DISPLAYNAME));
}
2013-01-09 18:22:22 +00:00
}
MainWindow::~MainWindow()
{
2013-03-11 21:19:17 +00:00
}
QMenu * MainWindow::createPopupMenu()
{
QMenu* filteredMenu = QMainWindow::createPopupMenu();
filteredMenu->removeAction( ui->mainToolBar->toggleViewAction() );
filteredMenu->addAction(ui->actionLockToolbars);
return filteredMenu;
}
void MainWindow::lockToolbars(bool state)
{
ui->mainToolBar->setMovable(!state);
ui->instanceToolBar->setMovable(!state);
ui->newsToolBar->setMovable(!state);
APPLICATION->settings()->set("ToolbarsLocked", state);
}
void MainWindow::konamiTriggered()
{
QString gradient = " stop:0 rgba(125, 0, 0, 255), stop:0.166 rgba(125, 125, 0, 255), stop:0.333 rgba(0, 125, 0, 255), stop:0.5 rgba(0, 125, 125, 255), stop:0.666 rgba(0, 0, 125, 255), stop:0.833 rgba(125, 0, 125, 255), stop:1 rgba(125, 0, 0, 255));";
QString stylesheet = "background-color: qlineargradient(spread:pad, x1:0, y1:0, x2:1, y2:0," + gradient;
if (ui->mainToolBar->styleSheet() == stylesheet) {
ui->mainToolBar->setStyleSheet("");
ui->instanceToolBar->setStyleSheet("");
ui->centralWidget->setStyleSheet("");
ui->newsToolBar->setStyleSheet("");
ui->statusBar->setStyleSheet("");
qDebug() << "Super Secret Mode DEACTIVATED!";
} else {
ui->mainToolBar->setStyleSheet(stylesheet);
ui->instanceToolBar->setStyleSheet("background-color: qlineargradient(spread:pad, x1:0, y1:0, x2:0, y2:1," + gradient);
ui->centralWidget->setStyleSheet("background-color: qlineargradient(spread:pad, x1:0, y1:0, x2:1, y2:1," + gradient);
ui->newsToolBar->setStyleSheet(stylesheet);
ui->statusBar->setStyleSheet(stylesheet);
qDebug() << "Super Secret Mode ACTIVATED!";
}
}
void MainWindow::showInstanceContextMenu(const QPoint &pos)
{
2018-07-15 13:51:05 +01:00
QList<QAction *> actions;
QAction *actionSep = new QAction("", this);
actionSep->setSeparator(true);
bool onInstance = view->indexAt(pos).isValid();
if (onInstance)
{
// reuse the file menu actions
actions = ui->fileMenu->actions();
2018-07-15 13:51:05 +01:00
// remove the add instance action, launcher settings action and close action
actions.removeFirst();
actions.removeLast();
actions.removeLast();
2018-07-15 13:51:05 +01:00
actions.prepend(ui->actionChangeInstIcon);
actions.prepend(ui->actionRenameInstance);
2018-07-15 13:51:05 +01:00
// add header
actions.prepend(actionSep);
QAction *actionVoid = new QAction(m_selectedInstance->name(), this);
actionVoid->setEnabled(false);
actions.prepend(actionVoid);
}
else
{
auto group = view->groupNameAt(pos);
QAction *actionVoid = new QAction(BuildConfig.LAUNCHER_DISPLAYNAME, this);
2018-07-15 13:51:05 +01:00
actionVoid->setEnabled(false);
QAction *actionCreateInstance = new QAction(tr("Create instance"), this);
actionCreateInstance->setToolTip(ui->actionAddInstance->toolTip());
if(!group.isNull())
{
QVariantMap data;
data["group"] = group;
actionCreateInstance->setData(data);
}
connect(actionCreateInstance, SIGNAL(triggered(bool)), SLOT(on_actionAddInstance_triggered()));
actions.prepend(actionSep);
actions.prepend(actionVoid);
actions.append(actionCreateInstance);
if(!group.isNull())
{
QAction *actionDeleteGroup = new QAction(tr("Delete group '%1'").arg(group), this);
QVariantMap data;
data["group"] = group;
actionDeleteGroup->setData(data);
connect(actionDeleteGroup, SIGNAL(triggered(bool)), SLOT(deleteGroup()));
actions.append(actionDeleteGroup);
}
}
QMenu myMenu;
myMenu.addActions(actions);
/*
if (onInstance)
myMenu.setEnabled(m_selectedInstance->canLaunch());
*/
myMenu.exec(view->mapToGlobal(pos));
}
void MainWindow::updateMainToolBar()
{
ui->menuBar->setVisible(APPLICATION->settings()->get("MenuBarInsteadOfToolBar").toBool());
ui->mainToolBar->setVisible(ui->menuBar->isNativeMenuBar() || !APPLICATION->settings()->get("MenuBarInsteadOfToolBar").toBool());
}
void MainWindow::updateToolsMenu()
{
bool currentInstanceRunning = m_selectedInstance && m_selectedInstance->isRunning();
ui->actionLaunchInstance->setDisabled(!m_selectedInstance || currentInstanceRunning);
ui->actionLaunchInstanceOffline->setDisabled(!m_selectedInstance || currentInstanceRunning);
ui->actionLaunchInstanceDemo->setDisabled(!m_selectedInstance || currentInstanceRunning);
2018-07-15 13:51:05 +01:00
QMenu *launchMenu = ui->actionLaunchInstance->menu();
if (launchMenu)
{
launchMenu->clear();
}
else
{
launchMenu = new QMenu(this);
}
QAction *normalLaunch = launchMenu->addAction(tr("Launch"));
normalLaunch->setShortcut(QKeySequence::Open);
QAction *normalLaunchOffline = launchMenu->addAction(tr("Launch Offline"));
normalLaunchOffline->setShortcut(QKeySequence(tr("Ctrl+Shift+O")));
QAction *normalLaunchDemo = launchMenu->addAction(tr("Launch Demo"));
normalLaunchDemo->setShortcut(QKeySequence(tr("Ctrl+Alt+O")));
if (m_selectedInstance)
{
normalLaunch->setEnabled(m_selectedInstance->canLaunch());
normalLaunchOffline->setEnabled(m_selectedInstance->canLaunch());
normalLaunchDemo->setEnabled(m_selectedInstance->canLaunch());
connect(normalLaunch, &QAction::triggered, [this]() {
APPLICATION->launch(m_selectedInstance, true, false);
});
connect(normalLaunchOffline, &QAction::triggered, [this]() {
APPLICATION->launch(m_selectedInstance, false, false);
});
connect(normalLaunchDemo, &QAction::triggered, [this]() {
APPLICATION->launch(m_selectedInstance, false, true);
});
}
else
{
normalLaunch->setDisabled(true);
normalLaunchOffline->setDisabled(true);
normalLaunchDemo->setDisabled(true);
}
// Disable demo-mode if not available.
auto instance = dynamic_cast<MinecraftInstance*>(m_selectedInstance.get());
if (instance) {
normalLaunchDemo->setEnabled(instance->supportsDemo());
}
2019-04-14 22:02:01 +01:00
QString profilersTitle = tr("Profilers");
launchMenu->addSeparator()->setText(profilersTitle);
2021-11-20 15:22:22 +00:00
for (auto profiler : APPLICATION->profilers().values())
2018-07-15 13:51:05 +01:00
{
QAction *profilerAction = launchMenu->addAction(profiler->name());
QAction *profilerOfflineAction = launchMenu->addAction(tr("%1 Offline").arg(profiler->name()));
2018-07-15 13:51:05 +01:00
QString error;
if (!profiler->check(&error))
{
profilerAction->setDisabled(true);
profilerOfflineAction->setDisabled(true);
2019-04-14 22:02:01 +01:00
QString profilerToolTip = tr("Profiler not setup correctly. Go into settings, \"External Tools\".");
profilerAction->setToolTip(profilerToolTip);
profilerOfflineAction->setToolTip(profilerToolTip);
2018-07-15 13:51:05 +01:00
}
else if (m_selectedInstance)
2018-07-15 13:51:05 +01:00
{
profilerAction->setEnabled(m_selectedInstance->canLaunch());
profilerOfflineAction->setEnabled(m_selectedInstance->canLaunch());
2018-07-15 13:51:05 +01:00
connect(profilerAction, &QAction::triggered, [this, profiler]()
{
APPLICATION->launch(m_selectedInstance, true, false, profiler.get());
2018-07-15 13:51:05 +01:00
});
connect(profilerOfflineAction, &QAction::triggered, [this, profiler]()
{
APPLICATION->launch(m_selectedInstance, false, false, profiler.get());
});
2018-07-15 13:51:05 +01:00
}
else
{
profilerAction->setDisabled(true);
profilerOfflineAction->setDisabled(true);
}
2018-07-15 13:51:05 +01:00
}
ui->actionLaunchInstance->setMenu(launchMenu);
}
void MainWindow::updateThemeMenu()
{
QMenu *themeMenu = ui->actionChangeTheme->menu();
if (themeMenu) {
themeMenu->clear();
} else {
themeMenu = new QMenu(this);
}
auto themes = APPLICATION->getValidApplicationThemes();
QActionGroup* themesGroup = new QActionGroup( this );
for (auto* theme : themes) {
QAction * themeAction = themeMenu->addAction(theme->name());
themeAction->setCheckable(true);
if (APPLICATION->settings()->get("ApplicationTheme").toString() == theme->id()) {
themeAction->setChecked(true);
}
themeAction->setActionGroup(themesGroup);
connect(themeAction, &QAction::triggered, [theme]() {
APPLICATION->setApplicationTheme(theme->id());
APPLICATION->settings()->set("ApplicationTheme", theme->id());
});
}
ui->actionChangeTheme->setMenu(themeMenu);
}
2013-11-27 22:39:49 +00:00
void MainWindow::repopulateAccountsMenu()
{
ui->accountsMenu->clear();
2018-07-15 13:51:05 +01:00
// NOTE: this is done so the accounts button text is not set to the accounts menu title
QMenu *accountsButtonMenu = ui->actionAccountsButton->menu();
if (accountsButtonMenu) {
accountsButtonMenu->clear();
} else {
accountsButtonMenu = new QMenu(this);
ui->actionAccountsButton->setMenu(accountsButtonMenu);
}
2021-11-20 15:22:22 +00:00
auto accounts = APPLICATION->accounts();
MinecraftAccountPtr defaultAccount = accounts->defaultAccount();
2018-07-15 13:51:05 +01:00
QString active_profileId = "";
2021-11-20 15:22:22 +00:00
if (defaultAccount)
2018-07-15 13:51:05 +01:00
{
// this can be called before accountMenuButton exists
if (ui->actionAccountsButton)
2018-07-15 13:51:05 +01:00
{
2021-11-20 15:22:22 +00:00
auto profileLabel = profileInUseFilter(defaultAccount->profileName(), defaultAccount->isInUse());
ui->actionAccountsButton->setText(profileLabel);
2018-07-15 13:51:05 +01:00
}
}
QActionGroup* accountsGroup = new QActionGroup(this);
2018-07-15 13:51:05 +01:00
if (accounts->count() <= 0)
{
ui->actionNoAccountsAdded->setEnabled(false);
ui->accountsMenu->addAction(ui->actionNoAccountsAdded);
2018-07-15 13:51:05 +01:00
}
else
{
// TODO: Nicer way to iterate?
for (int i = 0; i < accounts->count(); i++)
{
MinecraftAccountPtr account = accounts->at(i);
auto profileLabel = profileInUseFilter(account->profileName(), account->isInUse());
QAction *action = new QAction(profileLabel, this);
action->setData(i);
action->setCheckable(true);
action->setActionGroup(accountsGroup);
2021-11-20 15:22:22 +00:00
if (defaultAccount == account)
2018-07-15 13:51:05 +01:00
{
action->setChecked(true);
2018-07-15 13:51:05 +01:00
}
auto face = account->getFace();
if(!face.isNull()) {
action->setIcon(face);
}
else {
2021-11-20 15:22:22 +00:00
action->setIcon(APPLICATION->getThemedIcon("noaccount"));
}
const int highestNumberKey = 9;
if(i<highestNumberKey)
{
action->setShortcut(QKeySequence(tr("Ctrl+%1").arg(i + 1)));
}
ui->accountsMenu->addAction(action);
connect(action, SIGNAL(triggered(bool)), SLOT(changeActiveAccount()));
2018-07-15 13:51:05 +01:00
}
}
ui->accountsMenu->addSeparator();
2018-07-15 13:51:05 +01:00
ui->actionNoDefaultAccount->setData(-1);
ui->actionNoDefaultAccount->setChecked(!defaultAccount);
ui->actionNoDefaultAccount->setActionGroup(accountsGroup);
2018-07-15 13:51:05 +01:00
ui->accountsMenu->addAction(ui->actionNoDefaultAccount);
2018-07-15 13:51:05 +01:00
connect(ui->actionNoDefaultAccount, SIGNAL(triggered(bool)), SLOT(changeActiveAccount()));
2018-07-15 13:51:05 +01:00
ui->accountsMenu->addSeparator();
ui->accountsMenu->addAction(ui->actionManageAccounts);
accountsButtonMenu->addActions(ui->accountsMenu->actions());
2013-11-27 22:39:49 +00:00
}
void MainWindow::updatesAllowedChanged(bool allowed)
{
2018-07-15 13:51:05 +01:00
if(!BuildConfig.UPDATER_ENABLED)
{
return;
}
ui->actionCheckUpdate->setEnabled(allowed);
}
2013-11-27 22:39:49 +00:00
/*
* Assumes the sender is a QAction
*/
void MainWindow::changeActiveAccount()
{
2018-07-15 13:51:05 +01:00
QAction *sAction = (QAction *)sender();
2018-07-15 13:51:05 +01:00
// Profile's associated Mojang username
if (sAction->data().type() != QVariant::Type::Int)
2018-07-15 13:51:05 +01:00
return;
2013-11-27 22:39:49 +00:00
2018-07-15 13:51:05 +01:00
QVariant data = sAction->data();
bool valid = false;
int index = data.toInt(&valid);
if(!valid) {
index = -1;
2018-07-15 13:51:05 +01:00
}
2021-11-20 15:22:22 +00:00
auto accounts = APPLICATION->accounts();
accounts->setDefaultAccount(index == -1 ? nullptr : accounts->at(index));
defaultAccountChanged();
2013-11-27 22:39:49 +00:00
}
2021-11-20 15:22:22 +00:00
void MainWindow::defaultAccountChanged()
{
2018-07-15 13:51:05 +01:00
repopulateAccountsMenu();
2013-11-27 22:39:49 +00:00
2021-11-20 15:22:22 +00:00
MinecraftAccountPtr account = APPLICATION->accounts()->defaultAccount();
// FIXME: this needs adjustment for MSA
2021-11-20 15:22:22 +00:00
if (account && account->profileName() != "")
2018-07-15 13:51:05 +01:00
{
auto profileLabel = profileInUseFilter(account->profileName(), account->isInUse());
ui->actionAccountsButton->setText(profileLabel);
auto face = account->getFace();
if(face.isNull()) {
ui->actionAccountsButton->setIcon(APPLICATION->getThemedIcon("noaccount"));
}
else {
ui->actionAccountsButton->setIcon(face);
}
return;
2018-07-15 13:51:05 +01:00
}
2013-11-27 22:39:49 +00:00
2018-07-15 13:51:05 +01:00
// Set the icon to the "no account" icon.
ui->actionAccountsButton->setIcon(APPLICATION->getThemedIcon("noaccount"));
ui->actionAccountsButton->setText(tr("Accounts"));
}
2013-10-06 00:13:40 +01:00
bool MainWindow::eventFilter(QObject *obj, QEvent *ev)
{
2018-07-15 13:51:05 +01:00
if (obj == view)
{
if (ev->type() == QEvent::KeyPress)
{
secretEventFilter->input(ev);
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
switch (keyEvent->key())
{
2018-11-22 00:50:32 +00:00
/*
2018-07-15 13:51:05 +01:00
case Qt::Key_Enter:
case Qt::Key_Return:
activateInstance(m_selectedInstance);
return true;
2018-11-22 00:50:32 +00:00
*/
2018-07-15 13:51:05 +01:00
case Qt::Key_Delete:
on_actionDeleteInstance_triggered();
return true;
case Qt::Key_F5:
refreshInstances();
return true;
case Qt::Key_F2:
on_actionRenameInstance_triggered();
return true;
default:
break;
}
}
}
return QMainWindow::eventFilter(obj, ev);
}
void MainWindow::updateNewsLabel()
{
if (m_newsChecker->isLoadingNews())
{
newsLabel->setText(tr("Loading news..."));
newsLabel->setEnabled(false);
ui->actionMoreNews->setVisible(false);
}
else
{
QList<NewsEntryPtr> entries = m_newsChecker->getNewsEntries();
if (entries.length() > 0)
{
newsLabel->setText(entries[0]->title);
newsLabel->setEnabled(true);
ui->actionMoreNews->setVisible(true);
}
else
{
newsLabel->setText(tr("No news available."));
newsLabel->setEnabled(false);
ui->actionMoreNews->setVisible(false);
}
}
}
QList<int> stringToIntList(const QString &string)
{
#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
QStringList split = string.split(',', Qt::SkipEmptyParts);
#else
2018-07-15 13:51:05 +01:00
QStringList split = string.split(',', QString::SkipEmptyParts);
#endif
2018-07-15 13:51:05 +01:00
QList<int> out;
for (int i = 0; i < split.size(); ++i)
{
out.append(split.at(i).toInt());
}
return out;
}
QString intListToString(const QList<int> &list)
{
2018-07-15 13:51:05 +01:00
QStringList slist;
for (int i = 0; i < list.size(); ++i)
{
slist.append(QString::number(list.at(i)));
}
return slist.join(',');
}
2013-10-06 00:13:40 +01:00
void MainWindow::onCatToggled(bool state)
{
2018-07-15 13:51:05 +01:00
setCatBackground(state);
2021-11-20 15:22:22 +00:00
APPLICATION->settings()->set("TheCat", state);
}
2013-10-06 00:13:40 +01:00
void MainWindow::setCatBackground(bool enabled)
{
if (enabled) {
2018-12-24 02:26:14 +00:00
view->setStyleSheet(QString(R"(
InstanceView
{
2018-12-24 02:26:14 +00:00
background-image: url(:/backgrounds/%1);
background-attachment: fixed;
background-clip: padding;
background-position: bottom right;
background-repeat: none;
background-color:palette(base);
})")
.arg(ThemeManager::getCatImage()));
} else {
2018-07-15 13:51:05 +01:00
view->setStyleSheet(QString());
}
}
2016-10-02 23:55:54 +01:00
void MainWindow::runModalTask(Task *task)
2015-01-27 21:31:07 +00:00
{
2018-07-15 13:51:05 +01:00
connect(task, &Task::failed, [this](QString reason)
{
CustomMessageBox::selectable(this, tr("Error"), reason, QMessageBox::Critical)->show();
});
connect(task, &Task::succeeded, [this, task]()
{
QStringList warnings = task->warnings();
if(warnings.count())
{
CustomMessageBox::selectable(this, tr("Warnings"), warnings.join('\n'), QMessageBox::Warning)->show();
}
});
connect(task, &Task::aborted, [this]
{
CustomMessageBox::selectable(this, tr("Task aborted"), tr("The task has been aborted by the user."), QMessageBox::Information)->show();
});
2018-07-15 13:51:05 +01:00
ProgressDialog loadDialog(this);
loadDialog.setSkipButton(true, tr("Abort"));
loadDialog.execWithTask(task);
2016-10-02 23:55:54 +01:00
}
2018-03-19 01:36:12 +00:00
void MainWindow::instanceFromInstanceTask(InstanceTask *rawTask)
2016-10-02 23:55:54 +01:00
{
2021-11-20 15:22:22 +00:00
unique_qobject_ptr<Task> task(APPLICATION->instances()->wrapInstanceTask(rawTask));
2018-07-15 13:51:05 +01:00
runModalTask(task.get());
}
2016-10-02 23:55:54 +01:00
void MainWindow::on_actionCopyInstance_triggered()
2015-01-27 21:31:07 +00:00
{
2018-07-15 13:51:05 +01:00
if (!m_selectedInstance)
return;
2015-02-01 02:08:25 +00:00
2018-07-15 13:51:05 +01:00
CopyInstanceDialog copyInstDlg(m_selectedInstance, this);
if (!copyInstDlg.exec())
return;
2015-01-27 21:31:07 +00:00
auto copyTask = new InstanceCopyTask(m_selectedInstance, copyInstDlg.getChosenOptions());
2018-07-15 13:51:05 +01:00
copyTask->setName(copyInstDlg.instName());
copyTask->setGroup(copyInstDlg.instGroup());
copyTask->setIcon(copyInstDlg.iconKey());
2021-11-20 15:22:22 +00:00
unique_qobject_ptr<Task> task(APPLICATION->instances()->wrapInstanceTask(copyTask));
2018-07-15 13:51:05 +01:00
runModalTask(task.get());
2015-01-27 21:31:07 +00:00
}
2015-01-27 21:31:07 +00:00
void MainWindow::finalizeInstance(InstancePtr inst)
{
2018-07-15 13:51:05 +01:00
view->updateGeometries();
setSelectedInstanceById(inst->id());
2021-11-20 15:22:22 +00:00
if (APPLICATION->accounts()->anyAccountIsValid())
2018-07-15 13:51:05 +01:00
{
ProgressDialog loadDialog(this);
auto update = inst->createUpdateTask(Net::Mode::Online);
connect(update.get(), &Task::failed, [this](QString reason)
{
QString error = QString("Instance load failed: %1").arg(reason);
CustomMessageBox::selectable(this, tr("Error"), error, QMessageBox::Warning)->show();
});
if(update)
{
loadDialog.setSkipButton(true, tr("Abort"));
loadDialog.execWithTask(update.get());
}
}
else
{
2021-10-17 23:47:02 +01:00
CustomMessageBox::selectable(
this,
tr("Error"),
tr("The launcher cannot download Minecraft or update instances unless you have at least "
"one account added.\nPlease add your Mojang or Minecraft account."),
QMessageBox::Warning
)->show();
2018-07-15 13:51:05 +01:00
}
2013-01-09 18:22:22 +00:00
}
void MainWindow::addInstance(QString url)
2015-01-27 21:31:07 +00:00
{
2018-07-15 13:51:05 +01:00
QString groupName;
do
{
QObject* obj = sender();
if(!obj)
break;
QAction *action = qobject_cast<QAction *>(obj);
if(!action)
break;
auto map = action->data().toMap();
if(!map.contains("group"))
break;
groupName = map["group"].toString();
} while(0);
if(groupName.isEmpty())
{
2021-11-20 15:22:22 +00:00
groupName = APPLICATION->settings()->get("LastUsedGroupForNewInstance").toString();
2018-07-15 13:51:05 +01:00
}
NewInstanceDialog newInstDlg(groupName, url, this);
if (!newInstDlg.exec())
return;
2021-11-20 15:22:22 +00:00
APPLICATION->settings()->set("LastUsedGroupForNewInstance", newInstDlg.instGroup());
2018-07-15 13:51:05 +01:00
InstanceTask * creationTask = newInstDlg.extractTask();
if(creationTask)
{
instanceFromInstanceTask(creationTask);
}
2015-01-27 21:31:07 +00:00
}
void MainWindow::on_actionAddInstance_triggered()
{
2018-07-15 13:51:05 +01:00
addInstance();
}
void MainWindow::processURLs(QList<QUrl> urls)
{
// NOTE: This loop only processes one dropped file!
for (auto& url : urls) {
qDebug() << "Processing" << url;
// The isLocalFile() check below doesn't work as intended without an explicit scheme.
if (url.scheme().isEmpty())
url.setScheme("file");
if (!url.isLocalFile()) { // probably instance/modpack
2018-07-15 13:51:05 +01:00
addInstance(url.toString());
break;
2018-07-15 13:51:05 +01:00
}
auto localFileName = QDir::toNativeSeparators(url.toLocalFile()) ;
QFileInfo localFileInfo(localFileName);
auto type = ResourceUtils::identify(localFileInfo);
if (ResourceUtils::ValidResourceTypes.count(type) == 0) { // probably instance/modpack
addInstance(localFileName);
continue;
2018-07-15 13:51:05 +01:00
}
ImportResourceDialog dlg(localFileName, type, this);
if (dlg.exec() != QDialog::Accepted)
continue;
qDebug() << "Adding resource" << localFileName << "to" << dlg.selectedInstanceKey;
auto inst = APPLICATION->instances()->getInstanceById(dlg.selectedInstanceKey);
auto minecraftInst = std::dynamic_pointer_cast<MinecraftInstance>(inst);
switch (type) {
case PackedResourceType::ResourcePack:
minecraftInst->resourcePackList()->installResource(localFileName);
break;
case PackedResourceType::TexturePack:
minecraftInst->texturePackList()->installResource(localFileName);
break;
case PackedResourceType::DataPack:
qWarning() << "Importing of Data Packs not supported at this time. Ignoring" << localFileName;
break;
case PackedResourceType::Mod:
minecraftInst->loaderModList()->installMod(localFileName);
break;
case PackedResourceType::ShaderPack:
minecraftInst->shaderPackList()->installResource(localFileName);
break;
case PackedResourceType::WorldSave:
minecraftInst->worldList()->installWorld(localFileInfo);
break;
case PackedResourceType::UNKNOWN:
default:
qDebug() << "Can't Identify" << localFileName << "Ignoring it.";
break;
}
2018-07-15 13:51:05 +01:00
}
}
2015-09-15 22:02:21 +01:00
void MainWindow::on_actionREDDIT_triggered()
{
DesktopServices::openUrl(QUrl(BuildConfig.SUBREDDIT_URL));
2015-09-15 22:02:21 +01:00
}
void MainWindow::on_actionDISCORD_triggered()
{
DesktopServices::openUrl(QUrl(BuildConfig.DISCORD_URL));
}
2022-03-08 17:41:23 +00:00
void MainWindow::on_actionMATRIX_triggered()
{
DesktopServices::openUrl(QUrl(BuildConfig.MATRIX_URL));
}
void MainWindow::on_actionChangeInstIcon_triggered()
{
2018-07-15 13:51:05 +01:00
if (!m_selectedInstance)
return;
2013-10-06 00:13:40 +01:00
2018-07-15 13:51:05 +01:00
IconPickerDialog dlg(this);
dlg.execWithSelection(m_selectedInstance->iconKey());
if (dlg.result() == QDialog::Accepted)
{
m_selectedInstance->setIconKey(dlg.selectedIconKey);
2021-11-20 15:22:22 +00:00
auto icon = APPLICATION->icons()->getIcon(dlg.selectedIconKey);
2018-07-15 13:51:05 +01:00
ui->actionChangeInstIcon->setIcon(icon);
changeIconButton->setIcon(icon);
2018-07-15 13:51:05 +01:00
}
}
void MainWindow::iconUpdated(QString icon)
{
2018-07-15 13:51:05 +01:00
if (icon == m_currentInstIcon)
{
2021-11-20 15:22:22 +00:00
auto icon = APPLICATION->icons()->getIcon(m_currentInstIcon);
2018-07-15 13:51:05 +01:00
ui->actionChangeInstIcon->setIcon(icon);
changeIconButton->setIcon(icon);
2018-07-15 13:51:05 +01:00
}
}
void MainWindow::updateInstanceToolIcon(QString new_icon)
{
2018-07-15 13:51:05 +01:00
m_currentInstIcon = new_icon;
2021-11-20 15:22:22 +00:00
auto icon = APPLICATION->icons()->getIcon(m_currentInstIcon);
2018-07-15 13:51:05 +01:00
ui->actionChangeInstIcon->setIcon(icon);
changeIconButton->setIcon(icon);
}
void MainWindow::setSelectedInstanceById(const QString &id)
{
2018-07-15 13:51:05 +01:00
if (id.isNull())
return;
2021-11-20 15:22:22 +00:00
const QModelIndex index = APPLICATION->instances()->getInstanceIndexById(id);
2018-07-15 13:51:05 +01:00
if (index.isValid())
{
QModelIndex selectionIndex = proxymodel->mapFromSource(index);
view->selectionModel()->setCurrentIndex(selectionIndex, QItemSelectionModel::ClearAndSelect);
2019-07-10 03:23:24 +01:00
updateStatusCenter();
2018-07-15 13:51:05 +01:00
}
}
void MainWindow::on_actionChangeInstGroup_triggered()
{
2018-07-15 13:51:05 +01:00
if (!m_selectedInstance)
return;
2013-10-06 00:13:40 +01:00
2018-07-15 13:51:05 +01:00
bool ok = false;
InstanceId instId = m_selectedInstance->id();
2021-11-20 15:22:22 +00:00
QString name(APPLICATION->instances()->getInstanceGroup(instId));
auto groups = APPLICATION->instances()->getGroups();
2018-07-15 13:51:05 +01:00
groups.insert(0, "");
groups.sort(Qt::CaseInsensitive);
int foo = groups.indexOf(name);
2018-07-15 13:51:05 +01:00
name = QInputDialog::getItem(this, tr("Group name"), tr("Enter a new group name."), groups, foo, true, &ok);
name = name.simplified();
if (ok)
{
2021-11-20 15:22:22 +00:00
APPLICATION->instances()->setInstanceGroup(instId, name);
}
}
void MainWindow::deleteGroup()
{
2018-07-15 13:51:05 +01:00
QObject* obj = sender();
if(!obj)
return;
QAction *action = qobject_cast<QAction *>(obj);
if(!action)
return;
auto map = action->data().toMap();
if(!map.contains("group"))
return;
QString groupName = map["group"].toString();
if(!groupName.isEmpty())
{
2022-03-18 12:19:09 +00:00
auto reply = QMessageBox::question(this, tr("Delete group"), tr("Are you sure you want to delete the group %1?")
2018-11-08 16:30:30 +00:00
.arg(groupName), QMessageBox::Yes | QMessageBox::No);
if(reply == QMessageBox::Yes)
{
2021-11-20 15:22:22 +00:00
APPLICATION->instances()->deleteGroup(groupName);
2018-11-08 16:30:30 +00:00
}
2018-07-15 13:51:05 +01:00
}
}
void MainWindow::undoTrashInstance()
{
APPLICATION->instances()->undoTrashInstance();
ui->actionUndoTrashInstance->setEnabled(APPLICATION->instances()->trashedSomething());
}
2013-01-09 18:22:22 +00:00
void MainWindow::on_actionViewInstanceFolder_triggered()
{
2021-11-20 15:22:22 +00:00
QString str = APPLICATION->settings()->get("InstanceDir").toString();
2018-07-15 13:51:05 +01:00
DesktopServices::openDirectory(str);
2013-01-09 18:22:22 +00:00
}
void MainWindow::on_actionViewLauncherRootFolder_triggered()
{
const QString dataPath = QDir::currentPath();
DesktopServices::openDirectory(dataPath);
}
void MainWindow::refreshInstances()
2013-01-09 18:22:22 +00:00
{
2021-11-20 15:22:22 +00:00
APPLICATION->instances()->loadList();
2013-01-09 18:22:22 +00:00
}
void MainWindow::on_actionViewCentralModsFolder_triggered()
{
2021-11-20 15:22:22 +00:00
DesktopServices::openDirectory(APPLICATION->settings()->get("CentralModsDir").toString(), true);
2013-01-09 18:22:22 +00:00
}
void MainWindow::checkForUpdates()
2013-01-09 18:22:22 +00:00
{
2018-07-15 13:51:05 +01:00
if(BuildConfig.UPDATER_ENABLED)
{
APPLICATION->triggerUpdateCheck();
2018-07-15 13:51:05 +01:00
}
else
{
qWarning() << "Updater not set up. Cannot check for updates.";
}
2013-01-09 18:22:22 +00:00
}
void MainWindow::on_actionSettings_triggered()
{
2021-11-20 15:22:22 +00:00
APPLICATION->ShowGlobalSettings(this, "global-settings");
}
void MainWindow::globalSettingsClosed()
{
2018-07-15 13:51:05 +01:00
// FIXME: quick HACK to make this work. improve, optimize.
2021-11-20 15:22:22 +00:00
APPLICATION->instances()->loadList();
2018-07-15 13:51:05 +01:00
proxymodel->invalidate();
proxymodel->sort(0);
updateMainToolBar();
2018-07-15 13:51:05 +01:00
updateToolsMenu();
updateThemeMenu();
updateStatusCenter();
// This needs to be done to prevent UI elements disappearing in the event the config is changed
// but Prism Launcher exits abnormally, causing the window state to never be saved:
APPLICATION->settings()->set("MainWindowState", saveState().toBase64());
2018-07-15 13:51:05 +01:00
update();
}
2014-06-18 00:15:01 +01:00
void MainWindow::on_actionEditInstance_triggered()
{
2021-11-20 15:22:22 +00:00
APPLICATION->showInstanceWindow(m_selectedInstance);
2014-06-18 00:15:01 +01:00
}
void MainWindow::on_actionManageAccounts_triggered()
{
2021-11-20 15:22:22 +00:00
APPLICATION->ShowGlobalSettings(this, "accounts");
}
2013-01-09 18:22:22 +00:00
void MainWindow::on_actionReportBug_triggered()
{
DesktopServices::openUrl(QUrl(BuildConfig.BUG_TRACKER_URL));
2013-01-09 18:22:22 +00:00
}
void MainWindow::on_actionClearMetadata_triggered()
{
APPLICATION->metacache()->evictAll();
APPLICATION->metacache()->SaveNow();
}
#ifdef Q_OS_MAC
void MainWindow::on_actionAddToPATH_triggered()
{
auto binaryPath = APPLICATION->applicationFilePath();
auto targetPath = QString("/usr/local/bin/%1").arg(BuildConfig.LAUNCHER_APP_BINARY_NAME);
qDebug() << "Symlinking" << binaryPath << "to" << targetPath;
QStringList args;
args << "-e";
args << QString("do shell script \"mkdir -p /usr/local/bin && ln -sf '%1' '%2'\" with administrator privileges")
.arg(binaryPath, targetPath);
auto outcome = QProcess::execute("/usr/bin/osascript", args);
if (!outcome) {
QMessageBox::information(this, tr("Successfully added %1 to PATH").arg(BuildConfig.LAUNCHER_DISPLAYNAME),
tr("%1 was successfully added to your PATH. You can now start it by running `%2`.")
.arg(BuildConfig.LAUNCHER_DISPLAYNAME, BuildConfig.LAUNCHER_APP_BINARY_NAME));
} else {
QMessageBox::critical(this, tr("Failed to add %1 to PATH").arg(BuildConfig.LAUNCHER_DISPLAYNAME),
tr("An error occurred while trying to add %1 to PATH").arg(BuildConfig.LAUNCHER_DISPLAYNAME));
}
}
#endif
void MainWindow::on_actionOpenWiki_triggered()
{
DesktopServices::openUrl(QUrl(BuildConfig.HELP_URL.arg("")));
}
void MainWindow::on_actionMoreNews_triggered()
{
auto entries = m_newsChecker->getNewsEntries();
NewsDialog news_dialog(entries, this);
news_dialog.exec();
}
void MainWindow::newsButtonClicked()
{
auto entries = m_newsChecker->getNewsEntries();
NewsDialog news_dialog(entries, this);
news_dialog.toggleArticleList();
news_dialog.exec();
}
void MainWindow::onCatChanged(int) {
setCatBackground(APPLICATION->settings()->get("TheCat").toBool());
}
2013-01-09 18:22:22 +00:00
void MainWindow::on_actionAbout_triggered()
{
2018-07-15 13:51:05 +01:00
AboutDialog dialog(this);
dialog.exec();
2013-01-09 18:22:22 +00:00
}
2013-01-30 05:52:37 +00:00
void MainWindow::on_actionDeleteInstance_triggered()
{
if (!m_selectedInstance) {
2018-07-15 13:51:05 +01:00
return;
}
auto id = m_selectedInstance->id();
auto response = CustomMessageBox::selectable(this, tr("Confirm Deletion"),
tr("You are about to delete \"%1\".\n"
"This may be permanent and will completely delete the instance.\n\n"
"Are you sure?")
.arg(m_selectedInstance->name()),
QMessageBox::Warning, QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
->exec();
if (response != QMessageBox::Yes)
return;
auto linkedInstances = APPLICATION->instances()->getLinkedInstancesById(id);
if (!linkedInstances.empty()) {
response = CustomMessageBox::selectable(
this, tr("There are linked instances"),
tr("The following instance(s) might reference files in this instance:\n\n"
"%1\n\n"
"Deleting it could break the other instance(s), \n\n"
"Do you wish to proceed?", nullptr, linkedInstances.count()).arg(linkedInstances.join("\n")),
QMessageBox::Warning, QMessageBox::Yes | QMessageBox::No, QMessageBox::No
)->exec();
if (response != QMessageBox::Yes)
return;
}
if (APPLICATION->instances()->trashInstance(id)) {
ui->actionUndoTrashInstance->setEnabled(APPLICATION->instances()->trashedSomething());
return;
2018-07-15 13:51:05 +01:00
}
APPLICATION->instances()->deleteInstance(id);
}
void MainWindow::on_actionExportInstanceZip_triggered()
{
2018-07-15 13:51:05 +01:00
if (m_selectedInstance)
{
ExportInstanceDialog dlg(m_selectedInstance, this);
dlg.exec();
}
}
void MainWindow::on_actionExportInstanceMrPack_triggered()
{
if (m_selectedInstance)
{
ExportPackDialog dlg(m_selectedInstance, this);
dlg.exec();
}
}
void MainWindow::on_actionExportInstanceFlamePack_triggered()
{
if (m_selectedInstance) {
auto instance = dynamic_cast<MinecraftInstance*>(m_selectedInstance.get());
if (instance) {
if (instance->getPackProfile()->getComponent("org.quiltmc.quilt-loader")) {
QMessageBox msgBox;
msgBox.setText(tr("Quilt is currently not supported by CurseForge modpacks."));
msgBox.exec();
return;
}
ExportPackDialog dlg(m_selectedInstance, this, ModPlatform::ResourceProvider::FLAME);
dlg.exec();
}
}
}
void MainWindow::on_actionRenameInstance_triggered()
{
2018-07-15 13:51:05 +01:00
if (m_selectedInstance)
{
2018-11-22 00:50:32 +00:00
view->edit(view->currentIndex());
2018-07-15 13:51:05 +01:00
}
}
void MainWindow::on_actionViewSelectedInstFolder_triggered()
{
2018-07-15 13:51:05 +01:00
if (m_selectedInstance)
{
QString str = m_selectedInstance->instanceRoot();
DesktopServices::openDirectory(QDir(str).absolutePath());
}
}
2013-10-06 00:13:40 +01:00
void MainWindow::closeEvent(QCloseEvent *event)
2013-01-30 05:52:37 +00:00
{
2018-07-15 13:51:05 +01:00
// Save the window state and geometry.
2021-11-20 15:22:22 +00:00
APPLICATION->settings()->set("MainWindowState", saveState().toBase64());
APPLICATION->settings()->set("MainWindowGeometry", saveGeometry().toBase64());
instanceToolbarSetting->set(ui->instanceToolBar->getVisibilityState());
2018-07-15 13:51:05 +01:00
event->accept();
emit isClosing();
2013-01-30 05:52:37 +00:00
}
2013-03-11 21:19:17 +00:00
void MainWindow::changeEvent(QEvent* event)
{
2018-07-15 13:51:05 +01:00
if (event->type() == QEvent::LanguageChange)
{
retranslateUi();
2018-07-15 13:51:05 +01:00
}
QMainWindow::changeEvent(event);
}
2013-10-21 21:25:50 +01:00
void MainWindow::instanceActivated(QModelIndex index)
{
2018-07-15 13:51:05 +01:00
if (!index.isValid())
return;
QString id = index.data(InstanceList::InstanceIDRole).toString();
2021-11-20 15:22:22 +00:00
InstancePtr inst = APPLICATION->instances()->getInstanceById(id);
2018-07-15 13:51:05 +01:00
if (!inst)
return;
2013-10-21 21:25:50 +01:00
2018-07-15 13:51:05 +01:00
activateInstance(inst);
2013-10-21 21:25:50 +01:00
}
void MainWindow::on_actionLaunchInstance_triggered()
{
if(m_selectedInstance && !m_selectedInstance->isRunning())
2018-07-15 13:51:05 +01:00
{
2021-11-20 15:22:22 +00:00
APPLICATION->launch(m_selectedInstance);
2018-07-15 13:51:05 +01:00
}
}
void MainWindow::activateInstance(InstancePtr instance)
{
2021-11-20 15:22:22 +00:00
APPLICATION->launch(instance);
}
void MainWindow::on_actionLaunchInstanceOffline_triggered()
{
2018-07-15 13:51:05 +01:00
if (m_selectedInstance)
{
2021-11-20 15:22:22 +00:00
APPLICATION->launch(m_selectedInstance, false);
2018-07-15 13:51:05 +01:00
}
}
void MainWindow::on_actionLaunchInstanceDemo_triggered()
{
if (m_selectedInstance)
{
APPLICATION->launch(m_selectedInstance, false, true);
}
}
void MainWindow::on_actionKillInstance_triggered()
{
if(m_selectedInstance && m_selectedInstance->isRunning())
{
APPLICATION->kill(m_selectedInstance);
}
}
void MainWindow::on_actionCreateInstanceShortcut_triggered()
{
if (m_selectedInstance)
{
auto desktopPath = FS::getDesktopDir();
if (desktopPath.isEmpty()) {
// TODO come up with an alternative solution (open "save file" dialog)
QMessageBox::critical(this, tr("Create instance shortcut"), tr("Couldn't find desktop?!"));
return;
}
#if defined(Q_OS_MACOS)
QString appPath = QApplication::applicationFilePath();
if (appPath.startsWith("/private/var/")) {
QMessageBox::critical(this, tr("Create instance shortcut"), tr("The launcher is in the folder it was extracted from, therefore it cannot create shortcuts."));
return;
}
if (FS::createShortcut(FS::PathCombine(desktopPath, m_selectedInstance->name()),
appPath, { "--launch", m_selectedInstance->id() },
m_selectedInstance->name(), "")) {
QMessageBox::information(this, tr("Create instance shortcut"), tr("Created a shortcut to this instance on your desktop!"));
}
else
{
QMessageBox::critical(this, tr("Create instance shortcut"), tr("Failed to create instance shortcut!"));
}
#elif defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
QString appPath = QApplication::applicationFilePath();
if (appPath.startsWith("/tmp/.mount_")) {
// AppImage!
appPath = QProcessEnvironment::systemEnvironment().value(QStringLiteral("APPIMAGE"));
if (appPath.isEmpty())
{
QMessageBox::critical(this, tr("Create instance shortcut"), tr("Launcher is running as misconfigured AppImage? ($APPIMAGE environment variable is missing)"));
}
else if (appPath.endsWith("/"))
{
appPath.chop(1);
}
}
auto icon = APPLICATION->icons()->icon(m_selectedInstance->iconKey());
if (icon == nullptr)
{
icon = APPLICATION->icons()->icon("grass");
}
QString iconPath = FS::PathCombine(m_selectedInstance->instanceRoot(), "icon.png");
QFile iconFile(iconPath);
if (!iconFile.open(QFile::WriteOnly))
{
QMessageBox::critical(this, tr("Create instance shortcut"), tr("Failed to create icon for shortcut."));
return;
}
bool success = icon->icon().pixmap(64, 64).save(&iconFile, "PNG");
iconFile.close();
if (!success)
{
iconFile.remove();
QMessageBox::critical(this, tr("Create instance shortcut"), tr("Failed to create icon for shortcut."));
return;
}
QString desktopFilePath = FS::PathCombine(desktopPath, m_selectedInstance->name() + ".desktop");
QStringList args;
if (DesktopServices::isFlatpak()) {
QFileDialog fileDialog;
// workaround to make sure the portal file dialog opens in the desktop directory
fileDialog.setDirectoryUrl(desktopPath);
desktopFilePath = fileDialog.getSaveFileName(
this, tr("Create Shortcut"), desktopFilePath,
tr("Desktop Entries (*.desktop)"));
if (desktopFilePath.isEmpty())
return; // file dialog canceled by user
appPath = "flatpak";
QString flatpakAppId = BuildConfig.LAUNCHER_DESKTOPFILENAME;
flatpakAppId.remove(".desktop");
args.append({ "run", flatpakAppId });
}
args.append({ "--launch", m_selectedInstance->id() });
if (FS::createShortcut(desktopFilePath, appPath, args, m_selectedInstance->name(), iconPath)) {
QMessageBox::information(this, tr("Create instance shortcut"), tr("Created a shortcut to this instance on your desktop!"));
}
else
{
iconFile.remove();
QMessageBox::critical(this, tr("Create instance shortcut"), tr("Failed to create instance shortcut!"));
}
#elif defined(Q_OS_WIN)
auto icon = APPLICATION->icons()->icon(m_selectedInstance->iconKey());
if (icon == nullptr)
{
icon = APPLICATION->icons()->icon("grass");
}
QString iconPath = FS::PathCombine(m_selectedInstance->instanceRoot(), "icon.ico");
// part of fix for weird bug involving the window icon being replaced
// dunno why it happens, but this 2-line fix seems to be enough, so w/e
auto appIcon = APPLICATION->getThemedIcon("logo");
QFile iconFile(iconPath);
if (!iconFile.open(QFile::WriteOnly))
{
QMessageBox::critical(this, tr("Create instance shortcut"), tr("Failed to create icon for shortcut."));
return;
}
bool success = icon->icon().pixmap(64, 64).save(&iconFile, "ICO");
iconFile.close();
// restore original window icon
QGuiApplication::setWindowIcon(appIcon);
if (!success)
{
iconFile.remove();
QMessageBox::critical(this, tr("Create instance shortcut"), tr("Failed to create icon for shortcut."));
return;
}
if (FS::createShortcut(FS::PathCombine(desktopPath, m_selectedInstance->name()),
QApplication::applicationFilePath(), { "--launch", m_selectedInstance->id() },
m_selectedInstance->name(), iconPath)) {
QMessageBox::information(this, tr("Create instance shortcut"), tr("Created a shortcut to this instance on your desktop!"));
}
else
{
iconFile.remove();
QMessageBox::critical(this, tr("Create instance shortcut"), tr("Failed to create instance shortcut!"));
}
#else
QMessageBox::critical(this, tr("Create instance shortcut"), tr("Not supported on your platform!"));
#endif
}
}
void MainWindow::taskEnd()
{
2018-07-15 13:51:05 +01:00
QObject *sender = QObject::sender();
if (sender == m_versionLoadTask)
m_versionLoadTask = NULL;
2013-10-06 00:13:40 +01:00
2018-07-15 13:51:05 +01:00
sender->deleteLater();
}
void MainWindow::startTask(Task *task)
{
2018-07-15 13:51:05 +01:00
connect(task, SIGNAL(succeeded()), SLOT(taskEnd()));
connect(task, SIGNAL(failed(QString)), SLOT(taskEnd()));
task->start();
}
2013-10-06 00:13:40 +01:00
void MainWindow::instanceChanged(const QModelIndex &current, const QModelIndex &previous)
{
2018-07-15 13:51:05 +01:00
if (!current.isValid())
{
2021-11-20 15:22:22 +00:00
APPLICATION->settings()->set("SelectedInstance", QString());
2018-07-15 13:51:05 +01:00
selectionBad();
return;
}
if (m_selectedInstance) {
2022-06-10 08:48:18 +01:00
disconnect(m_selectedInstance.get(), &BaseInstance::runningStatusChanged, this, &MainWindow::refreshCurrentInstance);
}
2018-07-15 13:51:05 +01:00
QString id = current.data(InstanceList::InstanceIDRole).toString();
2021-11-20 15:22:22 +00:00
m_selectedInstance = APPLICATION->instances()->getInstanceById(id);
2018-07-15 13:51:05 +01:00
if (m_selectedInstance)
{
ui->instanceToolBar->setEnabled(true);
setInstanceActionsEnabled(true);
ui->actionLaunchInstance->setEnabled(m_selectedInstance->canLaunch());
2018-07-15 13:51:05 +01:00
ui->actionLaunchInstanceOffline->setEnabled(m_selectedInstance->canLaunch());
ui->actionLaunchInstanceDemo->setEnabled(m_selectedInstance->canLaunch());
// Disable demo-mode if not available.
auto instance = dynamic_cast<MinecraftInstance*>(m_selectedInstance.get());
if (instance) {
ui->actionLaunchInstanceDemo->setEnabled(instance->supportsDemo());
}
ui->actionKillInstance->setEnabled(m_selectedInstance->isRunning());
2018-07-15 13:51:05 +01:00
ui->actionExportInstance->setEnabled(m_selectedInstance->canExport());
renameButton->setText(m_selectedInstance->name());
2018-07-15 13:51:05 +01:00
m_statusLeft->setText(m_selectedInstance->getStatusbarDescription());
2019-07-10 03:23:24 +01:00
updateStatusCenter();
2018-07-15 13:51:05 +01:00
updateInstanceToolIcon(m_selectedInstance->iconKey());
updateToolsMenu();
2021-11-20 15:22:22 +00:00
APPLICATION->settings()->set("SelectedInstance", m_selectedInstance->id());
2022-06-10 08:48:18 +01:00
connect(m_selectedInstance.get(), &BaseInstance::runningStatusChanged, this, &MainWindow::refreshCurrentInstance);
2018-07-15 13:51:05 +01:00
}
else
{
ui->instanceToolBar->setEnabled(false);
setInstanceActionsEnabled(false);
ui->actionLaunchInstance->setEnabled(false);
ui->actionLaunchInstanceOffline->setEnabled(false);
ui->actionLaunchInstanceDemo->setEnabled(false);
ui->actionKillInstance->setEnabled(false);
2021-11-20 15:22:22 +00:00
APPLICATION->settings()->set("SelectedInstance", QString());
2018-07-15 13:51:05 +01:00
selectionBad();
return;
}
}
void MainWindow::instanceSelectRequest(QString id)
{
setSelectedInstanceById(id);
}
void MainWindow::instanceDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
{
2018-07-15 13:51:05 +01:00
auto current = view->selectionModel()->currentIndex();
QItemSelection test(topLeft, bottomRight);
if (test.contains(current))
{
instanceChanged(current, current);
}
}
void MainWindow::selectionBad()
{
2018-07-15 13:51:05 +01:00
// start by reseting everything...
m_selectedInstance = nullptr;
2018-07-15 13:51:05 +01:00
statusBar()->clearMessage();
ui->instanceToolBar->setEnabled(false);
setInstanceActionsEnabled(false);
updateToolsMenu();
renameButton->setText(tr("Rename Instance"));
2021-10-15 23:42:01 +01:00
updateInstanceToolIcon("grass");
2018-07-15 13:51:05 +01:00
// ...and then see if we can enable the previously selected instance
2021-11-20 15:22:22 +00:00
setSelectedInstanceById(APPLICATION->settings()->get("SelectedInstance").toString());
}
void MainWindow::checkInstancePathForProblems()
{
2021-11-20 15:22:22 +00:00
QString instanceFolder = APPLICATION->settings()->get("InstanceDir").toString();
2018-07-15 13:51:05 +01:00
if (FS::checkProblemticPathJava(QDir(instanceFolder)))
{
QMessageBox warning(this);
warning.setText(tr("Your instance folder contains \'!\' and this is known to cause Java problems!"));
2021-10-17 23:47:02 +01:00
warning.setInformativeText(
tr(
"You have now two options: <br/>"
" - change the instance folder in the settings <br/>"
" - move this installation of %1 to a different folder"
).arg(BuildConfig.LAUNCHER_DISPLAYNAME)
2021-10-17 23:47:02 +01:00
);
2018-07-15 13:51:05 +01:00
warning.setDefaultButton(QMessageBox::Ok);
warning.exec();
}
auto tempFolderText = tr("This is a problem: <br/>"
2021-10-17 23:47:02 +01:00
" - The launcher will likely be deleted without warning by the operating system <br/>"
" - close the launcher now and extract it to a real location, not a temporary folder");
2018-07-15 13:51:05 +01:00
QString pathfoldername = QDir(instanceFolder).absolutePath();
if (pathfoldername.contains("Rar$", Qt::CaseInsensitive))
{
QMessageBox warning(this);
2021-10-17 23:47:02 +01:00
warning.setText(tr("Your instance folder contains \'Rar$\' - that means you haven't extracted the launcher archive!"));
2018-07-15 13:51:05 +01:00
warning.setInformativeText(tempFolderText);
warning.setDefaultButton(QMessageBox::Ok);
warning.exec();
}
else if (pathfoldername.startsWith(QDir::tempPath()) || pathfoldername.contains("/TempState/"))
2018-07-15 13:51:05 +01:00
{
QMessageBox warning(this);
warning.setText(tr("Your instance folder is in a temporary folder: \'%1\'!").arg(QDir::tempPath()));
warning.setInformativeText(tempFolderText);
warning.setDefaultButton(QMessageBox::Ok);
warning.exec();
}
}
2019-07-10 03:23:24 +01:00
void MainWindow::updateStatusCenter()
{
2021-11-20 15:22:22 +00:00
m_statusCenter->setVisible(APPLICATION->settings()->get("ShowGlobalGameTime").toBool());
2021-11-20 15:22:22 +00:00
int timePlayed = APPLICATION->instances()->getTotalPlayTime();
if (timePlayed > 0) {
m_statusCenter->setText(tr("Total playtime: %1").arg(Time::prettifyDuration(timePlayed)));
}
2019-07-10 03:23:24 +01:00
}
// "Instance actions" are actions that require an instance to be selected (i.e. "new instance" is not here)
// Actions that also require other conditions (e.g. a running instance) won't be changed.
void MainWindow::setInstanceActionsEnabled(bool enabled)
{
ui->actionEditInstance->setEnabled(enabled);
ui->actionChangeInstGroup->setEnabled(enabled);
ui->actionViewSelectedInstFolder->setEnabled(enabled);
ui->actionExportInstance->setEnabled(enabled);
ui->actionDeleteInstance->setEnabled(enabled);
ui->actionCopyInstance->setEnabled(enabled);
ui->actionCreateInstanceShortcut->setEnabled(enabled);
}
2022-06-10 08:48:18 +01:00
void MainWindow::refreshCurrentInstance(bool running)
{
auto current = view->selectionModel()->currentIndex();
instanceChanged(current, current);
}