2022-06-12 17:20:58 +05:30
|
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
/*
|
|
|
|
* PolyMC - Minecraft Launcher
|
|
|
|
* Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
|
2013-02-20 04:37:52 +05:30
|
|
|
*
|
2022-06-12 17:20:58 +05:30
|
|
|
* 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 23:52:22 +05:30
|
|
|
*
|
2022-06-12 17:20:58 +05:30
|
|
|
* 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-12 02:49:17 +05:30
|
|
|
*
|
2022-06-12 17:20:58 +05:30
|
|
|
* 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 23:52:22 +05:30
|
|
|
*
|
2022-06-12 17:20:58 +05:30
|
|
|
* This file incorporates work covered by the following copyright and
|
|
|
|
* permission notice:
|
2013-02-20 04:37:52 +05:30
|
|
|
*
|
2022-06-12 17:20:58 +05:30
|
|
|
* Copyright 2013-2021 MultiMC Contributors
|
2013-01-09 23:52:22 +05:30
|
|
|
*
|
2022-06-12 17:20:58 +05:30
|
|
|
* Authors: Andrew Okin
|
|
|
|
* Peterix
|
|
|
|
* Orochimarufan <orochimarufan.x3@gmail.com>
|
2013-03-12 02:49:17 +05:30
|
|
|
*
|
2022-06-12 17:20:58 +05:30
|
|
|
* 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 23:52:22 +05:30
|
|
|
*
|
2022-06-12 17:20:58 +05:30
|
|
|
* 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 23:52:22 +05:30
|
|
|
*/
|
2022-06-12 17:20:58 +05:30
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
#include "Application.h"
|
2014-04-06 07:29:37 +05:30
|
|
|
#include "BuildConfig.h"
|
2013-01-09 23:52:22 +05:30
|
|
|
|
2013-11-04 07:23:05 +05:30
|
|
|
#include "MainWindow.h"
|
2015-03-02 02:50:57 +05:30
|
|
|
|
2022-05-02 22:40:45 +05:30
|
|
|
#include <QVariant>
|
|
|
|
#include <QUrl>
|
|
|
|
#include <QDir>
|
|
|
|
#include <QFileInfo>
|
|
|
|
|
|
|
|
#include <QKeyEvent>
|
|
|
|
#include <QAction>
|
2022-11-15 13:49:46 +05:30
|
|
|
#include <QActionGroup>
|
2022-05-02 22:40:45 +05:30
|
|
|
#include <QApplication>
|
|
|
|
#include <QButtonGroup>
|
|
|
|
#include <QHBoxLayout>
|
|
|
|
#include <QHeaderView>
|
|
|
|
#include <QMainWindow>
|
|
|
|
#include <QStatusBar>
|
|
|
|
#include <QToolBar>
|
|
|
|
#include <QWidget>
|
|
|
|
#include <QMenu>
|
|
|
|
#include <QMenuBar>
|
|
|
|
#include <QMessageBox>
|
2022-10-19 19:23:57 +05:30
|
|
|
#include <QFileDialog>
|
2022-05-02 22:40:45 +05:30
|
|
|
#include <QInputDialog>
|
|
|
|
#include <QLabel>
|
|
|
|
#include <QToolButton>
|
|
|
|
#include <QWidgetAction>
|
|
|
|
#include <QProgressDialog>
|
|
|
|
#include <QShortcut>
|
2015-10-20 20:48:53 +05:30
|
|
|
|
|
|
|
#include <BaseInstance.h>
|
|
|
|
#include <InstanceList.h>
|
|
|
|
#include <MMCZip.h>
|
|
|
|
#include <icons/IconList.h>
|
|
|
|
#include <java/JavaUtils.h>
|
2016-01-02 05:05:54 +05:30
|
|
|
#include <java/JavaInstallList.h>
|
2015-10-20 20:48:53 +05:30
|
|
|
#include <launch/LaunchTask.h>
|
2021-07-27 01:14:11 +05:30
|
|
|
#include <minecraft/auth/AccountList.h>
|
2016-04-10 07:59:29 +05:30
|
|
|
#include <SkinUtils.h>
|
2020-07-18 19:48:02 +05:30
|
|
|
#include <BuildConfig.h>
|
2015-10-20 20:48:53 +05:30
|
|
|
#include <net/NetJob.h>
|
2016-05-28 23:24:17 +05:30
|
|
|
#include <net/Download.h>
|
2022-02-10 17:25:07 +05:30
|
|
|
#include <news/NewsChecker.h>
|
2015-10-20 20:48:53 +05:30
|
|
|
#include <tools/BaseProfiler.h>
|
|
|
|
#include <updater/DownloadTask.h>
|
|
|
|
#include <updater/UpdateChecker.h>
|
2016-01-05 12:02:52 +05:30
|
|
|
#include <DesktopServices.h>
|
2016-08-06 19:09:29 +05:30
|
|
|
#include "InstanceWindow.h"
|
2015-10-20 20:48:53 +05:30
|
|
|
#include "InstancePageProvider.h"
|
|
|
|
#include "JavaCommon.h"
|
2016-08-11 04:14:01 +05:30
|
|
|
#include "LaunchController.h"
|
2021-11-22 08:25:16 +05:30
|
|
|
|
|
|
|
#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"
|
2022-06-26 04:45:16 +05:30
|
|
|
#include "ui/dialogs/NewsDialog.h"
|
2021-11-22 08:25:16 +05:30
|
|
|
#include "ui/dialogs/ProgressDialog.h"
|
|
|
|
#include "ui/dialogs/AboutDialog.h"
|
|
|
|
#include "ui/dialogs/VersionSelectDialog.h"
|
|
|
|
#include "ui/dialogs/CustomMessageBox.h"
|
|
|
|
#include "ui/dialogs/IconPickerDialog.h"
|
|
|
|
#include "ui/dialogs/CopyInstanceDialog.h"
|
|
|
|
#include "ui/dialogs/UpdateDialog.h"
|
|
|
|
#include "ui/dialogs/EditAccountDialog.h"
|
|
|
|
#include "ui/dialogs/ExportInstanceDialog.h"
|
2022-11-15 04:29:26 +05:30
|
|
|
#include "ui/themes/ITheme.h"
|
2021-11-22 08:25:16 +05:30
|
|
|
|
2016-11-18 20:34:08 +05:30
|
|
|
#include "UpdateController.h"
|
2018-03-15 13:57:45 +05:30
|
|
|
#include "KonamiCode.h"
|
2021-11-22 08:25:16 +05:30
|
|
|
|
|
|
|
#include "InstanceImportTask.h"
|
|
|
|
#include "InstanceCopyTask.h"
|
|
|
|
|
2021-09-29 03:50:34 +05:30
|
|
|
#include "MMCTime.h"
|
2015-10-20 20:48:53 +05:30
|
|
|
|
2021-07-27 01:14:11 +05:30
|
|
|
namespace {
|
|
|
|
QString profileInUseFilter(const QString & profile, bool used)
|
|
|
|
{
|
|
|
|
if(used)
|
|
|
|
{
|
|
|
|
return QObject::tr("%1 (in use)").arg(profile);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return profile;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-08 05:32:34 +05:30
|
|
|
// WHY: to hold the pre-translation strings together with the T pointer, so it can be retranslated without a lot of ugly code
|
2017-10-04 06:05:28 +05:30
|
|
|
template <typename T>
|
|
|
|
class Translated
|
2017-10-02 04:25:34 +05:30
|
|
|
{
|
|
|
|
public:
|
2018-07-15 18:21:05 +05:30
|
|
|
Translated(){}
|
|
|
|
Translated(QWidget *parent)
|
|
|
|
{
|
|
|
|
m_contained = new T(parent);
|
|
|
|
}
|
|
|
|
void setTooltipId(const char * tooltip)
|
|
|
|
{
|
|
|
|
m_tooltip = tooltip;
|
|
|
|
}
|
|
|
|
void setTextId(const char * text)
|
|
|
|
{
|
|
|
|
m_text = text;
|
|
|
|
}
|
|
|
|
operator T*()
|
|
|
|
{
|
|
|
|
return m_contained;
|
|
|
|
}
|
|
|
|
T * operator->()
|
|
|
|
{
|
|
|
|
return m_contained;
|
|
|
|
}
|
|
|
|
void retranslate()
|
|
|
|
{
|
|
|
|
if(m_text)
|
|
|
|
{
|
2021-10-18 04:17:02 +05:30
|
|
|
QString result;
|
|
|
|
result = QApplication::translate("MainWindow", m_text);
|
|
|
|
if(result.contains("%1")) {
|
2022-10-18 13:20:27 +05:30
|
|
|
result = result.arg(BuildConfig.LAUNCHER_DISPLAYNAME);
|
2021-10-18 04:17:02 +05:30
|
|
|
}
|
|
|
|
m_contained->setText(result);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
if(m_tooltip)
|
|
|
|
{
|
2021-10-18 04:17:02 +05:30
|
|
|
QString result;
|
|
|
|
result = QApplication::translate("MainWindow", m_tooltip);
|
|
|
|
if(result.contains("%1")) {
|
2022-10-18 13:20:27 +05:30
|
|
|
result = result.arg(BuildConfig.LAUNCHER_DISPLAYNAME);
|
2021-10-18 04:17:02 +05:30
|
|
|
}
|
|
|
|
m_contained->setToolTip(result);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
}
|
2017-10-02 04:25:34 +05:30
|
|
|
private:
|
2018-07-15 18:21:05 +05:30
|
|
|
T * m_contained = nullptr;
|
|
|
|
const char * m_text = nullptr;
|
|
|
|
const char * m_tooltip = nullptr;
|
2017-10-02 04:25:34 +05:30
|
|
|
};
|
2017-10-04 06:05:28 +05:30
|
|
|
using TranslatedAction = Translated<QAction>;
|
|
|
|
using TranslatedToolButton = Translated<QToolButton>;
|
2017-10-02 04:25:34 +05:30
|
|
|
|
|
|
|
class TranslatedToolbar
|
|
|
|
{
|
|
|
|
public:
|
2018-07-15 18:21:05 +05:30
|
|
|
TranslatedToolbar(){}
|
|
|
|
TranslatedToolbar(QWidget *parent)
|
|
|
|
{
|
|
|
|
m_contained = new QToolBar(parent);
|
|
|
|
}
|
|
|
|
void setWindowTitleId(const char * title)
|
|
|
|
{
|
|
|
|
m_title = title;
|
|
|
|
}
|
|
|
|
operator QToolBar*()
|
|
|
|
{
|
|
|
|
return m_contained;
|
|
|
|
}
|
|
|
|
QToolBar * operator->()
|
|
|
|
{
|
|
|
|
return m_contained;
|
|
|
|
}
|
|
|
|
void retranslate()
|
|
|
|
{
|
|
|
|
if(m_title)
|
|
|
|
{
|
|
|
|
m_contained->setWindowTitle(QApplication::translate("MainWindow", m_title));
|
|
|
|
}
|
|
|
|
}
|
2017-10-02 04:25:34 +05:30
|
|
|
private:
|
2018-07-15 18:21:05 +05:30
|
|
|
QToolBar * m_contained = nullptr;
|
|
|
|
const char * m_title = nullptr;
|
2017-10-02 04:25:34 +05:30
|
|
|
};
|
|
|
|
|
2015-10-20 20:48:53 +05:30
|
|
|
class MainWindow::Ui
|
2015-03-02 02:50:57 +05:30
|
|
|
{
|
|
|
|
public:
|
2018-07-15 18:21:05 +05:30
|
|
|
TranslatedAction actionAddInstance;
|
|
|
|
//TranslatedAction actionRefresh;
|
|
|
|
TranslatedAction actionCheckUpdate;
|
|
|
|
TranslatedAction actionSettings;
|
2022-02-10 17:25:07 +05:30
|
|
|
TranslatedAction actionMoreNews;
|
2018-07-15 18:21:05 +05:30
|
|
|
TranslatedAction actionManageAccounts;
|
|
|
|
TranslatedAction actionLaunchInstance;
|
2022-06-20 00:03:34 +05:30
|
|
|
TranslatedAction actionKillInstance;
|
2018-07-15 18:21:05 +05:30
|
|
|
TranslatedAction actionRenameInstance;
|
|
|
|
TranslatedAction actionChangeInstGroup;
|
|
|
|
TranslatedAction actionChangeInstIcon;
|
|
|
|
TranslatedAction actionEditInstance;
|
|
|
|
TranslatedAction actionViewSelectedInstFolder;
|
|
|
|
TranslatedAction actionDeleteInstance;
|
|
|
|
TranslatedAction actionCAT;
|
|
|
|
TranslatedAction actionCopyInstance;
|
|
|
|
TranslatedAction actionLaunchInstanceOffline;
|
2022-07-12 00:16:11 +05:30
|
|
|
TranslatedAction actionLaunchInstanceDemo;
|
2018-07-15 18:21:05 +05:30
|
|
|
TranslatedAction actionExportInstance;
|
|
|
|
QVector<TranslatedAction *> all_actions;
|
|
|
|
|
|
|
|
LabeledToolButton *renameButton = nullptr;
|
|
|
|
LabeledToolButton *changeIconButton = nullptr;
|
|
|
|
|
|
|
|
QMenu * foldersMenu = nullptr;
|
|
|
|
TranslatedToolButton foldersMenuButton;
|
|
|
|
TranslatedAction actionViewInstanceFolder;
|
|
|
|
TranslatedAction actionViewCentralModsFolder;
|
|
|
|
|
2022-07-30 23:12:33 +05:30
|
|
|
QMenu * editMenu = nullptr;
|
|
|
|
TranslatedAction actionUndoTrashInstance;
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
QMenu * helpMenu = nullptr;
|
|
|
|
TranslatedToolButton helpMenuButton;
|
2022-10-10 16:15:44 +05:30
|
|
|
TranslatedAction actionClearMetadata;
|
2022-11-05 20:01:07 +05:30
|
|
|
#ifdef Q_OS_MAC
|
2022-10-19 19:23:57 +05:30
|
|
|
TranslatedAction actionAddToPATH;
|
2022-11-05 20:01:07 +05:30
|
|
|
#endif
|
2018-07-15 18:21:05 +05:30
|
|
|
TranslatedAction actionReportBug;
|
|
|
|
TranslatedAction actionDISCORD;
|
2022-03-08 23:11:23 +05:30
|
|
|
TranslatedAction actionMATRIX;
|
2018-07-15 18:21:05 +05:30
|
|
|
TranslatedAction actionREDDIT;
|
|
|
|
TranslatedAction actionAbout;
|
|
|
|
|
2022-05-09 08:49:23 +05:30
|
|
|
TranslatedAction actionNoAccountsAdded;
|
|
|
|
TranslatedAction actionNoDefaultAccount;
|
|
|
|
|
2022-10-26 03:52:11 +05:30
|
|
|
TranslatedAction actionLockToolbars;
|
|
|
|
|
2022-11-15 01:03:25 +05:30
|
|
|
TranslatedAction actionChangeTheme;
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
QVector<TranslatedToolButton *> all_toolbuttons;
|
|
|
|
|
|
|
|
QWidget *centralWidget = nullptr;
|
|
|
|
QHBoxLayout *horizontalLayout = nullptr;
|
|
|
|
QStatusBar *statusBar = nullptr;
|
|
|
|
|
2022-04-09 01:07:18 +05:30
|
|
|
QMenuBar *menuBar = nullptr;
|
|
|
|
QMenu *fileMenu;
|
2022-04-16 13:02:08 +05:30
|
|
|
QMenu *viewMenu;
|
2022-04-09 01:07:18 +05:30
|
|
|
QMenu *profileMenu;
|
2022-04-16 13:02:08 +05:30
|
|
|
|
2022-04-16 23:05:13 +05:30
|
|
|
TranslatedAction actionCloseWindow;
|
2022-04-16 13:02:08 +05:30
|
|
|
|
2022-04-16 23:05:13 +05:30
|
|
|
TranslatedAction actionOpenWiki;
|
|
|
|
TranslatedAction actionNewsMenuBar;
|
2022-04-09 01:07:18 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
TranslatedToolbar mainToolBar;
|
|
|
|
TranslatedToolbar instanceToolBar;
|
2022-02-10 17:25:07 +05:30
|
|
|
TranslatedToolbar newsToolBar;
|
2018-07-15 18:21:05 +05:30
|
|
|
QVector<TranslatedToolbar *> all_toolbars;
|
|
|
|
|
2022-04-21 08:04:13 +05:30
|
|
|
void createMainToolbarActions(MainWindow *MainWindow)
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
|
|
|
actionAddInstance = TranslatedAction(MainWindow);
|
|
|
|
actionAddInstance->setObjectName(QStringLiteral("actionAddInstance"));
|
2021-11-20 20:52:22 +05:30
|
|
|
actionAddInstance->setIcon(APPLICATION->getThemedIcon("new"));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionAddInstance.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Add Instanc&e..."));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionAddInstance.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Add a new instance."));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionAddInstance->setShortcut(QKeySequence::New);
|
2018-07-15 18:21:05 +05:30
|
|
|
all_actions.append(&actionAddInstance);
|
|
|
|
|
|
|
|
actionViewInstanceFolder = TranslatedAction(MainWindow);
|
|
|
|
actionViewInstanceFolder->setObjectName(QStringLiteral("actionViewInstanceFolder"));
|
2021-11-20 20:52:22 +05:30
|
|
|
actionViewInstanceFolder->setIcon(APPLICATION->getThemedIcon("viewfolder"));
|
2022-04-22 04:01:03 +05:30
|
|
|
actionViewInstanceFolder.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&View Instance Folder"));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionViewInstanceFolder.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open the instance folder in a file browser."));
|
|
|
|
all_actions.append(&actionViewInstanceFolder);
|
|
|
|
|
|
|
|
actionViewCentralModsFolder = TranslatedAction(MainWindow);
|
|
|
|
actionViewCentralModsFolder->setObjectName(QStringLiteral("actionViewCentralModsFolder"));
|
2021-11-20 20:52:22 +05:30
|
|
|
actionViewCentralModsFolder->setIcon(APPLICATION->getThemedIcon("centralmods"));
|
2022-04-22 04:01:03 +05:30
|
|
|
actionViewCentralModsFolder.setTextId(QT_TRANSLATE_NOOP("MainWindow", "View &Central Mods Folder"));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionViewCentralModsFolder.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open the central mods folder in a file browser."));
|
|
|
|
all_actions.append(&actionViewCentralModsFolder);
|
2022-04-16 13:02:08 +05:30
|
|
|
|
|
|
|
foldersMenu = new QMenu(MainWindow);
|
|
|
|
foldersMenu->setTitle(tr("F&olders"));
|
|
|
|
foldersMenu->setToolTipsVisible(true);
|
|
|
|
|
|
|
|
foldersMenu->addAction(actionViewInstanceFolder);
|
2018-07-15 18:21:05 +05:30
|
|
|
foldersMenu->addAction(actionViewCentralModsFolder);
|
|
|
|
|
|
|
|
foldersMenuButton = TranslatedToolButton(MainWindow);
|
2022-04-16 13:02:08 +05:30
|
|
|
foldersMenuButton.setTextId(QT_TRANSLATE_NOOP("MainWindow", "F&olders"));
|
2018-07-15 18:21:05 +05:30
|
|
|
foldersMenuButton.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open one of the folders shared between instances."));
|
|
|
|
foldersMenuButton->setMenu(foldersMenu);
|
|
|
|
foldersMenuButton->setPopupMode(QToolButton::InstantPopup);
|
|
|
|
foldersMenuButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
|
2021-11-20 20:52:22 +05:30
|
|
|
foldersMenuButton->setIcon(APPLICATION->getThemedIcon("viewfolder"));
|
2019-07-22 00:42:05 +05:30
|
|
|
foldersMenuButton->setFocusPolicy(Qt::NoFocus);
|
2018-07-15 18:21:05 +05:30
|
|
|
all_toolbuttons.append(&foldersMenuButton);
|
|
|
|
|
|
|
|
actionSettings = TranslatedAction(MainWindow);
|
|
|
|
actionSettings->setObjectName(QStringLiteral("actionSettings"));
|
2021-11-20 20:52:22 +05:30
|
|
|
actionSettings->setIcon(APPLICATION->getThemedIcon("settings"));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionSettings->setMenuRole(QAction::PreferencesRole);
|
2022-04-22 04:01:03 +05:30
|
|
|
actionSettings.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Setti&ngs..."));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionSettings.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Change settings."));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionSettings->setShortcut(QKeySequence::Preferences);
|
2018-07-15 18:21:05 +05:30
|
|
|
all_actions.append(&actionSettings);
|
|
|
|
|
2022-07-30 23:12:33 +05:30
|
|
|
actionUndoTrashInstance = TranslatedAction(MainWindow);
|
|
|
|
actionUndoTrashInstance->setObjectName(QStringLiteral("actionUndoTrashInstance"));
|
|
|
|
actionUndoTrashInstance.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&Undo Last Instance Deletion"));
|
|
|
|
actionUndoTrashInstance->setEnabled(APPLICATION->instances()->trashedSomething());
|
2022-10-30 23:38:02 +05:30
|
|
|
actionUndoTrashInstance->setShortcut(QKeySequence::Undo);
|
2022-07-30 23:12:33 +05:30
|
|
|
all_actions.append(&actionUndoTrashInstance);
|
|
|
|
|
2022-10-10 16:15:44 +05:30
|
|
|
actionClearMetadata = TranslatedAction(MainWindow);
|
|
|
|
actionClearMetadata->setObjectName(QStringLiteral("actionClearMetadata"));
|
|
|
|
actionClearMetadata->setIcon(APPLICATION->getThemedIcon("refresh"));
|
|
|
|
actionClearMetadata.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&Clear Metadata Cache"));
|
|
|
|
actionClearMetadata.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Clear cached metadata"));
|
|
|
|
all_actions.append(&actionClearMetadata);
|
|
|
|
|
2022-10-19 19:23:57 +05:30
|
|
|
#ifdef Q_OS_MAC
|
|
|
|
actionAddToPATH = TranslatedAction(MainWindow);
|
|
|
|
actionAddToPATH->setObjectName(QStringLiteral("actionAddToPATH"));
|
2022-11-14 16:51:47 +05:30
|
|
|
actionAddToPATH.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Install to &PATH"));
|
|
|
|
actionAddToPATH.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Install a prismlauncher symlink to /usr/local/bin"));
|
2022-10-19 19:23:57 +05:30
|
|
|
all_actions.append(&actionAddToPATH);
|
|
|
|
#endif
|
|
|
|
|
2021-06-18 16:54:20 +05:30
|
|
|
if (!BuildConfig.BUG_TRACKER_URL.isEmpty()) {
|
|
|
|
actionReportBug = TranslatedAction(MainWindow);
|
|
|
|
actionReportBug->setObjectName(QStringLiteral("actionReportBug"));
|
2021-11-20 20:52:22 +05:30
|
|
|
actionReportBug->setIcon(APPLICATION->getThemedIcon("bug"));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionReportBug.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Report a &Bug..."));
|
2021-10-18 04:17:02 +05:30
|
|
|
actionReportBug.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open the bug tracker to report a bug with %1."));
|
2021-06-18 16:54:20 +05:30
|
|
|
all_actions.append(&actionReportBug);
|
|
|
|
}
|
2022-04-16 13:02:08 +05:30
|
|
|
|
2022-03-08 23:11:23 +05:30
|
|
|
if(!BuildConfig.MATRIX_URL.isEmpty()) {
|
|
|
|
actionMATRIX = TranslatedAction(MainWindow);
|
|
|
|
actionMATRIX->setObjectName(QStringLiteral("actionMATRIX"));
|
|
|
|
actionMATRIX->setIcon(APPLICATION->getThemedIcon("matrix"));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionMATRIX.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&Matrix Space"));
|
2022-03-08 23:11:23 +05:30
|
|
|
actionMATRIX.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open %1 Matrix space"));
|
|
|
|
all_actions.append(&actionMATRIX);
|
|
|
|
}
|
2021-06-18 16:54:20 +05:30
|
|
|
|
|
|
|
if (!BuildConfig.DISCORD_URL.isEmpty()) {
|
|
|
|
actionDISCORD = TranslatedAction(MainWindow);
|
|
|
|
actionDISCORD->setObjectName(QStringLiteral("actionDISCORD"));
|
2021-11-20 20:52:22 +05:30
|
|
|
actionDISCORD->setIcon(APPLICATION->getThemedIcon("discord"));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionDISCORD.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&Discord Guild"));
|
2022-03-08 23:11:23 +05:30
|
|
|
actionDISCORD.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open %1 Discord guild."));
|
2021-06-18 16:54:20 +05:30
|
|
|
all_actions.append(&actionDISCORD);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!BuildConfig.SUBREDDIT_URL.isEmpty()) {
|
|
|
|
actionREDDIT = TranslatedAction(MainWindow);
|
|
|
|
actionREDDIT->setObjectName(QStringLiteral("actionREDDIT"));
|
2021-11-20 20:52:22 +05:30
|
|
|
actionREDDIT->setIcon(APPLICATION->getThemedIcon("reddit-alien"));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionREDDIT.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Sub&reddit"));
|
2021-10-18 04:17:02 +05:30
|
|
|
actionREDDIT.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open %1 subreddit."));
|
2021-06-18 16:54:20 +05:30
|
|
|
all_actions.append(&actionREDDIT);
|
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
actionAbout = TranslatedAction(MainWindow);
|
|
|
|
actionAbout->setObjectName(QStringLiteral("actionAbout"));
|
2021-11-20 20:52:22 +05:30
|
|
|
actionAbout->setIcon(APPLICATION->getThemedIcon("about"));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionAbout->setMenuRole(QAction::AboutRole);
|
2022-04-16 13:02:08 +05:30
|
|
|
actionAbout.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&About %1"));
|
2021-10-18 04:17:02 +05:30
|
|
|
actionAbout.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "View information about %1."));
|
2018-07-15 18:21:05 +05:30
|
|
|
all_actions.append(&actionAbout);
|
|
|
|
|
|
|
|
if(BuildConfig.UPDATER_ENABLED)
|
|
|
|
{
|
|
|
|
actionCheckUpdate = TranslatedAction(MainWindow);
|
|
|
|
actionCheckUpdate->setObjectName(QStringLiteral("actionCheckUpdate"));
|
2021-11-20 20:52:22 +05:30
|
|
|
actionCheckUpdate->setIcon(APPLICATION->getThemedIcon("checkupdate"));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionCheckUpdate.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&Update..."));
|
2021-10-18 04:17:02 +05:30
|
|
|
actionCheckUpdate.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Check for new updates for %1."));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionCheckUpdate->setMenuRole(QAction::ApplicationSpecificRole);
|
2018-07-15 18:21:05 +05:30
|
|
|
all_actions.append(&actionCheckUpdate);
|
|
|
|
}
|
|
|
|
|
|
|
|
actionCAT = TranslatedAction(MainWindow);
|
|
|
|
actionCAT->setObjectName(QStringLiteral("actionCAT"));
|
|
|
|
actionCAT->setCheckable(true);
|
2021-11-20 20:52:22 +05:30
|
|
|
actionCAT->setIcon(APPLICATION->getThemedIcon("cat"));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionCAT.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&Meow"));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionCAT.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "It's a fluffy kitty :3"));
|
|
|
|
actionCAT->setPriority(QAction::LowPriority);
|
|
|
|
all_actions.append(&actionCAT);
|
|
|
|
|
|
|
|
// profile menu and its actions
|
|
|
|
actionManageAccounts = TranslatedAction(MainWindow);
|
|
|
|
actionManageAccounts->setObjectName(QStringLiteral("actionManageAccounts"));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionManageAccounts.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&Manage Accounts..."));
|
2018-07-15 18:21:05 +05:30
|
|
|
// FIXME: no tooltip!
|
|
|
|
actionManageAccounts->setCheckable(false);
|
2021-11-20 20:52:22 +05:30
|
|
|
actionManageAccounts->setIcon(APPLICATION->getThemedIcon("accounts"));
|
2018-07-15 18:21:05 +05:30
|
|
|
all_actions.append(&actionManageAccounts);
|
2022-10-26 03:52:11 +05:30
|
|
|
|
|
|
|
actionLockToolbars = TranslatedAction(MainWindow);
|
|
|
|
actionLockToolbars->setObjectName(QStringLiteral("actionLockToolbars"));
|
|
|
|
actionLockToolbars.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Lock Toolbars"));
|
|
|
|
actionLockToolbars->setCheckable(true);
|
|
|
|
all_actions.append(&actionLockToolbars);
|
2022-11-15 01:03:25 +05:30
|
|
|
|
|
|
|
actionChangeTheme = TranslatedAction(MainWindow);
|
|
|
|
actionChangeTheme->setObjectName(QStringLiteral("actionChangeTheme"));
|
|
|
|
actionChangeTheme.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Themes"));
|
|
|
|
all_actions.append(&actionChangeTheme);
|
2022-04-16 13:02:08 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void createMainToolbar(QMainWindow *MainWindow)
|
|
|
|
{
|
|
|
|
mainToolBar = TranslatedToolbar(MainWindow);
|
|
|
|
mainToolBar->setVisible(menuBar->isNativeMenuBar() || !APPLICATION->settings()->get("MenuBarInsteadOfToolBar").toBool());
|
|
|
|
mainToolBar->setObjectName(QStringLiteral("mainToolBar"));
|
|
|
|
mainToolBar->setAllowedAreas(Qt::TopToolBarArea | Qt::BottomToolBarArea);
|
|
|
|
mainToolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
|
|
|
|
mainToolBar->setFloatable(false);
|
|
|
|
mainToolBar.setWindowTitleId(QT_TRANSLATE_NOOP("MainWindow", "Main Toolbar"));
|
|
|
|
|
|
|
|
mainToolBar->addAction(actionAddInstance);
|
|
|
|
|
|
|
|
mainToolBar->addSeparator();
|
|
|
|
|
|
|
|
QWidgetAction* foldersButtonAction = new QWidgetAction(MainWindow);
|
|
|
|
foldersButtonAction->setDefaultWidget(foldersMenuButton);
|
|
|
|
mainToolBar->addAction(foldersButtonAction);
|
|
|
|
|
|
|
|
mainToolBar->addAction(actionSettings);
|
|
|
|
|
|
|
|
helpMenu = new QMenu(MainWindow);
|
|
|
|
helpMenu->setToolTipsVisible(true);
|
|
|
|
|
2022-10-10 16:15:44 +05:30
|
|
|
helpMenu->addAction(actionClearMetadata);
|
|
|
|
|
2022-10-19 19:23:57 +05:30
|
|
|
#ifdef Q_OS_MAC
|
|
|
|
helpMenu->addAction(actionAddToPATH);
|
|
|
|
#endif
|
|
|
|
|
2022-04-16 13:02:08 +05:30
|
|
|
if (!BuildConfig.BUG_TRACKER_URL.isEmpty()) {
|
|
|
|
helpMenu->addAction(actionReportBug);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!BuildConfig.MATRIX_URL.isEmpty()) {
|
|
|
|
helpMenu->addAction(actionMATRIX);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!BuildConfig.DISCORD_URL.isEmpty()) {
|
|
|
|
helpMenu->addAction(actionDISCORD);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!BuildConfig.SUBREDDIT_URL.isEmpty()) {
|
|
|
|
helpMenu->addAction(actionREDDIT);
|
|
|
|
}
|
|
|
|
|
|
|
|
helpMenu->addAction(actionAbout);
|
|
|
|
|
|
|
|
helpMenuButton = TranslatedToolButton(MainWindow);
|
|
|
|
helpMenuButton.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Help"));
|
|
|
|
helpMenuButton.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Get help with %1 or Minecraft."));
|
|
|
|
helpMenuButton->setMenu(helpMenu);
|
|
|
|
helpMenuButton->setPopupMode(QToolButton::InstantPopup);
|
|
|
|
helpMenuButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
|
|
|
|
helpMenuButton->setIcon(APPLICATION->getThemedIcon("help"));
|
|
|
|
helpMenuButton->setFocusPolicy(Qt::NoFocus);
|
|
|
|
all_toolbuttons.append(&helpMenuButton);
|
|
|
|
QWidgetAction* helpButtonAction = new QWidgetAction(MainWindow);
|
|
|
|
helpButtonAction->setDefaultWidget(helpMenuButton);
|
|
|
|
mainToolBar->addAction(helpButtonAction);
|
|
|
|
|
|
|
|
if(BuildConfig.UPDATER_ENABLED)
|
|
|
|
{
|
|
|
|
mainToolBar->addAction(actionCheckUpdate);
|
|
|
|
}
|
|
|
|
|
|
|
|
mainToolBar->addSeparator();
|
|
|
|
|
|
|
|
mainToolBar->addAction(actionCAT);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
all_toolbars.append(&mainToolBar);
|
|
|
|
MainWindow->addToolBar(Qt::TopToolBarArea, mainToolBar);
|
|
|
|
}
|
|
|
|
|
2022-04-16 23:05:13 +05:30
|
|
|
void createMenuBar(QMainWindow *MainWindow)
|
2022-04-09 01:07:18 +05:30
|
|
|
{
|
|
|
|
menuBar = new QMenuBar(MainWindow);
|
2022-04-16 03:55:37 +05:30
|
|
|
menuBar->setVisible(APPLICATION->settings()->get("MenuBarInsteadOfToolBar").toBool());
|
2022-04-09 01:07:18 +05:30
|
|
|
|
|
|
|
fileMenu = menuBar->addMenu(tr("&File"));
|
2022-06-22 09:49:20 +05:30
|
|
|
// Workaround for QTBUG-94802 (https://bugreports.qt.io/browse/QTBUG-94802); also present for other menus
|
|
|
|
fileMenu->setSeparatorsCollapsible(false);
|
2022-04-16 13:02:08 +05:30
|
|
|
fileMenu->addAction(actionAddInstance);
|
|
|
|
fileMenu->addAction(actionLaunchInstance);
|
2022-06-20 00:03:34 +05:30
|
|
|
fileMenu->addAction(actionKillInstance);
|
2022-04-16 13:02:08 +05:30
|
|
|
fileMenu->addAction(actionCloseWindow);
|
2022-04-09 01:07:18 +05:30
|
|
|
fileMenu->addSeparator();
|
2022-04-16 13:02:08 +05:30
|
|
|
fileMenu->addAction(actionEditInstance);
|
|
|
|
fileMenu->addAction(actionChangeInstGroup);
|
|
|
|
fileMenu->addAction(actionViewSelectedInstFolder);
|
|
|
|
fileMenu->addAction(actionExportInstance);
|
|
|
|
fileMenu->addAction(actionDeleteInstance);
|
|
|
|
fileMenu->addAction(actionCopyInstance);
|
2022-04-09 01:07:18 +05:30
|
|
|
fileMenu->addSeparator();
|
2022-04-16 22:47:34 +05:30
|
|
|
fileMenu->addAction(actionSettings);
|
2022-04-16 13:02:08 +05:30
|
|
|
|
2022-07-30 23:12:33 +05:30
|
|
|
editMenu = menuBar->addMenu(tr("&Edit"));
|
|
|
|
editMenu->addAction(actionUndoTrashInstance);
|
|
|
|
|
2022-04-16 13:02:08 +05:30
|
|
|
viewMenu = menuBar->addMenu(tr("&View"));
|
2022-06-22 09:49:20 +05:30
|
|
|
viewMenu->setSeparatorsCollapsible(false);
|
2022-11-15 01:03:25 +05:30
|
|
|
viewMenu->addAction(actionChangeTheme);
|
|
|
|
viewMenu->addSeparator();
|
2022-04-16 13:02:08 +05:30
|
|
|
viewMenu->addAction(actionCAT);
|
|
|
|
viewMenu->addSeparator();
|
|
|
|
|
2022-10-26 03:52:11 +05:30
|
|
|
viewMenu->addAction(actionLockToolbars);
|
|
|
|
|
2022-04-16 13:02:08 +05:30
|
|
|
menuBar->addMenu(foldersMenu);
|
2022-04-09 01:07:18 +05:30
|
|
|
|
2022-10-31 03:25:15 +05:30
|
|
|
profileMenu = menuBar->addMenu(tr("&Accounts"));
|
2022-06-22 09:49:20 +05:30
|
|
|
profileMenu->setSeparatorsCollapsible(false);
|
2022-04-16 13:02:08 +05:30
|
|
|
profileMenu->addAction(actionManageAccounts);
|
2022-04-09 01:07:18 +05:30
|
|
|
|
|
|
|
helpMenu = menuBar->addMenu(tr("&Help"));
|
2022-06-22 09:49:20 +05:30
|
|
|
helpMenu->setSeparatorsCollapsible(false);
|
2022-10-10 16:15:44 +05:30
|
|
|
helpMenu->addAction(actionClearMetadata);
|
2022-10-19 19:23:57 +05:30
|
|
|
#ifdef Q_OS_MAC
|
|
|
|
helpMenu->addAction(actionAddToPATH);
|
|
|
|
#endif
|
2022-10-10 16:15:44 +05:30
|
|
|
helpMenu->addSeparator();
|
2022-04-16 13:02:08 +05:30
|
|
|
helpMenu->addAction(actionAbout);
|
2022-04-16 22:47:34 +05:30
|
|
|
helpMenu->addAction(actionOpenWiki);
|
2022-04-16 13:02:08 +05:30
|
|
|
helpMenu->addAction(actionNewsMenuBar);
|
|
|
|
helpMenu->addSeparator();
|
|
|
|
if (!BuildConfig.BUG_TRACKER_URL.isEmpty())
|
|
|
|
helpMenu->addAction(actionReportBug);
|
|
|
|
if (!BuildConfig.MATRIX_URL.isEmpty())
|
|
|
|
helpMenu->addAction(actionMATRIX);
|
|
|
|
if (!BuildConfig.DISCORD_URL.isEmpty())
|
|
|
|
helpMenu->addAction(actionDISCORD);
|
|
|
|
if (!BuildConfig.SUBREDDIT_URL.isEmpty())
|
|
|
|
helpMenu->addAction(actionREDDIT);
|
|
|
|
if(BuildConfig.UPDATER_ENABLED)
|
2022-11-15 19:26:41 +05:30
|
|
|
{
|
|
|
|
helpMenu->addSeparator();
|
2022-04-16 13:02:08 +05:30
|
|
|
helpMenu->addAction(actionCheckUpdate);
|
2022-11-15 19:26:41 +05:30
|
|
|
}
|
2022-04-09 01:07:18 +05:30
|
|
|
MainWindow->setMenuBar(menuBar);
|
|
|
|
}
|
|
|
|
|
|
|
|
void createMenuActions(MainWindow *MainWindow)
|
|
|
|
{
|
2022-04-16 23:05:13 +05:30
|
|
|
actionCloseWindow = TranslatedAction(MainWindow);
|
|
|
|
actionCloseWindow->setObjectName(QStringLiteral("actionCloseWindow"));
|
|
|
|
actionCloseWindow.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Close &Window"));
|
|
|
|
actionCloseWindow.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Close the current window"));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionCloseWindow->setShortcut(QKeySequence::Close);
|
|
|
|
connect(actionCloseWindow, &QAction::triggered, APPLICATION, &Application::closeCurrentWindow);
|
2022-04-16 23:05:13 +05:30
|
|
|
all_actions.append(&actionCloseWindow);
|
2022-04-16 13:02:08 +05:30
|
|
|
|
2022-04-16 23:05:13 +05:30
|
|
|
actionOpenWiki = TranslatedAction(MainWindow);
|
|
|
|
actionOpenWiki->setObjectName(QStringLiteral("actionOpenWiki"));
|
2022-04-22 04:01:03 +05:30
|
|
|
actionOpenWiki.setTextId(QT_TRANSLATE_NOOP("MainWindow", "%1 &Help"));
|
2022-04-16 23:05:13 +05:30
|
|
|
actionOpenWiki.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open the %1 wiki"));
|
2022-11-15 19:26:41 +05:30
|
|
|
actionOpenWiki->setIcon(APPLICATION->getThemedIcon("help"));
|
2022-04-16 22:47:34 +05:30
|
|
|
connect(actionOpenWiki, &QAction::triggered, MainWindow, &MainWindow::on_actionOpenWiki_triggered);
|
2022-04-16 23:05:13 +05:30
|
|
|
all_actions.append(&actionOpenWiki);
|
2022-04-16 13:02:08 +05:30
|
|
|
|
2022-04-16 23:05:13 +05:30
|
|
|
actionNewsMenuBar = TranslatedAction(MainWindow);
|
|
|
|
actionNewsMenuBar->setObjectName(QStringLiteral("actionNewsMenuBar"));
|
|
|
|
actionNewsMenuBar.setTextId(QT_TRANSLATE_NOOP("MainWindow", "%1 &News"));
|
|
|
|
actionNewsMenuBar.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open the %1 wiki"));
|
2022-11-15 19:26:41 +05:30
|
|
|
actionNewsMenuBar->setIcon(APPLICATION->getThemedIcon("news"));
|
2022-04-16 13:02:08 +05:30
|
|
|
connect(actionNewsMenuBar, &QAction::triggered, MainWindow, &MainWindow::on_actionMoreNews_triggered);
|
2022-04-16 23:05:13 +05:30
|
|
|
all_actions.append(&actionNewsMenuBar);
|
2022-04-09 01:07:18 +05:30
|
|
|
}
|
|
|
|
|
2022-04-16 01:25:03 +05:30
|
|
|
// "Instance actions" are actions that require an instance to be selected (i.e. "new instance" is not here)
|
2022-06-20 00:03:34 +05:30
|
|
|
// Actions that also require other conditions (e.g. a running instance) won't be changed.
|
2022-04-16 13:02:08 +05:30
|
|
|
void setInstanceActionsEnabled(bool enabled)
|
2022-04-16 01:25:03 +05:30
|
|
|
{
|
2022-04-16 13:02:08 +05:30
|
|
|
actionEditInstance->setEnabled(enabled);
|
|
|
|
actionChangeInstGroup->setEnabled(enabled);
|
|
|
|
actionViewSelectedInstFolder->setEnabled(enabled);
|
|
|
|
actionExportInstance->setEnabled(enabled);
|
|
|
|
actionDeleteInstance->setEnabled(enabled);
|
|
|
|
actionCopyInstance->setEnabled(enabled);
|
2022-04-16 01:25:03 +05:30
|
|
|
}
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
void createStatusBar(QMainWindow *MainWindow)
|
|
|
|
{
|
|
|
|
statusBar = new QStatusBar(MainWindow);
|
|
|
|
statusBar->setObjectName(QStringLiteral("statusBar"));
|
|
|
|
MainWindow->setStatusBar(statusBar);
|
|
|
|
}
|
|
|
|
|
2022-02-10 17:25:07 +05:30
|
|
|
void createNewsToolbar(QMainWindow *MainWindow)
|
|
|
|
{
|
|
|
|
newsToolBar = TranslatedToolbar(MainWindow);
|
|
|
|
newsToolBar->setObjectName(QStringLiteral("newsToolBar"));
|
2022-03-20 02:29:00 +05:30
|
|
|
newsToolBar->setAllowedAreas(Qt::TopToolBarArea | Qt::BottomToolBarArea);
|
2022-02-10 17:25:07 +05:30
|
|
|
newsToolBar->setIconSize(QSize(16, 16));
|
|
|
|
newsToolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
|
|
|
|
newsToolBar->setFloatable(false);
|
|
|
|
newsToolBar->setWindowTitle(QT_TRANSLATE_NOOP("MainWindow", "News Toolbar"));
|
|
|
|
|
|
|
|
actionMoreNews = TranslatedAction(MainWindow);
|
|
|
|
actionMoreNews->setObjectName(QStringLiteral("actionMoreNews"));
|
|
|
|
actionMoreNews->setIcon(APPLICATION->getThemedIcon("news"));
|
|
|
|
actionMoreNews.setTextId(QT_TRANSLATE_NOOP("MainWindow", "More news..."));
|
|
|
|
actionMoreNews.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open the development blog to read more news about %1."));
|
|
|
|
all_actions.append(&actionMoreNews);
|
|
|
|
newsToolBar->addAction(actionMoreNews);
|
|
|
|
|
|
|
|
all_toolbars.append(&newsToolBar);
|
|
|
|
MainWindow->addToolBar(Qt::BottomToolBarArea, newsToolBar);
|
|
|
|
}
|
|
|
|
|
2022-04-16 13:02:08 +05:30
|
|
|
void createInstanceActions(QMainWindow *MainWindow)
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
|
|
|
// NOTE: not added to toolbar, but used for instance context menu (right click)
|
|
|
|
actionChangeInstIcon = TranslatedAction(MainWindow);
|
|
|
|
actionChangeInstIcon->setObjectName(QStringLiteral("actionChangeInstIcon"));
|
2021-10-16 04:12:01 +05:30
|
|
|
actionChangeInstIcon->setIcon(QIcon(":/icons/instances/grass"));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionChangeInstIcon->setIconVisibleInMenu(true);
|
|
|
|
actionChangeInstIcon.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Change Icon"));
|
|
|
|
actionChangeInstIcon.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Change the selected instance's icon."));
|
|
|
|
all_actions.append(&actionChangeInstIcon);
|
|
|
|
|
|
|
|
changeIconButton = new LabeledToolButton(MainWindow);
|
|
|
|
changeIconButton->setObjectName(QStringLiteral("changeIconButton"));
|
2021-11-20 20:52:22 +05:30
|
|
|
changeIconButton->setIcon(APPLICATION->getThemedIcon("news"));
|
2018-07-15 18:21:05 +05:30
|
|
|
changeIconButton->setToolTip(actionChangeInstIcon->toolTip());
|
|
|
|
changeIconButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
|
|
|
|
|
|
|
|
// NOTE: not added to toolbar, but used for instance context menu (right click)
|
|
|
|
actionRenameInstance = TranslatedAction(MainWindow);
|
|
|
|
actionRenameInstance->setObjectName(QStringLiteral("actionRenameInstance"));
|
|
|
|
actionRenameInstance.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Rename"));
|
|
|
|
actionRenameInstance.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Rename the selected instance."));
|
2022-10-21 02:18:57 +05:30
|
|
|
actionRenameInstance->setIcon(APPLICATION->getThemedIcon("rename"));
|
2018-07-15 18:21:05 +05:30
|
|
|
all_actions.append(&actionRenameInstance);
|
|
|
|
|
|
|
|
// the rename label is inside the rename tool button
|
|
|
|
renameButton = new LabeledToolButton(MainWindow);
|
|
|
|
renameButton->setObjectName(QStringLiteral("renameButton"));
|
|
|
|
renameButton->setToolTip(actionRenameInstance->toolTip());
|
|
|
|
renameButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
|
|
|
|
|
|
|
|
actionLaunchInstance = TranslatedAction(MainWindow);
|
|
|
|
actionLaunchInstance->setObjectName(QStringLiteral("actionLaunchInstance"));
|
2022-04-17 22:14:24 +05:30
|
|
|
actionLaunchInstance.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&Launch"));
|
|
|
|
actionLaunchInstance.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Launch the selected instance."));
|
2022-10-23 20:04:49 +05:30
|
|
|
actionLaunchInstance->setIcon(APPLICATION->getThemedIcon("launch"));
|
2018-07-15 18:21:05 +05:30
|
|
|
all_actions.append(&actionLaunchInstance);
|
|
|
|
|
|
|
|
actionLaunchInstanceOffline = TranslatedAction(MainWindow);
|
|
|
|
actionLaunchInstanceOffline->setObjectName(QStringLiteral("actionLaunchInstanceOffline"));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionLaunchInstanceOffline.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Launch &Offline"));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionLaunchInstanceOffline.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Launch the selected instance in offline mode."));
|
|
|
|
all_actions.append(&actionLaunchInstanceOffline);
|
|
|
|
|
2022-07-12 00:16:11 +05:30
|
|
|
actionLaunchInstanceDemo = TranslatedAction(MainWindow);
|
|
|
|
actionLaunchInstanceDemo->setObjectName(QStringLiteral("actionLaunchInstanceDemo"));
|
|
|
|
actionLaunchInstanceDemo.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Launch &Demo"));
|
|
|
|
actionLaunchInstanceDemo.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Launch the selected instance in demo mode."));
|
|
|
|
all_actions.append(&actionLaunchInstanceDemo);
|
|
|
|
|
2022-06-20 00:03:34 +05:30
|
|
|
actionKillInstance = TranslatedAction(MainWindow);
|
|
|
|
actionKillInstance->setObjectName(QStringLiteral("actionKillInstance"));
|
|
|
|
actionKillInstance->setDisabled(true);
|
|
|
|
actionKillInstance.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&Kill"));
|
|
|
|
actionKillInstance.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Kill the running instance"));
|
|
|
|
actionKillInstance->setShortcut(QKeySequence(tr("Ctrl+K")));
|
2022-10-21 02:18:57 +05:30
|
|
|
actionKillInstance->setIcon(APPLICATION->getThemedIcon("status-bad"));
|
2022-06-20 00:03:34 +05:30
|
|
|
all_actions.append(&actionKillInstance);
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
actionEditInstance = TranslatedAction(MainWindow);
|
|
|
|
actionEditInstance->setObjectName(QStringLiteral("actionEditInstance"));
|
2022-10-12 17:47:34 +05:30
|
|
|
actionEditInstance.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&Edit..."));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionEditInstance.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Change the instance settings, mods and versions."));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionEditInstance->setShortcut(QKeySequence(tr("Ctrl+I")));
|
2022-10-21 02:18:57 +05:30
|
|
|
actionEditInstance->setIcon(APPLICATION->getThemedIcon("settings-configure"));
|
2018-07-15 18:21:05 +05:30
|
|
|
all_actions.append(&actionEditInstance);
|
|
|
|
|
|
|
|
actionChangeInstGroup = TranslatedAction(MainWindow);
|
|
|
|
actionChangeInstGroup->setObjectName(QStringLiteral("actionChangeInstGroup"));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionChangeInstGroup.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&Change Group..."));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionChangeInstGroup.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Change the selected instance's group."));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionChangeInstGroup->setShortcut(QKeySequence(tr("Ctrl+G")));
|
2022-10-21 02:18:57 +05:30
|
|
|
actionChangeInstGroup->setIcon(APPLICATION->getThemedIcon("tag"));
|
2018-07-15 18:21:05 +05:30
|
|
|
all_actions.append(&actionChangeInstGroup);
|
|
|
|
|
2018-07-28 03:27:09 +05:30
|
|
|
actionViewSelectedInstFolder = TranslatedAction(MainWindow);
|
|
|
|
actionViewSelectedInstFolder->setObjectName(QStringLiteral("actionViewSelectedInstFolder"));
|
2022-10-12 17:47:34 +05:30
|
|
|
actionViewSelectedInstFolder.setTextId(QT_TRANSLATE_NOOP("MainWindow", "&Folder"));
|
2018-07-28 03:27:09 +05:30
|
|
|
actionViewSelectedInstFolder.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Open the selected instance's root folder in a file browser."));
|
2022-10-21 02:18:57 +05:30
|
|
|
actionViewSelectedInstFolder->setIcon(APPLICATION->getThemedIcon("viewfolder"));
|
2018-07-28 03:27:09 +05:30
|
|
|
all_actions.append(&actionViewSelectedInstFolder);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
actionExportInstance = TranslatedAction(MainWindow);
|
|
|
|
actionExportInstance->setObjectName(QStringLiteral("actionExportInstance"));
|
2022-10-12 17:47:34 +05:30
|
|
|
actionExportInstance.setTextId(QT_TRANSLATE_NOOP("MainWindow", "E&xport..."));
|
2022-02-03 22:39:12 +05:30
|
|
|
actionExportInstance.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Export the selected instance as a zip file."));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionExportInstance->setShortcut(QKeySequence(tr("Ctrl+E")));
|
2022-10-21 02:18:57 +05:30
|
|
|
actionExportInstance->setIcon(APPLICATION->getThemedIcon("export"));
|
2018-07-15 18:21:05 +05:30
|
|
|
all_actions.append(&actionExportInstance);
|
|
|
|
|
|
|
|
actionDeleteInstance = TranslatedAction(MainWindow);
|
|
|
|
actionDeleteInstance->setObjectName(QStringLiteral("actionDeleteInstance"));
|
2022-10-12 17:47:34 +05:30
|
|
|
actionDeleteInstance.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Dele&te"));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionDeleteInstance.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Delete the selected instance."));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionDeleteInstance->setShortcuts({QKeySequence(tr("Backspace")), QKeySequence::Delete});
|
2022-07-30 23:12:33 +05:30
|
|
|
actionDeleteInstance->setAutoRepeat(false);
|
2022-10-21 02:18:57 +05:30
|
|
|
actionDeleteInstance->setIcon(APPLICATION->getThemedIcon("delete"));
|
2018-07-15 18:21:05 +05:30
|
|
|
all_actions.append(&actionDeleteInstance);
|
|
|
|
|
|
|
|
actionCopyInstance = TranslatedAction(MainWindow);
|
|
|
|
actionCopyInstance->setObjectName(QStringLiteral("actionCopyInstance"));
|
2022-10-12 17:47:34 +05:30
|
|
|
actionCopyInstance.setTextId(QT_TRANSLATE_NOOP("MainWindow", "Cop&y..."));
|
2018-07-15 18:21:05 +05:30
|
|
|
actionCopyInstance.setTooltipId(QT_TRANSLATE_NOOP("MainWindow", "Copy the selected instance."));
|
2022-04-16 13:02:08 +05:30
|
|
|
actionCopyInstance->setShortcut(QKeySequence(tr("Ctrl+D")));
|
2022-10-21 02:18:57 +05:30
|
|
|
actionCopyInstance->setIcon(APPLICATION->getThemedIcon("copy"));
|
2018-07-15 18:21:05 +05:30
|
|
|
all_actions.append(&actionCopyInstance);
|
2022-04-16 13:02:08 +05:30
|
|
|
|
2022-04-17 22:14:24 +05:30
|
|
|
setInstanceActionsEnabled(false);
|
2022-04-16 13:02:08 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void createInstanceToolbar(QMainWindow *MainWindow)
|
|
|
|
{
|
|
|
|
instanceToolBar = TranslatedToolbar(MainWindow);
|
|
|
|
instanceToolBar->setObjectName(QStringLiteral("instanceToolBar"));
|
|
|
|
// disabled until we have an instance selected
|
|
|
|
instanceToolBar->setEnabled(false);
|
2022-05-08 05:12:19 +05:30
|
|
|
// Qt doesn't like vertical moving toolbars, so we have to force them...
|
|
|
|
// See https://github.com/PolyMC/PolyMC/issues/493
|
|
|
|
connect(instanceToolBar, &QToolBar::orientationChanged, [=](Qt::Orientation){ instanceToolBar->setOrientation(Qt::Vertical); });
|
2022-04-16 13:02:08 +05:30
|
|
|
instanceToolBar->setAllowedAreas(Qt::LeftToolBarArea | Qt::RightToolBarArea);
|
2022-10-23 20:04:49 +05:30
|
|
|
instanceToolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
|
|
|
|
instanceToolBar->setIconSize(QSize(16, 16));
|
|
|
|
|
2022-04-16 13:02:08 +05:30
|
|
|
instanceToolBar->setFloatable(false);
|
|
|
|
instanceToolBar->setWindowTitle(QT_TRANSLATE_NOOP("MainWindow", "Instance Toolbar"));
|
|
|
|
|
|
|
|
instanceToolBar->addWidget(changeIconButton);
|
|
|
|
instanceToolBar->addWidget(renameButton);
|
|
|
|
|
|
|
|
instanceToolBar->addSeparator();
|
|
|
|
|
|
|
|
instanceToolBar->addAction(actionLaunchInstance);
|
2022-06-20 00:03:34 +05:30
|
|
|
instanceToolBar->addAction(actionKillInstance);
|
2022-04-16 13:02:08 +05:30
|
|
|
|
|
|
|
instanceToolBar->addSeparator();
|
|
|
|
|
|
|
|
instanceToolBar->addAction(actionEditInstance);
|
|
|
|
instanceToolBar->addAction(actionChangeInstGroup);
|
|
|
|
|
|
|
|
instanceToolBar->addAction(actionViewSelectedInstFolder);
|
|
|
|
|
|
|
|
instanceToolBar->addAction(actionExportInstance);
|
2018-07-15 18:21:05 +05:30
|
|
|
instanceToolBar->addAction(actionCopyInstance);
|
2022-10-23 20:04:49 +05:30
|
|
|
instanceToolBar->addAction(actionDeleteInstance);
|
|
|
|
|
|
|
|
QLayout * lay = instanceToolBar->layout();
|
|
|
|
for(int i = 0; i < lay->count(); i++)
|
|
|
|
{
|
|
|
|
QLayoutItem * item = lay->itemAt(i);
|
|
|
|
if (item->widget()->metaObject()->className() == QString("QToolButton"))
|
|
|
|
{
|
|
|
|
item->setAlignment(Qt::AlignLeft);
|
|
|
|
}
|
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
all_toolbars.append(&instanceToolBar);
|
|
|
|
MainWindow->addToolBar(Qt::RightToolBarArea, instanceToolBar);
|
|
|
|
}
|
|
|
|
|
2022-04-17 22:14:24 +05:30
|
|
|
void setupUi(MainWindow *MainWindow)
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
|
|
|
if (MainWindow->objectName().isEmpty())
|
|
|
|
{
|
|
|
|
MainWindow->setObjectName(QStringLiteral("MainWindow"));
|
|
|
|
}
|
2019-09-15 07:45:51 +05:30
|
|
|
MainWindow->resize(800, 600);
|
2021-11-20 20:52:22 +05:30
|
|
|
MainWindow->setWindowIcon(APPLICATION->getThemedIcon("logo"));
|
2022-06-18 17:30:54 +05:30
|
|
|
MainWindow->setWindowTitle(APPLICATION->applicationDisplayName());
|
2020-05-30 19:02:38 +05:30
|
|
|
#ifndef QT_NO_ACCESSIBILITY
|
2022-10-18 13:20:27 +05:30
|
|
|
MainWindow->setAccessibleName(BuildConfig.LAUNCHER_DISPLAYNAME);
|
2020-05-30 19:02:38 +05:30
|
|
|
#endif
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2022-04-16 13:02:08 +05:30
|
|
|
createMainToolbarActions(MainWindow);
|
2022-04-17 22:14:24 +05:30
|
|
|
createMenuActions(MainWindow);
|
2022-04-16 13:02:08 +05:30
|
|
|
createInstanceActions(MainWindow);
|
|
|
|
|
2022-04-16 23:05:13 +05:30
|
|
|
createMenuBar(MainWindow);
|
2022-04-09 01:07:18 +05:30
|
|
|
|
2022-04-16 03:55:37 +05:30
|
|
|
createMainToolbar(MainWindow);
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
centralWidget = new QWidget(MainWindow);
|
|
|
|
centralWidget->setObjectName(QStringLiteral("centralWidget"));
|
|
|
|
horizontalLayout = new QHBoxLayout(centralWidget);
|
|
|
|
horizontalLayout->setSpacing(0);
|
|
|
|
horizontalLayout->setObjectName(QStringLiteral("horizontalLayout"));
|
|
|
|
horizontalLayout->setSizeConstraint(QLayout::SetDefaultConstraint);
|
|
|
|
horizontalLayout->setContentsMargins(0, 0, 0, 0);
|
|
|
|
MainWindow->setCentralWidget(centralWidget);
|
|
|
|
|
|
|
|
createStatusBar(MainWindow);
|
2022-02-10 17:25:07 +05:30
|
|
|
createNewsToolbar(MainWindow);
|
2018-07-15 18:21:05 +05:30
|
|
|
createInstanceToolbar(MainWindow);
|
|
|
|
|
2022-04-17 22:14:24 +05:30
|
|
|
MainWindow->updateToolsMenu();
|
2022-11-15 01:03:25 +05:30
|
|
|
MainWindow->updateThemeMenu();
|
2022-04-17 22:14:24 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
retranslateUi(MainWindow);
|
|
|
|
|
|
|
|
QMetaObject::connectSlotsByName(MainWindow);
|
|
|
|
} // setupUi
|
|
|
|
|
2022-05-09 09:12:37 +05:30
|
|
|
void retranslateUi(MainWindow *MainWindow)
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
|
|
|
// all the actions
|
|
|
|
for(auto * item: all_actions)
|
|
|
|
{
|
|
|
|
item->retranslate();
|
|
|
|
}
|
|
|
|
for(auto * item: all_toolbars)
|
|
|
|
{
|
|
|
|
item->retranslate();
|
|
|
|
}
|
|
|
|
for(auto * item: all_toolbuttons)
|
|
|
|
{
|
|
|
|
item->retranslate();
|
|
|
|
}
|
|
|
|
// submenu buttons
|
|
|
|
foldersMenuButton->setText(tr("Folders"));
|
|
|
|
helpMenuButton->setText(tr("Help"));
|
2022-05-09 09:12:37 +05:30
|
|
|
|
|
|
|
// playtime counter
|
|
|
|
if (MainWindow->m_statusCenter)
|
|
|
|
{
|
|
|
|
MainWindow->updateStatusCenter();
|
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
} // retranslateUi
|
2015-03-02 02:50:57 +05:30
|
|
|
};
|
|
|
|
|
2015-10-20 20:48:53 +05:30
|
|
|
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new MainWindow::Ui)
|
2013-01-09 23:52:22 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
ui->setupUi(this);
|
|
|
|
|
|
|
|
// OSX magic.
|
|
|
|
setUnifiedTitleAndToolBarOnMac(true);
|
|
|
|
|
|
|
|
// Global shortcuts
|
|
|
|
{
|
|
|
|
// FIXME: This is kinda weird. and bad. We need some kind of managed shutdown.
|
|
|
|
auto q = new QShortcut(QKeySequence::Quit, this);
|
|
|
|
connect(q, SIGNAL(activated()), qApp, SLOT(quit()));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Konami Code
|
|
|
|
{
|
|
|
|
secretEventFilter = new KonamiCode(this);
|
|
|
|
connect(secretEventFilter, &KonamiCode::triggered, this, &MainWindow::konamiTriggered);
|
|
|
|
}
|
|
|
|
|
2022-02-10 17:25:07 +05:30
|
|
|
// 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 18:21:05 +05:30
|
|
|
// Create the instance list widget
|
|
|
|
{
|
2021-10-26 03:21:42 +05:30
|
|
|
view = new InstanceView(ui->centralWidget);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
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);
|
2021-10-26 03:21:42 +05:30
|
|
|
connect(view, &InstanceView::droppedURLs, this, &MainWindow::droppedURLs, Qt::QueuedConnection);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
proxymodel = new InstanceProxyModel(this);
|
2021-11-20 20:52:22 +05:30
|
|
|
proxymodel->setSourceModel(APPLICATION->instances().get());
|
2018-07-15 18:21:05 +05:30
|
|
|
proxymodel->sort(0);
|
|
|
|
connect(proxymodel, &InstanceProxyModel::dataChanged, this, &MainWindow::instanceDataChanged);
|
|
|
|
|
|
|
|
view->setModel(proxymodel);
|
2019-08-20 06:28:27 +05:30
|
|
|
view->setSourceOfGroupCollapseStatus([](const QString & groupName)->bool {
|
2021-11-20 20:52:22 +05:30
|
|
|
return APPLICATION->instances()->isGroupCollapsed(groupName);
|
2019-08-20 06:28:27 +05:30
|
|
|
});
|
2021-11-20 20:52:22 +05:30
|
|
|
connect(view, &InstanceView::groupStateChanged, APPLICATION->instances().get(), &InstanceList::on_GroupStateChanged);
|
2018-07-15 18:21:05 +05:30
|
|
|
ui->horizontalLayout->addWidget(view);
|
|
|
|
}
|
|
|
|
// The cat background
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
bool cat_enable = APPLICATION->settings()->get("TheCat").toBool();
|
2018-07-15 18:21:05 +05:30
|
|
|
ui->actionCAT->setChecked(cat_enable);
|
2018-11-02 04:00:13 +05:30
|
|
|
// NOTE: calling the operator like that is an ugly hack to appease ancient gcc...
|
|
|
|
connect(ui->actionCAT.operator->(), SIGNAL(toggled(bool)), SLOT(onCatToggled(bool)));
|
2018-07-15 18:21:05 +05:30
|
|
|
setCatBackground(cat_enable);
|
|
|
|
}
|
2022-10-26 03:52:11 +05:30
|
|
|
|
|
|
|
// Lock toolbars
|
|
|
|
{
|
|
|
|
bool toolbarsLocked = APPLICATION->settings()->get("ToolbarsLocked").toBool();
|
|
|
|
ui->actionLockToolbars->setChecked(toolbarsLocked);
|
2022-11-06 02:40:36 +05:30
|
|
|
connect(ui->actionLockToolbars, &QAction::toggled, this, &MainWindow::lockToolbars);
|
2022-10-26 03:52:11 +05:30
|
|
|
lockToolbars(toolbarsLocked);
|
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
// start instance when double-clicked
|
2021-10-26 03:21:42 +05:30
|
|
|
connect(view, &InstanceView::activated, this, &MainWindow::instanceActivated);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
// 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 20:52:22 +05:30
|
|
|
connect(APPLICATION->icons().get(), &IconList::iconUpdated, this, &MainWindow::iconUpdated);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
// model reset -> selection is invalid. All the instance pointers are wrong.
|
2021-11-20 20:52:22 +05:30
|
|
|
connect(APPLICATION->instances().get(), &InstanceList::dataIsInvalid, this, &MainWindow::selectionBad);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2019-06-17 19:43:52 +05:30
|
|
|
// handle newly added instances
|
2021-11-20 20:52:22 +05:30
|
|
|
connect(APPLICATION->instances().get(), &InstanceList::instanceSelectRequest, this, &MainWindow::instanceSelectRequest);
|
2019-06-17 19:43:52 +05:30
|
|
|
|
2019-06-01 15:58:53 +05:30
|
|
|
// When the global settings page closes, we want to know about it and update our state
|
2021-11-20 20:52:22 +05:30
|
|
|
connect(APPLICATION, &Application::globalSettingsClosed, this, &MainWindow::globalSettingsClosed);
|
2019-06-01 15:58:53 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
m_statusLeft = new QLabel(tr("No instance selected"), this);
|
2021-10-02 03:50:25 +05:30
|
|
|
m_statusCenter = new QLabel(tr("Total playtime: 0s"), this);
|
2018-07-15 18:21:05 +05:30
|
|
|
statusBar()->addPermanentWidget(m_statusLeft, 1);
|
2021-10-10 04:55:31 +05:30
|
|
|
statusBar()->addPermanentWidget(m_statusCenter, 0);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
// Add "manage accounts" button, right align
|
|
|
|
QWidget *spacer = new QWidget();
|
|
|
|
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
|
|
|
|
ui->mainToolBar->addWidget(spacer);
|
|
|
|
|
|
|
|
accountMenu = new QMenu(this);
|
2022-05-09 12:50:53 +05:30
|
|
|
// Use undocumented property... https://stackoverflow.com/questions/7121718/create-a-scrollbar-in-a-submenu-qt
|
|
|
|
accountMenu->setStyleSheet("QMenu { menu-scrollable: 1; }");
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
repopulateAccountsMenu();
|
|
|
|
|
|
|
|
accountMenuButton = new QToolButton(this);
|
|
|
|
accountMenuButton->setMenu(accountMenu);
|
|
|
|
accountMenuButton->setPopupMode(QToolButton::InstantPopup);
|
|
|
|
accountMenuButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
|
2021-11-20 20:52:22 +05:30
|
|
|
accountMenuButton->setIcon(APPLICATION->getThemedIcon("noaccount"));
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
QWidgetAction *accountMenuButtonAction = new QWidgetAction(this);
|
|
|
|
accountMenuButtonAction->setDefaultWidget(accountMenuButton);
|
|
|
|
|
|
|
|
ui->mainToolBar->addAction(accountMenuButtonAction);
|
|
|
|
|
|
|
|
// 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...
|
2021-07-27 01:14:11 +05:30
|
|
|
connect(
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->accounts().get(),
|
|
|
|
&AccountList::defaultAccountChanged,
|
2021-07-27 01:14:11 +05:30
|
|
|
[this] {
|
2021-11-20 20:52:22 +05:30
|
|
|
defaultAccountChanged();
|
2021-07-27 01:14:11 +05:30
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->accounts().get(),
|
2021-07-27 01:14:11 +05:30
|
|
|
&AccountList::listChanged,
|
|
|
|
[this]
|
|
|
|
{
|
|
|
|
repopulateAccountsMenu();
|
|
|
|
}
|
|
|
|
);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
// Show initial account
|
2021-11-20 20:52:22 +05:30
|
|
|
defaultAccountChanged();
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2021-07-27 01:14:11 +05:30
|
|
|
// TODO: refresh accounts here?
|
2021-11-20 20:52:22 +05:30
|
|
|
// auto accounts = APPLICATION->accounts();
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2022-02-10 17:25:07 +05:30
|
|
|
// load the news
|
|
|
|
{
|
|
|
|
m_newsChecker->reloadNews();
|
|
|
|
updateNewsLabel();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
if(BuildConfig.UPDATER_ENABLED)
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
bool updatesAllowed = APPLICATION->updatesAreAllowed();
|
2018-07-15 18:21:05 +05:30
|
|
|
updatesAllowedChanged(updatesAllowed);
|
|
|
|
|
2018-11-02 04:00:13 +05:30
|
|
|
// NOTE: calling the operator like that is an ugly hack to appease ancient gcc...
|
|
|
|
connect(ui->actionCheckUpdate.operator->(), &QAction::triggered, this, &MainWindow::checkForUpdates);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
// set up the updater object.
|
2021-11-20 20:52:22 +05:30
|
|
|
auto updater = APPLICATION->updateChecker();
|
2018-07-15 18:21:05 +05:30
|
|
|
connect(updater.get(), &UpdateChecker::updateAvailable, this, &MainWindow::updateAvailable);
|
|
|
|
connect(updater.get(), &UpdateChecker::noUpdateFound, this, &MainWindow::updateNotAvailable);
|
|
|
|
// if automatic update checks are allowed, start one.
|
2021-11-20 20:52:22 +05:30
|
|
|
if (APPLICATION->settings()->get("AutoUpdate").toBool() && updatesAllowed)
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
updater->checkForUpdate(APPLICATION->settings()->get("UpdateChannel").toString(), false);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2022-04-21 08:04:13 +05:30
|
|
|
|
2022-04-26 05:03:17 +05:30
|
|
|
if (APPLICATION->updateChecker()->getExternalUpdater())
|
|
|
|
{
|
|
|
|
connect(APPLICATION->updateChecker()->getExternalUpdater(),
|
|
|
|
&ExternalUpdater::canCheckForUpdatesChanged,
|
|
|
|
this,
|
|
|
|
&MainWindow::updatesAllowedChanged);
|
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
|
2022-10-30 23:38:02 +05:30
|
|
|
connect(ui->actionUndoTrashInstance.operator->(), &QAction::triggered, this, &MainWindow::undoTrashInstance);
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
setSelectedInstanceById(APPLICATION->settings()->get("SelectedInstance").toString());
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
// removing this looks stupid
|
|
|
|
view->setFocus();
|
2021-06-19 04:42:54 +05:30
|
|
|
|
|
|
|
retranslateUi();
|
|
|
|
}
|
|
|
|
|
2022-04-09 01:51:52 +05:30
|
|
|
// 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)
|
2022-04-09 02:30:42 +05:30
|
|
|
#ifndef Q_OS_MAC
|
2022-04-09 01:51:52 +05:30
|
|
|
void MainWindow::keyReleaseEvent(QKeyEvent *event)
|
|
|
|
{
|
2022-04-16 03:55:37 +05:30
|
|
|
if(event->key()==Qt::Key_Alt && !APPLICATION->settings()->get("MenuBarInsteadOfToolBar").toBool())
|
2022-04-09 01:51:52 +05:30
|
|
|
ui->menuBar->setVisible(!ui->menuBar->isVisible());
|
2022-04-09 02:30:42 +05:30
|
|
|
else
|
|
|
|
QMainWindow::keyReleaseEvent(event);
|
2022-04-09 01:51:52 +05:30
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2021-06-19 04:42:54 +05:30
|
|
|
void MainWindow::retranslateUi()
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
auto accounts = APPLICATION->accounts();
|
|
|
|
MinecraftAccountPtr defaultAccount = accounts->defaultAccount();
|
|
|
|
if(defaultAccount) {
|
|
|
|
auto profileLabel = profileInUseFilter(defaultAccount->profileName(), defaultAccount->isInUse());
|
2021-07-27 01:14:11 +05:30
|
|
|
accountMenuButton->setText(profileLabel);
|
|
|
|
}
|
|
|
|
else {
|
2022-10-31 03:25:15 +05:30
|
|
|
accountMenuButton->setText(tr("Accounts"));
|
2021-07-27 01:14:11 +05:30
|
|
|
}
|
2021-06-19 04:42:54 +05:30
|
|
|
|
|
|
|
if (m_selectedInstance) {
|
|
|
|
m_statusLeft->setText(m_selectedInstance->getStatusbarDescription());
|
|
|
|
} else {
|
|
|
|
m_statusLeft->setText(tr("No instance selected"));
|
|
|
|
}
|
|
|
|
|
|
|
|
ui->retranslateUi(this);
|
2013-01-09 23:52:22 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
MainWindow::~MainWindow()
|
|
|
|
{
|
2013-03-12 02:49:17 +05:30
|
|
|
}
|
|
|
|
|
2019-07-16 05:00:09 +05:30
|
|
|
QMenu * MainWindow::createPopupMenu()
|
|
|
|
{
|
|
|
|
QMenu* filteredMenu = QMainWindow::createPopupMenu();
|
|
|
|
filteredMenu->removeAction( ui->mainToolBar->toggleViewAction() );
|
2022-10-26 03:52:11 +05:30
|
|
|
|
|
|
|
filteredMenu->addAction(ui->actionLockToolbars);
|
|
|
|
|
2019-07-16 05:00:09 +05:30
|
|
|
return filteredMenu;
|
|
|
|
}
|
2022-10-26 03:52:11 +05:30
|
|
|
void MainWindow::lockToolbars(bool state)
|
|
|
|
{
|
|
|
|
ui->mainToolBar->setMovable(!state);
|
|
|
|
ui->instanceToolBar->setMovable(!state);
|
|
|
|
ui->newsToolBar->setMovable(!state);
|
|
|
|
APPLICATION->settings()->set("ToolbarsLocked", state);
|
|
|
|
}
|
|
|
|
|
2019-07-16 05:00:09 +05:30
|
|
|
|
2018-03-15 13:57:45 +05:30
|
|
|
void MainWindow::konamiTriggered()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
qDebug() << "Super Secret Mode ACTIVATED!";
|
2018-03-15 13:57:45 +05:30
|
|
|
}
|
|
|
|
|
2014-01-27 07:30:49 +05:30
|
|
|
void MainWindow::showInstanceContextMenu(const QPoint &pos)
|
2014-01-05 05:36:59 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
QList<QAction *> actions;
|
|
|
|
|
|
|
|
QAction *actionSep = new QAction("", this);
|
|
|
|
actionSep->setSeparator(true);
|
|
|
|
|
|
|
|
bool onInstance = view->indexAt(pos).isValid();
|
|
|
|
if (onInstance)
|
|
|
|
{
|
|
|
|
actions = ui->instanceToolBar->actions();
|
|
|
|
|
|
|
|
// replace the change icon widget with an actual action
|
|
|
|
actions.replace(0, ui->actionChangeInstIcon);
|
|
|
|
|
|
|
|
// replace the rename widget with an actual action
|
|
|
|
actions.replace(1, ui->actionRenameInstance);
|
|
|
|
|
|
|
|
// 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);
|
|
|
|
|
2022-10-18 13:20:27 +05:30
|
|
|
QAction *actionVoid = new QAction(BuildConfig.LAUNCHER_DISPLAYNAME, this);
|
2018-07-15 18:21:05 +05:30
|
|
|
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));
|
2014-01-05 05:36:59 +05:30
|
|
|
}
|
|
|
|
|
2022-04-16 03:55:37 +05:30
|
|
|
void MainWindow::updateMainToolBar()
|
|
|
|
{
|
|
|
|
ui->menuBar->setVisible(APPLICATION->settings()->get("MenuBarInsteadOfToolBar").toBool());
|
|
|
|
ui->mainToolBar->setVisible(ui->menuBar->isNativeMenuBar() || !APPLICATION->settings()->get("MenuBarInsteadOfToolBar").toBool());
|
|
|
|
}
|
|
|
|
|
2014-02-16 16:19:55 +05:30
|
|
|
void MainWindow::updateToolsMenu()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
QToolButton *launchButton = dynamic_cast<QToolButton*>(ui->instanceToolBar->widgetForAction(ui->actionLaunchInstance));
|
2019-04-15 04:12:06 +05:30
|
|
|
|
2022-06-20 00:03:34 +05:30
|
|
|
bool currentInstanceRunning = m_selectedInstance && m_selectedInstance->isRunning();
|
|
|
|
|
|
|
|
ui->actionLaunchInstance->setDisabled(!m_selectedInstance || currentInstanceRunning);
|
|
|
|
ui->actionLaunchInstanceOffline->setDisabled(!m_selectedInstance || currentInstanceRunning);
|
2022-07-12 00:16:11 +05:30
|
|
|
ui->actionLaunchInstanceDemo->setDisabled(!m_selectedInstance || currentInstanceRunning);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
QMenu *launchMenu = ui->actionLaunchInstance->menu();
|
|
|
|
launchButton->setPopupMode(QToolButton::MenuButtonPopup);
|
|
|
|
if (launchMenu)
|
|
|
|
{
|
|
|
|
launchMenu->clear();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
launchMenu = new QMenu(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
QAction *normalLaunch = launchMenu->addAction(tr("Launch"));
|
2022-04-16 13:02:08 +05:30
|
|
|
normalLaunch->setShortcut(QKeySequence::Open);
|
2022-10-11 02:50:21 +05:30
|
|
|
QAction *normalLaunchOffline = launchMenu->addAction(tr("Launch Offline"));
|
2022-04-16 13:02:08 +05:30
|
|
|
normalLaunchOffline->setShortcut(QKeySequence(tr("Ctrl+Shift+O")));
|
2022-10-11 02:50:21 +05:30
|
|
|
QAction *normalLaunchDemo = launchMenu->addAction(tr("Launch Demo"));
|
2022-07-14 02:23:36 +05:30
|
|
|
normalLaunchDemo->setShortcut(QKeySequence(tr("Ctrl+Alt+O")));
|
2022-04-17 22:14:24 +05:30
|
|
|
if (m_selectedInstance)
|
|
|
|
{
|
2022-06-20 00:03:34 +05:30
|
|
|
normalLaunch->setEnabled(m_selectedInstance->canLaunch());
|
|
|
|
normalLaunchOffline->setEnabled(m_selectedInstance->canLaunch());
|
2022-07-12 00:16:11 +05:30
|
|
|
normalLaunchDemo->setEnabled(m_selectedInstance->canLaunch());
|
2022-06-20 00:03:34 +05:30
|
|
|
|
2022-04-17 22:14:24 +05:30
|
|
|
connect(normalLaunch, &QAction::triggered, [this]() {
|
2022-07-12 00:16:11 +05:30
|
|
|
APPLICATION->launch(m_selectedInstance, true, false);
|
2022-04-17 22:14:24 +05:30
|
|
|
});
|
|
|
|
connect(normalLaunchOffline, &QAction::triggered, [this]() {
|
2022-07-12 00:16:11 +05:30
|
|
|
APPLICATION->launch(m_selectedInstance, false, false);
|
|
|
|
});
|
|
|
|
connect(normalLaunchDemo, &QAction::triggered, [this]() {
|
|
|
|
APPLICATION->launch(m_selectedInstance, false, true);
|
2022-04-17 22:14:24 +05:30
|
|
|
});
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
normalLaunch->setDisabled(true);
|
|
|
|
normalLaunchOffline->setDisabled(true);
|
2022-07-12 00:16:11 +05:30
|
|
|
normalLaunchDemo->setDisabled(true);
|
2022-04-17 22:14:24 +05:30
|
|
|
}
|
2022-09-16 03:53:58 +05:30
|
|
|
|
|
|
|
// Disable demo-mode if not available.
|
|
|
|
auto instance = dynamic_cast<MinecraftInstance*>(m_selectedInstance.get());
|
|
|
|
if (instance) {
|
|
|
|
normalLaunchDemo->setEnabled(instance->supportsDemo());
|
|
|
|
}
|
|
|
|
|
2019-04-15 02:32:01 +05:30
|
|
|
QString profilersTitle = tr("Profilers");
|
|
|
|
launchMenu->addSeparator()->setText(profilersTitle);
|
2021-11-20 20:52:22 +05:30
|
|
|
for (auto profiler : APPLICATION->profilers().values())
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
|
|
|
QAction *profilerAction = launchMenu->addAction(profiler->name());
|
2022-10-11 18:28:34 +05:30
|
|
|
QAction *profilerOfflineAction = launchMenu->addAction(tr("%1 Offline").arg(profiler->name()));
|
2018-07-15 18:21:05 +05:30
|
|
|
QString error;
|
|
|
|
if (!profiler->check(&error))
|
|
|
|
{
|
|
|
|
profilerAction->setDisabled(true);
|
2019-04-15 04:12:06 +05:30
|
|
|
profilerOfflineAction->setDisabled(true);
|
2019-04-15 02:32:01 +05:30
|
|
|
QString profilerToolTip = tr("Profiler not setup correctly. Go into settings, \"External Tools\".");
|
|
|
|
profilerAction->setToolTip(profilerToolTip);
|
|
|
|
profilerOfflineAction->setToolTip(profilerToolTip);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2022-04-17 22:14:24 +05:30
|
|
|
else if (m_selectedInstance)
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
2022-06-20 00:03:34 +05:30
|
|
|
profilerAction->setEnabled(m_selectedInstance->canLaunch());
|
|
|
|
profilerOfflineAction->setEnabled(m_selectedInstance->canLaunch());
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
connect(profilerAction, &QAction::triggered, [this, profiler]()
|
|
|
|
{
|
2022-07-12 00:16:11 +05:30
|
|
|
APPLICATION->launch(m_selectedInstance, true, false, profiler.get());
|
2018-07-15 18:21:05 +05:30
|
|
|
});
|
2019-04-15 04:12:06 +05:30
|
|
|
connect(profilerOfflineAction, &QAction::triggered, [this, profiler]()
|
|
|
|
{
|
2022-07-12 00:16:11 +05:30
|
|
|
APPLICATION->launch(m_selectedInstance, false, false, profiler.get());
|
|
|
|
});
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2022-04-17 22:14:24 +05:30
|
|
|
else
|
|
|
|
{
|
|
|
|
profilerAction->setDisabled(true);
|
|
|
|
profilerOfflineAction->setDisabled(true);
|
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
ui->actionLaunchInstance->setMenu(launchMenu);
|
2014-02-16 16:19:55 +05:30
|
|
|
}
|
|
|
|
|
2022-11-15 01:03:25 +05:30
|
|
|
void MainWindow::updateThemeMenu()
|
|
|
|
{
|
|
|
|
QMenu *themeMenu = ui->actionChangeTheme->menu();
|
|
|
|
|
2022-11-15 14:08:31 +05:30
|
|
|
if (themeMenu) {
|
2022-11-15 01:03:25 +05:30
|
|
|
themeMenu->clear();
|
2022-11-15 14:08:31 +05:30
|
|
|
} else {
|
2022-11-15 01:03:25 +05:30
|
|
|
themeMenu = new QMenu(this);
|
|
|
|
}
|
|
|
|
|
2022-11-15 04:29:26 +05:30
|
|
|
auto themes = APPLICATION->getValidApplicationThemes();
|
|
|
|
|
2022-11-17 14:50:53 +05:30
|
|
|
QActionGroup* themesGroup = new QActionGroup( this );
|
2022-11-15 04:29:26 +05:30
|
|
|
|
2022-11-16 20:54:28 +05:30
|
|
|
for (auto* theme : themes) {
|
2022-11-15 04:29:26 +05:30
|
|
|
QAction * themeAction = themeMenu->addAction(theme->name());
|
|
|
|
|
|
|
|
themeAction->setCheckable(true);
|
2022-11-15 14:08:31 +05:30
|
|
|
if (APPLICATION->settings()->get("ApplicationTheme").toString() == theme->id()) {
|
|
|
|
themeAction->setChecked(true);
|
|
|
|
}
|
2022-11-17 15:09:05 +05:30
|
|
|
themeAction->setActionGroup(themesGroup);
|
2022-11-15 04:29:26 +05:30
|
|
|
|
|
|
|
connect(themeAction, &QAction::triggered, [theme]() {
|
2022-11-15 14:39:13 +05:30
|
|
|
APPLICATION->setApplicationTheme(theme->id(),false);
|
|
|
|
APPLICATION->settings()->set("ApplicationTheme", theme->id());
|
2022-11-15 04:29:26 +05:30
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2022-11-15 01:03:25 +05:30
|
|
|
ui->actionChangeTheme->setMenu(themeMenu);
|
|
|
|
}
|
|
|
|
|
2013-11-28 04:09:49 +05:30
|
|
|
void MainWindow::repopulateAccountsMenu()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
accountMenu->clear();
|
2022-04-16 05:25:49 +05:30
|
|
|
ui->profileMenu->clear();
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
auto accounts = APPLICATION->accounts();
|
|
|
|
MinecraftAccountPtr defaultAccount = accounts->defaultAccount();
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2021-07-27 01:14:11 +05:30
|
|
|
QString active_profileId = "";
|
2021-11-20 20:52:22 +05:30
|
|
|
if (defaultAccount)
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
|
|
|
// this can be called before accountMenuButton exists
|
2021-07-27 01:14:11 +05:30
|
|
|
if (accountMenuButton)
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
auto profileLabel = profileInUseFilter(defaultAccount->profileName(), defaultAccount->isInUse());
|
2018-07-15 18:21:05 +05:30
|
|
|
accountMenuButton->setText(profileLabel);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (accounts->count() <= 0)
|
|
|
|
{
|
2022-05-09 08:49:23 +05:30
|
|
|
ui->all_actions.removeAll(&ui->actionNoAccountsAdded);
|
|
|
|
ui->actionNoAccountsAdded = TranslatedAction(this);
|
|
|
|
ui->actionNoAccountsAdded->setObjectName(QStringLiteral("actionNoAccountsAdded"));
|
|
|
|
ui->actionNoAccountsAdded.setTextId(QT_TRANSLATE_NOOP("MainWindow", "No accounts added!"));
|
|
|
|
ui->actionNoAccountsAdded->setEnabled(false);
|
|
|
|
accountMenu->addAction(ui->actionNoAccountsAdded);
|
|
|
|
ui->profileMenu->addAction(ui->actionNoAccountsAdded);
|
|
|
|
ui->all_actions.append(&ui->actionNoAccountsAdded);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// TODO: Nicer way to iterate?
|
|
|
|
for (int i = 0; i < accounts->count(); i++)
|
|
|
|
{
|
2021-07-27 01:14:11 +05:30
|
|
|
MinecraftAccountPtr account = accounts->at(i);
|
|
|
|
auto profileLabel = profileInUseFilter(account->profileName(), account->isInUse());
|
|
|
|
QAction *action = new QAction(profileLabel, this);
|
2021-11-10 07:32:51 +05:30
|
|
|
action->setData(i);
|
2021-07-27 01:14:11 +05:30
|
|
|
action->setCheckable(true);
|
2021-11-20 20:52:22 +05:30
|
|
|
if (defaultAccount == account)
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
2021-07-27 01:14:11 +05:30
|
|
|
action->setChecked(true);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2021-07-27 01:14:11 +05:30
|
|
|
|
2021-11-10 07:32:51 +05:30
|
|
|
auto face = account->getFace();
|
|
|
|
if(!face.isNull()) {
|
|
|
|
action->setIcon(face);
|
|
|
|
}
|
|
|
|
else {
|
2021-11-20 20:52:22 +05:30
|
|
|
action->setIcon(APPLICATION->getThemedIcon("noaccount"));
|
2021-11-10 07:32:51 +05:30
|
|
|
}
|
2022-04-16 05:25:49 +05:30
|
|
|
|
|
|
|
const int highestNumberKey = 9;
|
|
|
|
if(i<highestNumberKey)
|
|
|
|
{
|
|
|
|
action->setShortcut(QKeySequence(tr("Ctrl+%1").arg(i + 1)));
|
|
|
|
}
|
|
|
|
|
2021-07-27 01:14:11 +05:30
|
|
|
accountMenu->addAction(action);
|
2022-04-16 05:25:49 +05:30
|
|
|
ui->profileMenu->addAction(action);
|
2021-07-27 01:14:11 +05:30
|
|
|
connect(action, SIGNAL(triggered(bool)), SLOT(changeActiveAccount()));
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
accountMenu->addSeparator();
|
2022-04-16 05:25:49 +05:30
|
|
|
ui->profileMenu->addSeparator();
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2022-05-09 08:49:23 +05:30
|
|
|
ui->all_actions.removeAll(&ui->actionNoDefaultAccount);
|
|
|
|
ui->actionNoDefaultAccount = TranslatedAction(this);
|
|
|
|
ui->actionNoDefaultAccount->setObjectName(QStringLiteral("actionNoDefaultAccount"));
|
|
|
|
ui->actionNoDefaultAccount.setTextId(QT_TRANSLATE_NOOP("MainWindow", "No Default Account"));
|
|
|
|
ui->actionNoDefaultAccount->setCheckable(true);
|
|
|
|
ui->actionNoDefaultAccount->setIcon(APPLICATION->getThemedIcon("noaccount"));
|
|
|
|
ui->actionNoDefaultAccount->setData(-1);
|
|
|
|
ui->actionNoDefaultAccount->setShortcut(QKeySequence(tr("Ctrl+0")));
|
2021-11-20 20:52:22 +05:30
|
|
|
if (!defaultAccount) {
|
2022-05-09 08:49:23 +05:30
|
|
|
ui->actionNoDefaultAccount->setChecked(true);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
|
2022-05-09 08:49:23 +05:30
|
|
|
accountMenu->addAction(ui->actionNoDefaultAccount);
|
|
|
|
ui->profileMenu->addAction(ui->actionNoDefaultAccount);
|
|
|
|
connect(ui->actionNoDefaultAccount, SIGNAL(triggered(bool)), SLOT(changeActiveAccount()));
|
|
|
|
ui->all_actions.append(&ui->actionNoDefaultAccount);
|
|
|
|
ui->actionNoDefaultAccount.retranslate();
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
accountMenu->addSeparator();
|
2022-04-16 05:25:49 +05:30
|
|
|
ui->profileMenu->addSeparator();
|
2018-07-15 18:21:05 +05:30
|
|
|
accountMenu->addAction(ui->actionManageAccounts);
|
2022-04-16 13:02:08 +05:30
|
|
|
ui->profileMenu->addAction(ui->actionManageAccounts);
|
2013-11-28 04:09:49 +05:30
|
|
|
}
|
|
|
|
|
2017-05-02 05:13:18 +05:30
|
|
|
void MainWindow::updatesAllowedChanged(bool allowed)
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if(!BuildConfig.UPDATER_ENABLED)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ui->actionCheckUpdate->setEnabled(allowed);
|
2017-05-02 05:13:18 +05:30
|
|
|
}
|
|
|
|
|
2013-11-28 04:09:49 +05:30
|
|
|
/*
|
|
|
|
* Assumes the sender is a QAction
|
|
|
|
*/
|
|
|
|
void MainWindow::changeActiveAccount()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
QAction *sAction = (QAction *)sender();
|
2021-11-10 07:32:51 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
// Profile's associated Mojang username
|
2021-11-10 07:32:51 +05:30
|
|
|
if (sAction->data().type() != QVariant::Type::Int)
|
2018-07-15 18:21:05 +05:30
|
|
|
return;
|
2013-11-28 04:09:49 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
QVariant data = sAction->data();
|
2021-11-10 07:32:51 +05:30
|
|
|
bool valid = false;
|
|
|
|
int index = data.toInt(&valid);
|
|
|
|
if(!valid) {
|
|
|
|
index = -1;
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2021-11-20 20:52:22 +05:30
|
|
|
auto accounts = APPLICATION->accounts();
|
|
|
|
accounts->setDefaultAccount(index == -1 ? nullptr : accounts->at(index));
|
|
|
|
defaultAccountChanged();
|
2013-11-28 04:09:49 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void MainWindow::defaultAccountChanged()
|
2013-11-27 22:26:15 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
repopulateAccountsMenu();
|
2013-11-28 04:09:49 +05:30
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
MinecraftAccountPtr account = APPLICATION->accounts()->defaultAccount();
|
2013-11-27 22:26:15 +05:30
|
|
|
|
2021-07-27 01:14:11 +05:30
|
|
|
// FIXME: this needs adjustment for MSA
|
2021-11-20 20:52:22 +05:30
|
|
|
if (account && account->profileName() != "")
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
2021-07-27 01:14:11 +05:30
|
|
|
auto profileLabel = profileInUseFilter(account->profileName(), account->isInUse());
|
|
|
|
accountMenuButton->setText(profileLabel);
|
2021-11-10 07:32:51 +05:30
|
|
|
auto face = account->getFace();
|
|
|
|
if(face.isNull()) {
|
2021-11-20 20:52:22 +05:30
|
|
|
accountMenuButton->setIcon(APPLICATION->getThemedIcon("noaccount"));
|
2021-11-10 07:32:51 +05:30
|
|
|
}
|
|
|
|
else {
|
|
|
|
accountMenuButton->setIcon(face);
|
|
|
|
}
|
2021-07-27 01:14:11 +05:30
|
|
|
return;
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2013-11-28 04:09:49 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
// Set the icon to the "no account" icon.
|
2021-11-20 20:52:22 +05:30
|
|
|
accountMenuButton->setIcon(APPLICATION->getThemedIcon("noaccount"));
|
2022-10-31 03:25:15 +05:30
|
|
|
accountMenuButton->setText(tr("Accounts"));
|
2013-11-27 22:26:15 +05:30
|
|
|
}
|
|
|
|
|
2013-10-06 04:43:40 +05:30
|
|
|
bool MainWindow::eventFilter(QObject *obj, QEvent *ev)
|
2013-08-12 04:09:19 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (obj == view)
|
|
|
|
{
|
|
|
|
if (ev->type() == QEvent::KeyPress)
|
|
|
|
{
|
|
|
|
secretEventFilter->input(ev);
|
|
|
|
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
|
|
|
|
switch (keyEvent->key())
|
|
|
|
{
|
2018-11-22 06:20:32 +05:30
|
|
|
/*
|
2018-07-15 18:21:05 +05:30
|
|
|
case Qt::Key_Enter:
|
|
|
|
case Qt::Key_Return:
|
|
|
|
activateInstance(m_selectedInstance);
|
|
|
|
return true;
|
2018-11-22 06:20:32 +05:30
|
|
|
*/
|
2018-07-15 18:21:05 +05:30
|
|
|
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);
|
2013-08-12 04:09:19 +05:30
|
|
|
}
|
|
|
|
|
2022-02-10 17:25:07 +05:30
|
|
|
void MainWindow::updateNewsLabel()
|
|
|
|
{
|
|
|
|
if (m_newsChecker->isLoadingNews())
|
|
|
|
{
|
|
|
|
newsLabel->setText(tr("Loading news..."));
|
|
|
|
newsLabel->setEnabled(false);
|
2022-08-13 02:03:10 +05:30
|
|
|
ui->actionMoreNews->setVisible(false);
|
2022-02-10 17:25:07 +05:30
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
QList<NewsEntryPtr> entries = m_newsChecker->getNewsEntries();
|
|
|
|
if (entries.length() > 0)
|
|
|
|
{
|
|
|
|
newsLabel->setText(entries[0]->title);
|
|
|
|
newsLabel->setEnabled(true);
|
2022-08-13 02:03:10 +05:30
|
|
|
ui->actionMoreNews->setVisible(true);
|
2022-02-10 17:25:07 +05:30
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
newsLabel->setText(tr("No news available."));
|
|
|
|
newsLabel->setEnabled(false);
|
2022-08-13 02:03:10 +05:30
|
|
|
ui->actionMoreNews->setVisible(false);
|
2022-02-10 17:25:07 +05:30
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-08 22:26:14 +05:30
|
|
|
void MainWindow::updateAvailable(GoUpdate::Status status)
|
2013-12-02 05:25:24 +05:30
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
if(!APPLICATION->updatesAreAllowed())
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
|
|
|
updateNotAvailable();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
UpdateDialog dlg(true, this);
|
|
|
|
UpdateAction action = (UpdateAction)dlg.exec();
|
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case UPDATE_LATER:
|
|
|
|
qDebug() << "Update will be installed later.";
|
|
|
|
break;
|
|
|
|
case UPDATE_NOW:
|
|
|
|
downloadUpdates(status);
|
|
|
|
break;
|
|
|
|
}
|
2013-12-02 05:25:24 +05:30
|
|
|
}
|
|
|
|
|
2014-07-14 04:27:54 +05:30
|
|
|
void MainWindow::updateNotAvailable()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
UpdateDialog dlg(false, this);
|
|
|
|
dlg.exec();
|
2014-07-14 04:27:54 +05:30
|
|
|
}
|
|
|
|
|
2014-01-03 23:49:27 +05:30
|
|
|
QList<int> stringToIntList(const QString &string)
|
|
|
|
{
|
2022-05-02 22:40:45 +05:30
|
|
|
#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
|
|
|
|
QStringList split = string.split(',', Qt::SkipEmptyParts);
|
|
|
|
#else
|
2018-07-15 18:21:05 +05:30
|
|
|
QStringList split = string.split(',', QString::SkipEmptyParts);
|
2022-05-02 22:40:45 +05:30
|
|
|
#endif
|
2018-07-15 18:21:05 +05:30
|
|
|
QList<int> out;
|
|
|
|
for (int i = 0; i < split.size(); ++i)
|
|
|
|
{
|
|
|
|
out.append(split.at(i).toInt());
|
|
|
|
}
|
|
|
|
return out;
|
2014-01-03 23:49:27 +05:30
|
|
|
}
|
|
|
|
QString intListToString(const QList<int> &list)
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
QStringList slist;
|
|
|
|
for (int i = 0; i < list.size(); ++i)
|
|
|
|
{
|
|
|
|
slist.append(QString::number(list.at(i)));
|
|
|
|
}
|
|
|
|
return slist.join(',');
|
2014-01-03 23:49:27 +05:30
|
|
|
}
|
|
|
|
|
2015-06-08 03:12:22 +05:30
|
|
|
void MainWindow::downloadUpdates(GoUpdate::Status status)
|
2013-12-07 00:29:58 +05:30
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
if(!APPLICATION->updatesAreAllowed())
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
qDebug() << "Downloading updates.";
|
|
|
|
ProgressDialog updateDlg(this);
|
2021-11-20 20:52:22 +05:30
|
|
|
status.rootPath = APPLICATION->root();
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
auto dlPath = FS::PathCombine(APPLICATION->root(), "update", "XXXXXX");
|
2018-07-15 18:21:05 +05:30
|
|
|
if (!FS::ensureFilePathExists(dlPath))
|
|
|
|
{
|
|
|
|
CustomMessageBox::selectable(this, tr("Error"), tr("Couldn't create folder for update downloads:\n%1").arg(dlPath), QMessageBox::Warning)->show();
|
|
|
|
}
|
2021-11-22 03:51:12 +05:30
|
|
|
GoUpdate::DownloadTask updateTask(APPLICATION->network(), status, dlPath, &updateDlg);
|
2018-07-15 18:21:05 +05:30
|
|
|
// If the task succeeds, install the updates.
|
|
|
|
if (updateDlg.execWithTask(&updateTask))
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* NOTE: This disables launching instances until the update either succeeds (and this process exits)
|
|
|
|
* or the update fails (and the control leaves this scope).
|
|
|
|
*/
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->updateIsRunning(true);
|
|
|
|
UpdateController update(this, APPLICATION->root(), updateTask.updateFilesDir(), updateTask.operations());
|
2018-07-15 18:21:05 +05:30
|
|
|
update.installUpdates();
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->updateIsRunning(false);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CustomMessageBox::selectable(this, tr("Error"), updateTask.failReason(), QMessageBox::Warning)->show();
|
|
|
|
}
|
2013-12-07 00:29:58 +05:30
|
|
|
}
|
|
|
|
|
2013-10-06 04:43:40 +05:30
|
|
|
void MainWindow::onCatToggled(bool state)
|
2013-08-26 02:18:41 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
setCatBackground(state);
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->settings()->set("TheCat", state);
|
2013-08-26 02:18:41 +05:30
|
|
|
}
|
|
|
|
|
2018-12-24 19:19:53 +05:30
|
|
|
namespace {
|
|
|
|
template <typename T>
|
|
|
|
T non_stupid_abs(T in)
|
|
|
|
{
|
|
|
|
if (in < 0)
|
|
|
|
return -in;
|
|
|
|
return in;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-06 04:43:40 +05:30
|
|
|
void MainWindow::setCatBackground(bool enabled)
|
2013-08-26 02:18:41 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (enabled)
|
|
|
|
{
|
2018-12-24 07:56:14 +05:30
|
|
|
QDateTime now = QDateTime::currentDateTime();
|
2021-12-06 03:56:04 +05:30
|
|
|
QDateTime birthday(QDate(now.date().year(), 11, 30), QTime(0, 0));
|
2018-12-24 07:56:14 +05:30
|
|
|
QDateTime xmas(QDate(now.date().year(), 12, 25), QTime(0, 0));
|
2022-11-04 23:39:57 +05:30
|
|
|
QDateTime halloween(QDate(now.date().year(), 10, 31), QTime(0, 0));
|
2022-11-02 03:36:27 +05:30
|
|
|
QString cat = APPLICATION->settings()->get("BackgroundCat").toString();
|
2022-11-04 23:39:57 +05:30
|
|
|
if (non_stupid_abs(now.daysTo(xmas)) <= 4) {
|
2022-11-02 03:36:27 +05:30
|
|
|
cat += "-xmas";
|
2022-11-06 04:34:43 +05:30
|
|
|
} else if (non_stupid_abs(now.daysTo(halloween)) <= 4) {
|
2022-11-06 05:17:33 +05:30
|
|
|
cat += "-spooky";
|
2022-11-04 23:39:57 +05:30
|
|
|
} else if (non_stupid_abs(now.daysTo(birthday)) <= 12) {
|
2022-11-02 03:36:27 +05:30
|
|
|
cat += "-bday";
|
2021-12-06 03:56:04 +05:30
|
|
|
}
|
2018-12-24 07:56:14 +05:30
|
|
|
view->setStyleSheet(QString(R"(
|
2021-10-26 03:21:42 +05:30
|
|
|
InstanceView
|
2018-07-24 04:12:18 +05:30
|
|
|
{
|
2018-12-24 07:56:14 +05:30
|
|
|
background-image: url(:/backgrounds/%1);
|
2018-07-24 04:12:18 +05:30
|
|
|
background-attachment: fixed;
|
|
|
|
background-clip: padding;
|
2022-11-02 03:36:27 +05:30
|
|
|
background-position: bottom left;
|
2018-07-24 04:12:18 +05:30
|
|
|
background-repeat: none;
|
|
|
|
background-color:palette(base);
|
2022-11-02 03:36:27 +05:30
|
|
|
})")
|
|
|
|
.arg(cat));
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
view->setStyleSheet(QString());
|
|
|
|
}
|
2013-08-26 02:18:41 +05:30
|
|
|
}
|
|
|
|
|
2016-10-03 04:25:54 +05:30
|
|
|
void MainWindow::runModalTask(Task *task)
|
2015-01-28 03:01:07 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
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();
|
|
|
|
}
|
|
|
|
});
|
2022-07-29 00:28:04 +05:30
|
|
|
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 18:21:05 +05:30
|
|
|
ProgressDialog loadDialog(this);
|
|
|
|
loadDialog.setSkipButton(true, tr("Abort"));
|
|
|
|
loadDialog.execWithTask(task);
|
2016-10-03 04:25:54 +05:30
|
|
|
}
|
2015-02-13 02:31:20 +05:30
|
|
|
|
2018-03-19 07:06:12 +05:30
|
|
|
void MainWindow::instanceFromInstanceTask(InstanceTask *rawTask)
|
2016-10-03 04:25:54 +05:30
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
unique_qobject_ptr<Task> task(APPLICATION->instances()->wrapInstanceTask(rawTask));
|
2018-07-15 18:21:05 +05:30
|
|
|
runModalTask(task.get());
|
2018-03-01 00:12:30 +05:30
|
|
|
}
|
|
|
|
|
2016-10-03 04:25:54 +05:30
|
|
|
void MainWindow::on_actionCopyInstance_triggered()
|
2015-01-28 03:01:07 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (!m_selectedInstance)
|
|
|
|
return;
|
2015-02-01 07:38:25 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
CopyInstanceDialog copyInstDlg(m_selectedInstance, this);
|
|
|
|
if (!copyInstDlg.exec())
|
|
|
|
return;
|
2015-01-28 03:01:07 +05:30
|
|
|
|
2022-10-23 08:34:36 +05:30
|
|
|
auto copyTask = new InstanceCopyTask(m_selectedInstance, copyInstDlg.getChosenOptions());
|
2018-07-15 18:21:05 +05:30
|
|
|
copyTask->setName(copyInstDlg.instName());
|
|
|
|
copyTask->setGroup(copyInstDlg.instGroup());
|
|
|
|
copyTask->setIcon(copyInstDlg.iconKey());
|
2021-11-20 20:52:22 +05:30
|
|
|
unique_qobject_ptr<Task> task(APPLICATION->instances()->wrapInstanceTask(copyTask));
|
2018-07-15 18:21:05 +05:30
|
|
|
runModalTask(task.get());
|
2015-01-28 03:01:07 +05:30
|
|
|
}
|
2015-02-13 02:31:20 +05:30
|
|
|
|
2015-01-28 03:01:07 +05:30
|
|
|
void MainWindow::finalizeInstance(InstancePtr inst)
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
view->updateGeometries();
|
|
|
|
setSelectedInstanceById(inst->id());
|
2021-11-20 20:52:22 +05:30
|
|
|
if (APPLICATION->accounts()->anyAccountIsValid())
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
|
|
|
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-18 04:17:02 +05:30
|
|
|
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 18:21:05 +05:30
|
|
|
}
|
2013-01-09 23:52:22 +05:30
|
|
|
}
|
|
|
|
|
2017-04-22 09:41:26 +05:30
|
|
|
void MainWindow::addInstance(QString url)
|
2015-01-28 03:01:07 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
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 20:52:22 +05:30
|
|
|
groupName = APPLICATION->settings()->get("LastUsedGroupForNewInstance").toString();
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
NewInstanceDialog newInstDlg(groupName, url, this);
|
|
|
|
if (!newInstDlg.exec())
|
|
|
|
return;
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->settings()->set("LastUsedGroupForNewInstance", newInstDlg.instGroup());
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
InstanceTask * creationTask = newInstDlg.extractTask();
|
|
|
|
if(creationTask)
|
|
|
|
{
|
|
|
|
instanceFromInstanceTask(creationTask);
|
|
|
|
}
|
2015-01-28 03:01:07 +05:30
|
|
|
}
|
|
|
|
|
2017-04-22 09:41:26 +05:30
|
|
|
void MainWindow::on_actionAddInstance_triggered()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
addInstance();
|
2017-04-22 09:41:26 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void MainWindow::droppedURLs(QList<QUrl> urls)
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
for(auto & url:urls)
|
|
|
|
{
|
|
|
|
if(url.isLocalFile())
|
|
|
|
{
|
|
|
|
addInstance(url.toLocalFile());
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
addInstance(url.toString());
|
|
|
|
}
|
|
|
|
// Only process one dropped file...
|
|
|
|
break;
|
|
|
|
}
|
2017-04-22 09:41:26 +05:30
|
|
|
}
|
|
|
|
|
2015-09-16 02:32:21 +05:30
|
|
|
void MainWindow::on_actionREDDIT_triggered()
|
|
|
|
{
|
2021-06-18 16:54:20 +05:30
|
|
|
DesktopServices::openUrl(QUrl(BuildConfig.SUBREDDIT_URL));
|
2015-09-16 02:32:21 +05:30
|
|
|
}
|
|
|
|
|
2016-01-09 06:09:51 +05:30
|
|
|
void MainWindow::on_actionDISCORD_triggered()
|
|
|
|
{
|
2021-06-18 16:54:20 +05:30
|
|
|
DesktopServices::openUrl(QUrl(BuildConfig.DISCORD_URL));
|
2016-01-09 06:09:51 +05:30
|
|
|
}
|
|
|
|
|
2022-03-08 23:11:23 +05:30
|
|
|
void MainWindow::on_actionMATRIX_triggered()
|
|
|
|
{
|
|
|
|
DesktopServices::openUrl(QUrl(BuildConfig.MATRIX_URL));
|
|
|
|
}
|
|
|
|
|
2013-08-10 22:04:08 +05:30
|
|
|
void MainWindow::on_actionChangeInstIcon_triggered()
|
2013-03-19 10:54:34 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (!m_selectedInstance)
|
|
|
|
return;
|
2013-10-06 04:43:40 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
IconPickerDialog dlg(this);
|
|
|
|
dlg.execWithSelection(m_selectedInstance->iconKey());
|
|
|
|
if (dlg.result() == QDialog::Accepted)
|
|
|
|
{
|
|
|
|
m_selectedInstance->setIconKey(dlg.selectedIconKey);
|
2021-11-20 20:52:22 +05:30
|
|
|
auto icon = APPLICATION->icons()->getIcon(dlg.selectedIconKey);
|
2018-07-15 18:21:05 +05:30
|
|
|
ui->actionChangeInstIcon->setIcon(icon);
|
|
|
|
ui->changeIconButton->setIcon(icon);
|
|
|
|
}
|
2013-03-19 10:54:34 +05:30
|
|
|
}
|
|
|
|
|
2013-12-31 05:54:28 +05:30
|
|
|
void MainWindow::iconUpdated(QString icon)
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (icon == m_currentInstIcon)
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
auto icon = APPLICATION->icons()->getIcon(m_currentInstIcon);
|
2018-07-15 18:21:05 +05:30
|
|
|
ui->actionChangeInstIcon->setIcon(icon);
|
|
|
|
ui->changeIconButton->setIcon(icon);
|
|
|
|
}
|
2013-03-19 10:54:34 +05:30
|
|
|
}
|
|
|
|
|
2013-12-31 05:54:28 +05:30
|
|
|
void MainWindow::updateInstanceToolIcon(QString new_icon)
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
m_currentInstIcon = new_icon;
|
2021-11-20 20:52:22 +05:30
|
|
|
auto icon = APPLICATION->icons()->getIcon(m_currentInstIcon);
|
2018-07-15 18:21:05 +05:30
|
|
|
ui->actionChangeInstIcon->setIcon(icon);
|
|
|
|
ui->changeIconButton->setIcon(icon);
|
2013-12-31 05:54:28 +05:30
|
|
|
}
|
|
|
|
|
2014-01-06 14:31:40 +05:30
|
|
|
void MainWindow::setSelectedInstanceById(const QString &id)
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (id.isNull())
|
|
|
|
return;
|
2021-11-20 20:52:22 +05:30
|
|
|
const QModelIndex index = APPLICATION->instances()->getInstanceIndexById(id);
|
2018-07-15 18:21:05 +05:30
|
|
|
if (index.isValid())
|
|
|
|
{
|
|
|
|
QModelIndex selectionIndex = proxymodel->mapFromSource(index);
|
|
|
|
view->selectionModel()->setCurrentIndex(selectionIndex, QItemSelectionModel::ClearAndSelect);
|
2019-07-10 07:53:24 +05:30
|
|
|
updateStatusCenter();
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2014-01-06 14:31:40 +05:30
|
|
|
}
|
|
|
|
|
2013-08-10 22:04:08 +05:30
|
|
|
void MainWindow::on_actionChangeInstGroup_triggered()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (!m_selectedInstance)
|
|
|
|
return;
|
2013-10-06 04:43:40 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
bool ok = false;
|
2018-07-31 05:24:08 +05:30
|
|
|
InstanceId instId = m_selectedInstance->id();
|
2021-11-20 20:52:22 +05:30
|
|
|
QString name(APPLICATION->instances()->getInstanceGroup(instId));
|
|
|
|
auto groups = APPLICATION->instances()->getGroups();
|
2018-07-15 18:21:05 +05:30
|
|
|
groups.insert(0, "");
|
|
|
|
groups.sort(Qt::CaseInsensitive);
|
|
|
|
int foo = groups.indexOf(name);
|
2013-12-15 22:40:51 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
name = QInputDialog::getItem(this, tr("Group name"), tr("Enter a new group name."), groups, foo, true, &ok);
|
|
|
|
name = name.simplified();
|
|
|
|
if (ok)
|
2018-07-31 05:24:08 +05:30
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->instances()->setInstanceGroup(instId, name);
|
2018-07-31 05:24:08 +05:30
|
|
|
}
|
2013-08-10 22:04:08 +05:30
|
|
|
}
|
|
|
|
|
2017-12-14 04:59:00 +05:30
|
|
|
void MainWindow::deleteGroup()
|
2016-04-11 05:00:50 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
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 17:49:09 +05:30
|
|
|
auto reply = QMessageBox::question(this, tr("Delete group"), tr("Are you sure you want to delete the group %1?")
|
2018-11-08 22:00:30 +05:30
|
|
|
.arg(groupName), QMessageBox::Yes | QMessageBox::No);
|
|
|
|
if(reply == QMessageBox::Yes)
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->instances()->deleteGroup(groupName);
|
2018-11-08 22:00:30 +05:30
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2016-04-11 05:00:50 +05:30
|
|
|
}
|
|
|
|
|
2022-07-30 23:12:33 +05:30
|
|
|
void MainWindow::undoTrashInstance()
|
|
|
|
{
|
|
|
|
APPLICATION->instances()->undoTrashInstance();
|
2022-10-30 23:07:03 +05:30
|
|
|
ui->actionUndoTrashInstance->setEnabled(APPLICATION->instances()->trashedSomething());
|
2022-07-30 23:12:33 +05:30
|
|
|
}
|
|
|
|
|
2013-01-09 23:52:22 +05:30
|
|
|
void MainWindow::on_actionViewInstanceFolder_triggered()
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
QString str = APPLICATION->settings()->get("InstanceDir").toString();
|
2018-07-15 18:21:05 +05:30
|
|
|
DesktopServices::openDirectory(str);
|
2013-01-09 23:52:22 +05:30
|
|
|
}
|
|
|
|
|
2017-12-14 04:59:00 +05:30
|
|
|
void MainWindow::refreshInstances()
|
2013-01-09 23:52:22 +05:30
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->instances()->loadList();
|
2013-01-09 23:52:22 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void MainWindow::on_actionViewCentralModsFolder_triggered()
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
DesktopServices::openDirectory(APPLICATION->settings()->get("CentralModsDir").toString(), true);
|
2013-01-09 23:52:22 +05:30
|
|
|
}
|
|
|
|
|
2017-12-14 04:59:00 +05:30
|
|
|
void MainWindow::checkForUpdates()
|
2013-01-09 23:52:22 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if(BuildConfig.UPDATER_ENABLED)
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
auto updater = APPLICATION->updateChecker();
|
|
|
|
updater->checkForUpdate(APPLICATION->settings()->get("UpdateChannel").toString(), true);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
qWarning() << "Updater not set up. Cannot check for updates.";
|
|
|
|
}
|
2013-01-09 23:52:22 +05:30
|
|
|
}
|
|
|
|
|
2014-07-16 03:43:40 +05:30
|
|
|
void MainWindow::on_actionSettings_triggered()
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->ShowGlobalSettings(this, "global-settings");
|
2019-06-01 15:58:53 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void MainWindow::globalSettingsClosed()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
// FIXME: quick HACK to make this work. improve, optimize.
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->instances()->loadList();
|
2018-07-15 18:21:05 +05:30
|
|
|
proxymodel->invalidate();
|
|
|
|
proxymodel->sort(0);
|
2022-04-16 03:55:37 +05:30
|
|
|
updateMainToolBar();
|
2018-07-15 18:21:05 +05:30
|
|
|
updateToolsMenu();
|
2022-11-15 14:16:24 +05:30
|
|
|
updateThemeMenu();
|
2021-10-14 02:44:02 +05:30
|
|
|
updateStatusCenter();
|
2022-05-17 04:51:57 +05:30
|
|
|
// This needs to be done to prevent UI elements disappearing in the event the config is changed
|
2022-10-18 20:07:04 +05:30
|
|
|
// but Prism Launcher exits abnormally, causing the window state to never be saved:
|
2022-05-17 04:51:57 +05:30
|
|
|
APPLICATION->settings()->set("MainWindowState", saveState().toBase64());
|
2018-07-15 18:21:05 +05:30
|
|
|
update();
|
2014-07-16 03:43:40 +05:30
|
|
|
}
|
|
|
|
|
2014-06-18 04:45:01 +05:30
|
|
|
void MainWindow::on_actionEditInstance_triggered()
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->showInstanceWindow(m_selectedInstance);
|
2014-06-18 04:45:01 +05:30
|
|
|
}
|
|
|
|
|
2013-11-20 23:50:35 +05:30
|
|
|
void MainWindow::on_actionManageAccounts_triggered()
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->ShowGlobalSettings(this, "accounts");
|
2013-11-20 23:50:35 +05:30
|
|
|
}
|
|
|
|
|
2013-01-09 23:52:22 +05:30
|
|
|
void MainWindow::on_actionReportBug_triggered()
|
|
|
|
{
|
2021-06-18 16:54:20 +05:30
|
|
|
DesktopServices::openUrl(QUrl(BuildConfig.BUG_TRACKER_URL));
|
2013-01-09 23:52:22 +05:30
|
|
|
}
|
|
|
|
|
2022-10-10 16:15:44 +05:30
|
|
|
void MainWindow::on_actionClearMetadata_triggered()
|
|
|
|
{
|
|
|
|
APPLICATION->metacache()->evictAll();
|
2022-11-06 05:35:10 +05:30
|
|
|
APPLICATION->metacache()->SaveNow();
|
2022-10-10 16:15:44 +05:30
|
|
|
}
|
|
|
|
|
2022-11-05 20:01:07 +05:30
|
|
|
#ifdef Q_OS_MAC
|
2022-11-14 23:07:24 +05:30
|
|
|
void MainWindow::on_actionAddToPATH_triggered()
|
|
|
|
{
|
2022-11-05 19:45:31 +05:30
|
|
|
auto binaryPath = APPLICATION->applicationFilePath();
|
2022-11-14 23:07:24 +05:30
|
|
|
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);
|
2022-10-19 19:23:57 +05:30
|
|
|
if (!outcome) {
|
2022-11-14 23:07:24 +05:30
|
|
|
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));
|
2022-10-19 19:23:57 +05:30
|
|
|
} else {
|
2022-11-14 23:07:24 +05:30
|
|
|
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));
|
2022-10-19 19:23:57 +05:30
|
|
|
}
|
|
|
|
}
|
2022-11-05 20:01:07 +05:30
|
|
|
#endif
|
2022-10-19 19:23:57 +05:30
|
|
|
|
2022-04-09 01:07:18 +05:30
|
|
|
void MainWindow::on_actionOpenWiki_triggered()
|
|
|
|
{
|
2022-04-16 02:14:27 +05:30
|
|
|
DesktopServices::openUrl(QUrl(BuildConfig.HELP_URL.arg("")));
|
2022-04-09 01:07:18 +05:30
|
|
|
}
|
|
|
|
|
2022-02-10 17:25:07 +05:30
|
|
|
void MainWindow::on_actionMoreNews_triggered()
|
|
|
|
{
|
2022-06-26 04:45:16 +05:30
|
|
|
auto entries = m_newsChecker->getNewsEntries();
|
|
|
|
NewsDialog news_dialog(entries, this);
|
|
|
|
news_dialog.exec();
|
2022-02-10 17:25:07 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void MainWindow::newsButtonClicked()
|
|
|
|
{
|
2022-06-26 04:45:16 +05:30
|
|
|
auto entries = m_newsChecker->getNewsEntries();
|
|
|
|
NewsDialog news_dialog(entries, this);
|
|
|
|
news_dialog.toggleArticleList();
|
|
|
|
news_dialog.exec();
|
2022-02-10 17:25:07 +05:30
|
|
|
}
|
|
|
|
|
2013-01-09 23:52:22 +05:30
|
|
|
void MainWindow::on_actionAbout_triggered()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
AboutDialog dialog(this);
|
|
|
|
dialog.exec();
|
2013-01-09 23:52:22 +05:30
|
|
|
}
|
2013-01-30 11:22:37 +05:30
|
|
|
|
2013-06-24 01:40:32 +05:30
|
|
|
void MainWindow::on_actionDeleteInstance_triggered()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (!m_selectedInstance)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2022-07-30 23:12:33 +05:30
|
|
|
|
2019-06-17 20:15:32 +05:30
|
|
|
auto id = m_selectedInstance->id();
|
2022-07-30 23:12:33 +05:30
|
|
|
if (APPLICATION->instances()->trashInstance(id)) {
|
2022-10-30 23:07:03 +05:30
|
|
|
ui->actionUndoTrashInstance->setEnabled(APPLICATION->instances()->trashedSomething());
|
2022-07-30 23:12:33 +05:30
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
auto response = CustomMessageBox::selectable(
|
|
|
|
this,
|
|
|
|
tr("CAREFUL!"),
|
|
|
|
tr("About to delete: %1\nThis is permanent and will completely delete the instance.\n\nAre you sure?").arg(m_selectedInstance->name()),
|
|
|
|
QMessageBox::Warning,
|
2019-02-27 03:26:08 +05:30
|
|
|
QMessageBox::Yes | QMessageBox::No,
|
|
|
|
QMessageBox::No
|
2018-07-15 18:21:05 +05:30
|
|
|
)->exec();
|
|
|
|
if (response == QMessageBox::Yes)
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->instances()->deleteInstance(id);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2013-06-24 01:40:32 +05:30
|
|
|
}
|
|
|
|
|
2015-02-13 02:31:20 +05:30
|
|
|
void MainWindow::on_actionExportInstance_triggered()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (m_selectedInstance)
|
|
|
|
{
|
|
|
|
ExportInstanceDialog dlg(m_selectedInstance, this);
|
|
|
|
dlg.exec();
|
|
|
|
}
|
2015-02-13 02:31:20 +05:30
|
|
|
}
|
|
|
|
|
2013-06-24 01:40:32 +05:30
|
|
|
void MainWindow::on_actionRenameInstance_triggered()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (m_selectedInstance)
|
|
|
|
{
|
2018-11-22 06:20:32 +05:30
|
|
|
view->edit(view->currentIndex());
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2013-06-24 01:40:32 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void MainWindow::on_actionViewSelectedInstFolder_triggered()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (m_selectedInstance)
|
|
|
|
{
|
|
|
|
QString str = m_selectedInstance->instanceRoot();
|
|
|
|
DesktopServices::openDirectory(QDir(str).absolutePath());
|
|
|
|
}
|
2013-06-24 01:40:32 +05:30
|
|
|
}
|
|
|
|
|
2013-10-06 04:43:40 +05:30
|
|
|
void MainWindow::closeEvent(QCloseEvent *event)
|
2013-01-30 11:22:37 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
// Save the window state and geometry.
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->settings()->set("MainWindowState", saveState().toBase64());
|
|
|
|
APPLICATION->settings()->set("MainWindowGeometry", saveGeometry().toBase64());
|
2018-07-15 18:21:05 +05:30
|
|
|
event->accept();
|
|
|
|
emit isClosing();
|
2013-01-30 11:22:37 +05:30
|
|
|
}
|
2013-03-12 02:49:17 +05:30
|
|
|
|
2016-12-05 06:59:08 +05:30
|
|
|
void MainWindow::changeEvent(QEvent* event)
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (event->type() == QEvent::LanguageChange)
|
|
|
|
{
|
2021-06-19 04:42:54 +05:30
|
|
|
retranslateUi();
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
QMainWindow::changeEvent(event);
|
2016-12-05 06:59:08 +05:30
|
|
|
}
|
|
|
|
|
2013-10-22 01:55:50 +05:30
|
|
|
void MainWindow::instanceActivated(QModelIndex index)
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (!index.isValid())
|
|
|
|
return;
|
|
|
|
QString id = index.data(InstanceList::InstanceIDRole).toString();
|
2021-11-20 20:52:22 +05:30
|
|
|
InstancePtr inst = APPLICATION->instances()->getInstanceById(id);
|
2018-07-15 18:21:05 +05:30
|
|
|
if (!inst)
|
|
|
|
return;
|
2013-10-22 01:55:50 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
activateInstance(inst);
|
2013-10-22 01:55:50 +05:30
|
|
|
}
|
|
|
|
|
2013-02-06 04:04:20 +05:30
|
|
|
void MainWindow::on_actionLaunchInstance_triggered()
|
|
|
|
{
|
2022-06-20 00:03:34 +05:30
|
|
|
if(m_selectedInstance && !m_selectedInstance->isRunning())
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->launch(m_selectedInstance);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2013-02-06 04:04:20 +05:30
|
|
|
}
|
|
|
|
|
2016-11-26 22:36:08 +05:30
|
|
|
void MainWindow::activateInstance(InstancePtr instance)
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->launch(instance);
|
2016-11-26 22:36:08 +05:30
|
|
|
}
|
|
|
|
|
2014-01-27 07:30:49 +05:30
|
|
|
void MainWindow::on_actionLaunchInstanceOffline_triggered()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (m_selectedInstance)
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->launch(m_selectedInstance, false);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2015-07-04 23:32:43 +05:30
|
|
|
}
|
|
|
|
|
2022-07-12 00:16:11 +05:30
|
|
|
void MainWindow::on_actionLaunchInstanceDemo_triggered()
|
|
|
|
{
|
|
|
|
if (m_selectedInstance)
|
|
|
|
{
|
|
|
|
APPLICATION->launch(m_selectedInstance, false, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-20 00:03:34 +05:30
|
|
|
void MainWindow::on_actionKillInstance_triggered()
|
|
|
|
{
|
|
|
|
if(m_selectedInstance && m_selectedInstance->isRunning())
|
|
|
|
{
|
|
|
|
APPLICATION->kill(m_selectedInstance);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-09 03:56:35 +05:30
|
|
|
void MainWindow::taskEnd()
|
2013-05-07 03:49:20 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
QObject *sender = QObject::sender();
|
|
|
|
if (sender == m_versionLoadTask)
|
|
|
|
m_versionLoadTask = NULL;
|
2013-10-06 04:43:40 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
sender->deleteLater();
|
2013-05-07 03:49:20 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void MainWindow::startTask(Task *task)
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
connect(task, SIGNAL(succeeded()), SLOT(taskEnd()));
|
|
|
|
connect(task, SIGNAL(failed(QString)), SLOT(taskEnd()));
|
|
|
|
task->start();
|
2013-05-07 03:49:20 +05:30
|
|
|
}
|
|
|
|
|
2013-10-06 04:43:40 +05:30
|
|
|
void MainWindow::instanceChanged(const QModelIndex ¤t, const QModelIndex &previous)
|
2013-08-25 05:02:42 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (!current.isValid())
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->settings()->set("SelectedInstance", QString());
|
2018-07-15 18:21:05 +05:30
|
|
|
selectionBad();
|
|
|
|
return;
|
|
|
|
}
|
2022-06-10 07:55:13 +05:30
|
|
|
if (m_selectedInstance) {
|
2022-06-10 13:18:18 +05:30
|
|
|
disconnect(m_selectedInstance.get(), &BaseInstance::runningStatusChanged, this, &MainWindow::refreshCurrentInstance);
|
2022-06-10 07:55:13 +05:30
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
QString id = current.data(InstanceList::InstanceIDRole).toString();
|
2021-11-20 20:52:22 +05:30
|
|
|
m_selectedInstance = APPLICATION->instances()->getInstanceById(id);
|
2018-07-15 18:21:05 +05:30
|
|
|
if (m_selectedInstance)
|
|
|
|
{
|
|
|
|
ui->instanceToolBar->setEnabled(true);
|
2022-04-16 01:25:03 +05:30
|
|
|
ui->setInstanceActionsEnabled(true);
|
2022-06-20 00:03:34 +05:30
|
|
|
ui->actionLaunchInstance->setEnabled(m_selectedInstance->canLaunch());
|
2018-07-15 18:21:05 +05:30
|
|
|
ui->actionLaunchInstanceOffline->setEnabled(m_selectedInstance->canLaunch());
|
2022-07-12 00:16:11 +05:30
|
|
|
ui->actionLaunchInstanceDemo->setEnabled(m_selectedInstance->canLaunch());
|
2022-09-16 03:53:58 +05:30
|
|
|
|
|
|
|
// Disable demo-mode if not available.
|
|
|
|
auto instance = dynamic_cast<MinecraftInstance*>(m_selectedInstance.get());
|
|
|
|
if (instance) {
|
|
|
|
ui->actionLaunchInstanceDemo->setEnabled(instance->supportsDemo());
|
|
|
|
}
|
|
|
|
|
2022-06-20 00:03:34 +05:30
|
|
|
ui->actionKillInstance->setEnabled(m_selectedInstance->isRunning());
|
2018-07-15 18:21:05 +05:30
|
|
|
ui->actionExportInstance->setEnabled(m_selectedInstance->canExport());
|
|
|
|
ui->renameButton->setText(m_selectedInstance->name());
|
|
|
|
m_statusLeft->setText(m_selectedInstance->getStatusbarDescription());
|
2019-07-10 07:53:24 +05:30
|
|
|
updateStatusCenter();
|
2018-07-15 18:21:05 +05:30
|
|
|
updateInstanceToolIcon(m_selectedInstance->iconKey());
|
|
|
|
|
|
|
|
updateToolsMenu();
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->settings()->set("SelectedInstance", m_selectedInstance->id());
|
2022-06-10 07:55:13 +05:30
|
|
|
|
2022-06-10 13:18:18 +05:30
|
|
|
connect(m_selectedInstance.get(), &BaseInstance::runningStatusChanged, this, &MainWindow::refreshCurrentInstance);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ui->instanceToolBar->setEnabled(false);
|
2022-04-16 01:25:03 +05:30
|
|
|
ui->setInstanceActionsEnabled(false);
|
2022-06-20 00:03:34 +05:30
|
|
|
ui->actionLaunchInstance->setEnabled(false);
|
|
|
|
ui->actionLaunchInstanceOffline->setEnabled(false);
|
2022-07-12 00:16:11 +05:30
|
|
|
ui->actionLaunchInstanceDemo->setEnabled(false);
|
2022-06-20 00:03:34 +05:30
|
|
|
ui->actionKillInstance->setEnabled(false);
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->settings()->set("SelectedInstance", QString());
|
2018-07-15 18:21:05 +05:30
|
|
|
selectionBad();
|
|
|
|
return;
|
|
|
|
}
|
2013-08-26 10:00:11 +05:30
|
|
|
}
|
|
|
|
|
2019-06-23 18:24:17 +05:30
|
|
|
void MainWindow::instanceSelectRequest(QString id)
|
2019-06-17 19:43:52 +05:30
|
|
|
{
|
|
|
|
setSelectedInstanceById(id);
|
|
|
|
}
|
|
|
|
|
2015-10-20 20:52:13 +05:30
|
|
|
void MainWindow::instanceDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
|
2015-04-07 04:51:03 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
auto current = view->selectionModel()->currentIndex();
|
|
|
|
QItemSelection test(topLeft, bottomRight);
|
|
|
|
if (test.contains(current))
|
|
|
|
{
|
|
|
|
instanceChanged(current, current);
|
|
|
|
}
|
2015-04-07 04:51:03 +05:30
|
|
|
}
|
|
|
|
|
2013-08-26 10:00:11 +05:30
|
|
|
void MainWindow::selectionBad()
|
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
// start by reseting everything...
|
|
|
|
m_selectedInstance = nullptr;
|
2013-12-31 05:54:28 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
statusBar()->clearMessage();
|
|
|
|
ui->instanceToolBar->setEnabled(false);
|
2022-04-16 01:25:03 +05:30
|
|
|
ui->setInstanceActionsEnabled(false);
|
2022-06-20 00:30:51 +05:30
|
|
|
updateToolsMenu();
|
2018-07-15 18:21:05 +05:30
|
|
|
ui->renameButton->setText(tr("Rename Instance"));
|
2021-10-16 04:12:01 +05:30
|
|
|
updateInstanceToolIcon("grass");
|
2014-01-06 14:31:40 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
// ...and then see if we can enable the previously selected instance
|
2021-11-20 20:52:22 +05:30
|
|
|
setSelectedInstanceById(APPLICATION->settings()->get("SelectedInstance").toString());
|
2013-07-15 01:31:30 +05:30
|
|
|
}
|
2013-08-26 02:18:41 +05:30
|
|
|
|
2014-07-27 19:20:03 +05:30
|
|
|
void MainWindow::checkInstancePathForProblems()
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
QString instanceFolder = APPLICATION->settings()->get("InstanceDir").toString();
|
2018-07-15 18:21:05 +05:30
|
|
|
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-18 04:17:02 +05:30
|
|
|
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"
|
2022-10-18 13:20:27 +05:30
|
|
|
).arg(BuildConfig.LAUNCHER_DISPLAYNAME)
|
2021-10-18 04:17:02 +05:30
|
|
|
);
|
2018-07-15 18:21:05 +05:30
|
|
|
warning.setDefaultButton(QMessageBox::Ok);
|
|
|
|
warning.exec();
|
|
|
|
}
|
|
|
|
auto tempFolderText = tr("This is a problem: <br/>"
|
2021-10-18 04:17:02 +05:30
|
|
|
" - 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 18:21:05 +05:30
|
|
|
QString pathfoldername = QDir(instanceFolder).absolutePath();
|
|
|
|
if (pathfoldername.contains("Rar$", Qt::CaseInsensitive))
|
|
|
|
{
|
|
|
|
QMessageBox warning(this);
|
2021-10-18 04:17:02 +05:30
|
|
|
warning.setText(tr("Your instance folder contains \'Rar$\' - that means you haven't extracted the launcher archive!"));
|
2018-07-15 18:21:05 +05:30
|
|
|
warning.setInformativeText(tempFolderText);
|
|
|
|
warning.setDefaultButton(QMessageBox::Ok);
|
|
|
|
warning.exec();
|
|
|
|
}
|
2019-08-05 00:44:59 +05:30
|
|
|
else if (pathfoldername.startsWith(QDir::tempPath()) || pathfoldername.contains("/TempState/"))
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
|
|
|
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();
|
|
|
|
}
|
2014-07-27 19:20:03 +05:30
|
|
|
}
|
2019-07-10 07:53:24 +05:30
|
|
|
|
|
|
|
void MainWindow::updateStatusCenter()
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
m_statusCenter->setVisible(APPLICATION->settings()->get("ShowGlobalGameTime").toBool());
|
2021-10-14 02:44:02 +05:30
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
int timePlayed = APPLICATION->instances()->getTotalPlayTime();
|
2021-09-29 03:50:34 +05:30
|
|
|
if (timePlayed > 0) {
|
|
|
|
m_statusCenter->setText(tr("Total playtime: %1").arg(Time::prettifyDuration(timePlayed)));
|
|
|
|
}
|
2019-07-10 07:53:24 +05:30
|
|
|
}
|
2022-06-10 07:55:13 +05:30
|
|
|
|
2022-06-10 13:18:18 +05:30
|
|
|
void MainWindow::refreshCurrentInstance(bool running)
|
2022-06-10 07:55:13 +05:30
|
|
|
{
|
|
|
|
auto current = view->selectionModel()->currentIndex();
|
|
|
|
instanceChanged(current, current);
|
|
|
|
}
|