chore: make yuzu REUSE compliant
[REUSE] is a specification that aims at making file copyright
information consistent, so that it can be both human and machine
readable. It basically requires that all files have a header containing
copyright and licensing information. When this isn't possible, like
when dealing with binary assets, generated files or embedded third-party
dependencies, it is permitted to insert copyright information in the
`.reuse/dep5` file.
Oh, and it also requires that all the licenses used in the project are
present in the `LICENSES` folder, that's why the diff is so huge.
This can be done automatically with `reuse download --all`.
The `reuse` tool also contains a handy subcommand that analyzes the
project and tells whether or not the project is (still) compliant,
`reuse lint`.
Following REUSE has a few advantages over the current approach:
- Copyright information is easy to access for users / downstream
- Files like `dist/license.md` do not need to exist anymore, as
`.reuse/dep5` is used instead
- `reuse lint` makes it easy to ensure that copyright information of
files like binary assets / images is always accurate and up to date
To add copyright information of files that didn't have it I looked up
who committed what and when, for each file. As yuzu contributors do not
have to sign a CLA or similar I couldn't assume that copyright ownership
was of the "yuzu Emulator Project", so I used the name and/or email of
the commit author instead.
[REUSE]: https://reuse.software
Follow-up to 01cf05bc75b1e47beb08937439f3ed9339e7b254
2022-05-15 02:06:02 +02:00
|
|
|
// SPDX-FileCopyrightText: 2015 Citra Emulator Project
|
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2015-09-01 06:35:33 +02:00
|
|
|
|
2018-08-10 02:53:30 +02:00
|
|
|
#include <regex>
|
2017-04-18 04:53:40 +02:00
|
|
|
#include <QApplication>
|
2018-06-14 18:02:32 +02:00
|
|
|
#include <QDir>
|
2017-02-12 21:28:56 +01:00
|
|
|
#include <QFileInfo>
|
2015-09-01 06:35:33 +02:00
|
|
|
#include <QHeaderView>
|
2018-08-29 15:42:53 +02:00
|
|
|
#include <QJsonArray>
|
|
|
|
#include <QJsonDocument>
|
|
|
|
#include <QJsonObject>
|
2021-04-10 11:09:01 +02:00
|
|
|
#include <QList>
|
2016-12-15 10:55:03 +01:00
|
|
|
#include <QMenu>
|
2015-09-01 06:35:33 +02:00
|
|
|
#include <QThreadPool>
|
2022-03-19 06:16:04 +01:00
|
|
|
#include <QToolButton>
|
2018-08-29 15:42:53 +02:00
|
|
|
#include <fmt/format.h>
|
2018-09-02 16:53:06 +02:00
|
|
|
#include "common/common_types.h"
|
2015-09-01 06:35:33 +02:00
|
|
|
#include "common/logging/log.h"
|
2021-11-28 06:26:51 +01:00
|
|
|
#include "core/core.h"
|
2018-08-26 01:06:16 +02:00
|
|
|
#include "core/file_sys/patch_manager.h"
|
2019-03-04 18:40:53 +01:00
|
|
|
#include "core/file_sys/registered_cache.h"
|
2018-09-10 01:09:37 +02:00
|
|
|
#include "yuzu/compatibility_list.h"
|
2018-08-31 18:21:34 +02:00
|
|
|
#include "yuzu/game_list.h"
|
|
|
|
#include "yuzu/game_list_p.h"
|
2018-09-07 22:08:08 +02:00
|
|
|
#include "yuzu/game_list_worker.h"
|
2018-08-31 18:21:34 +02:00
|
|
|
#include "yuzu/main.h"
|
2019-07-29 22:06:33 +02:00
|
|
|
#include "yuzu/uisettings.h"
|
2021-11-28 06:26:51 +01:00
|
|
|
#include "yuzu/util/controller_navigation.h"
|
2015-09-01 06:35:33 +02:00
|
|
|
|
2022-06-13 22:52:19 +02:00
|
|
|
GameListSearchField::KeyReleaseEater::KeyReleaseEater(GameList* gamelist_, QObject* parent)
|
|
|
|
: QObject(parent), gamelist{gamelist_} {}
|
2017-04-30 04:04:39 +02:00
|
|
|
|
|
|
|
// EventFilter in order to process systemkeys while editing the searchfield
|
2018-07-23 12:43:34 +02:00
|
|
|
bool GameListSearchField::KeyReleaseEater::eventFilter(QObject* obj, QEvent* event) {
|
2017-04-30 04:04:39 +02:00
|
|
|
// If it isn't a KeyRelease event then continue with standard event processing
|
|
|
|
if (event->type() != QEvent::KeyRelease)
|
|
|
|
return QObject::eventFilter(obj, event);
|
|
|
|
|
|
|
|
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
|
|
|
|
QString edit_filter_text = gamelist->search_field->edit_filter->text().toLower();
|
|
|
|
|
|
|
|
// If the searchfield's text hasn't changed special function keys get checked
|
|
|
|
// If no function key changes the searchfield's text the filter doesn't need to get reloaded
|
|
|
|
if (edit_filter_text == edit_filter_text_old) {
|
|
|
|
switch (keyEvent->key()) {
|
|
|
|
// Escape: Resets the searchfield
|
|
|
|
case Qt::Key_Escape: {
|
|
|
|
if (edit_filter_text_old.isEmpty()) {
|
|
|
|
return QObject::eventFilter(obj, event);
|
|
|
|
} else {
|
|
|
|
gamelist->search_field->edit_filter->clear();
|
2019-05-20 21:18:36 +02:00
|
|
|
edit_filter_text.clear();
|
2017-04-30 04:04:39 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Return and Enter
|
2017-05-02 23:55:27 +02:00
|
|
|
// If the enter key gets pressed first checks how many and which entry is visible
|
2017-04-30 04:04:39 +02:00
|
|
|
// If there is only one result launch this game
|
|
|
|
case Qt::Key_Return:
|
|
|
|
case Qt::Key_Enter: {
|
2019-05-01 23:21:04 +02:00
|
|
|
if (gamelist->search_field->visible == 1) {
|
2020-09-23 17:28:08 +02:00
|
|
|
const QString file_path = gamelist->GetLastFilterResultItem();
|
2019-05-01 23:21:04 +02:00
|
|
|
|
2017-04-30 04:04:39 +02:00
|
|
|
// To avoid loading error dialog loops while confirming them using enter
|
2019-05-20 21:18:36 +02:00
|
|
|
// Also users usually want to run a different game after closing one
|
|
|
|
gamelist->search_field->edit_filter->clear();
|
|
|
|
edit_filter_text.clear();
|
2017-04-30 04:04:39 +02:00
|
|
|
emit gamelist->GameChosen(file_path);
|
|
|
|
} else {
|
|
|
|
return QObject::eventFilter(obj, event);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return QObject::eventFilter(obj, event);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
edit_filter_text_old = edit_filter_text;
|
|
|
|
return QObject::eventFilter(obj, event);
|
|
|
|
}
|
|
|
|
|
2022-05-27 01:57:35 +02:00
|
|
|
void GameListSearchField::setFilterResult(int visible_, int total_) {
|
|
|
|
visible = visible_;
|
|
|
|
total = total_;
|
2019-05-01 23:21:04 +02:00
|
|
|
|
game_list: Handle plurals within setFilterResult() better
Qt provides an overload of tr() that operates on quantities in relation
to pluralization. This also allows the translation to adapt based on the
target language rules better.
For example, the previous code would result in an incorrect translation
for the French language (which doesn't use the pluralized version of
"result" in the case of a total of zero. While in English it's
correct to use the pluralized version of "result", that is, "results"
---
For example:
English: "0 results"
French: "0 résultat" (uses the singular form)
In French, the noun being counted is singular if the quantity is 0 or 1.
In English, on the other hand, if the noun being counted has a quantity
of 0 or N > 1, then the noun is pluralized.
---
For another example in a language that has different counting methods
than the above, consider English and Irish. Irish has a special form of
of a grammatical number called a dual. Which alters how a word is
written when N of something is 2. This won't appear in this case with a
direct number "2", but it would change if we ever used "Two" to refer to
two of something. For example:
English: "Zero results"
Irish: "Toradh ar bith"
English: "One result"
Irish: "Toradh amháin"
English: "Two results"
Irish: "Dhá thorthaí" <- Dual case
Which is an important distinction to make between singular and plural,
because in other situations, "two" on its own would be written as "dó"
in Irish. There's also a few other cases where the order the words are
placed *and* whether or not the plural or singular variant of the word
is used *and* whether or not the word is placed after or between a set
of numbers can vary. Counting in Irish also differs depending on whether or not
you're counting things (like above) or counting people, in which case an
entirely different set of numbers are used.
It's not important for this case, but it's provided as an example as to why one
should never assume the placement of values in text will be like that of
English or other languages. Some languages have very different ways to
represent counting, and breaking up the translated string like this
isn't advisable because it makes it extremely difficult to get right
depending on what language a translator is translating text into due to
the ambiguity of the strings being presented for translation.
In this case a translator would see three fragmented strings on
Transifex (and not necessarily grouped beside one another, but even
then, it would still be annoying to decipher):
- "of"
- "result"
- "results"
There is no way a translator is going to know what those sets of words
are actually used for unless they look at the code to see what is being
done with them (which they shouldn't have to do).
2018-09-20 05:04:59 +02:00
|
|
|
label_filter_result->setText(tr("%1 of %n result(s)", "", total).arg(visible));
|
2017-04-30 04:04:39 +02:00
|
|
|
}
|
2015-09-01 06:35:33 +02:00
|
|
|
|
2021-04-29 23:56:30 +02:00
|
|
|
QString GameListSearchField::filterText() const {
|
|
|
|
return edit_filter->text();
|
2021-04-10 11:09:01 +02:00
|
|
|
}
|
|
|
|
|
2020-09-23 17:28:08 +02:00
|
|
|
QString GameList::GetLastFilterResultItem() const {
|
2019-05-01 23:21:04 +02:00
|
|
|
QString file_path;
|
2020-09-23 17:20:10 +02:00
|
|
|
|
2021-06-02 16:17:01 +02:00
|
|
|
for (int i = 1; i < item_model->rowCount() - 1; ++i) {
|
2020-09-23 17:20:10 +02:00
|
|
|
const QStandardItem* folder = item_model->item(i, 0);
|
2019-05-03 19:21:57 +02:00
|
|
|
const QModelIndex folder_index = folder->index();
|
|
|
|
const int children_count = folder->rowCount();
|
2020-09-23 17:20:10 +02:00
|
|
|
|
2019-05-03 19:21:57 +02:00
|
|
|
for (int j = 0; j < children_count; ++j) {
|
2020-09-23 17:20:10 +02:00
|
|
|
if (tree_view->isRowHidden(j, folder_index)) {
|
|
|
|
continue;
|
2019-05-01 23:21:04 +02:00
|
|
|
}
|
2020-09-23 17:20:10 +02:00
|
|
|
|
|
|
|
const QStandardItem* child = folder->child(j, 0);
|
|
|
|
file_path = child->data(GameListItemPath::FullPathRole).toString();
|
2019-05-01 23:21:04 +02:00
|
|
|
}
|
|
|
|
}
|
2020-09-23 17:20:10 +02:00
|
|
|
|
2019-05-01 23:21:04 +02:00
|
|
|
return file_path;
|
|
|
|
}
|
|
|
|
|
2018-07-23 12:43:34 +02:00
|
|
|
void GameListSearchField::clear() {
|
2019-05-20 21:18:36 +02:00
|
|
|
edit_filter->clear();
|
2017-04-30 04:04:39 +02:00
|
|
|
}
|
|
|
|
|
2018-07-23 12:43:34 +02:00
|
|
|
void GameListSearchField::setFocus() {
|
2017-04-30 04:04:39 +02:00
|
|
|
if (edit_filter->isVisible()) {
|
|
|
|
edit_filter->setFocus();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-23 12:43:34 +02:00
|
|
|
GameListSearchField::GameListSearchField(GameList* parent) : QWidget{parent} {
|
2020-09-29 21:22:50 +02:00
|
|
|
auto* const key_release_eater = new KeyReleaseEater(parent, this);
|
2017-04-30 04:04:39 +02:00
|
|
|
layout_filter = new QHBoxLayout;
|
2021-01-13 13:20:20 +01:00
|
|
|
layout_filter->setContentsMargins(8, 8, 8, 8);
|
2017-04-30 04:04:39 +02:00
|
|
|
label_filter = new QLabel;
|
|
|
|
label_filter->setText(tr("Filter:"));
|
|
|
|
edit_filter = new QLineEdit;
|
2019-05-20 21:18:36 +02:00
|
|
|
edit_filter->clear();
|
2017-04-30 04:04:39 +02:00
|
|
|
edit_filter->setPlaceholderText(tr("Enter pattern to filter"));
|
2019-05-20 21:18:36 +02:00
|
|
|
edit_filter->installEventFilter(key_release_eater);
|
2017-04-30 04:04:39 +02:00
|
|
|
edit_filter->setClearButtonEnabled(true);
|
2020-09-23 17:28:08 +02:00
|
|
|
connect(edit_filter, &QLineEdit::textChanged, parent, &GameList::OnTextChanged);
|
2017-04-30 04:04:39 +02:00
|
|
|
label_filter_result = new QLabel;
|
|
|
|
button_filter_close = new QToolButton(this);
|
2019-05-20 21:18:36 +02:00
|
|
|
button_filter_close->setText(QStringLiteral("X"));
|
2017-04-30 04:04:39 +02:00
|
|
|
button_filter_close->setCursor(Qt::ArrowCursor);
|
2019-05-20 21:18:36 +02:00
|
|
|
button_filter_close->setStyleSheet(
|
|
|
|
QStringLiteral("QToolButton{ border: none; padding: 0px; color: "
|
|
|
|
"#000000; font-weight: bold; background: #F0F0F0; }"
|
|
|
|
"QToolButton:hover{ border: none; padding: 0px; color: "
|
|
|
|
"#EEEEEE; font-weight: bold; background: #E81123}"));
|
2020-09-23 17:28:08 +02:00
|
|
|
connect(button_filter_close, &QToolButton::clicked, parent, &GameList::OnFilterCloseClicked);
|
2017-04-30 04:04:39 +02:00
|
|
|
layout_filter->setSpacing(10);
|
|
|
|
layout_filter->addWidget(label_filter);
|
|
|
|
layout_filter->addWidget(edit_filter);
|
|
|
|
layout_filter->addWidget(label_filter_result);
|
|
|
|
layout_filter->addWidget(button_filter_close);
|
|
|
|
setLayout(layout_filter);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-05-02 23:55:27 +02:00
|
|
|
* Checks if all words separated by spaces are contained in another string
|
|
|
|
* This offers a word order insensitive search function
|
|
|
|
*
|
2018-01-18 01:51:14 +01:00
|
|
|
* @param haystack String that gets checked if it contains all words of the userinput string
|
|
|
|
* @param userinput String containing all words getting checked
|
2017-05-02 23:55:27 +02:00
|
|
|
* @return true if the haystack contains all words of userinput
|
|
|
|
*/
|
2018-07-18 22:52:12 +02:00
|
|
|
static bool ContainsAllWords(const QString& haystack, const QString& userinput) {
|
2022-02-01 17:41:01 +01:00
|
|
|
const QStringList userinput_split = userinput.split(QLatin1Char{' '}, Qt::SkipEmptyParts);
|
2018-07-18 06:12:39 +02:00
|
|
|
|
2017-04-30 04:04:39 +02:00
|
|
|
return std::all_of(userinput_split.begin(), userinput_split.end(),
|
2018-07-18 06:12:39 +02:00
|
|
|
[&haystack](const QString& s) { return haystack.contains(s); });
|
2017-04-30 04:04:39 +02:00
|
|
|
}
|
|
|
|
|
2019-05-01 23:21:04 +02:00
|
|
|
// Syncs the expanded state of Game Directories with settings to persist across sessions
|
2020-09-23 17:28:08 +02:00
|
|
|
void GameList::OnItemExpanded(const QModelIndex& item) {
|
2019-05-03 19:21:57 +02:00
|
|
|
const auto type = item.data(GameListItem::TypeRole).value<GameListItemType>();
|
2020-09-23 17:28:08 +02:00
|
|
|
const bool is_dir = type == GameListItemType::CustomDir || type == GameListItemType::SdmcDir ||
|
|
|
|
type == GameListItemType::UserNandDir ||
|
|
|
|
type == GameListItemType::SysNandDir;
|
2021-12-12 21:46:42 +01:00
|
|
|
const bool is_fave = type == GameListItemType::Favorites;
|
|
|
|
if (!is_dir && !is_fave) {
|
2020-09-23 17:28:08 +02:00
|
|
|
return;
|
|
|
|
}
|
2021-12-12 21:46:42 +01:00
|
|
|
const bool is_expanded = tree_view->isExpanded(item);
|
|
|
|
if (is_fave) {
|
|
|
|
UISettings::values.favorites_expanded = is_expanded;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const int item_dir_index = item.data(GameListDir::GameDirRole).toInt();
|
|
|
|
UISettings::values.game_dirs[item_dir_index].expanded = is_expanded;
|
2019-05-01 23:21:04 +02:00
|
|
|
}
|
|
|
|
|
2017-04-30 04:04:39 +02:00
|
|
|
// Event in order to filter the gamelist after editing the searchfield
|
2020-09-23 17:28:08 +02:00
|
|
|
void GameList::OnTextChanged(const QString& new_text) {
|
2019-05-01 23:21:04 +02:00
|
|
|
QString edit_filter_text = new_text.toLower();
|
|
|
|
QStandardItem* folder;
|
2019-05-03 19:21:57 +02:00
|
|
|
int children_total = 0;
|
2017-04-30 04:04:39 +02:00
|
|
|
|
|
|
|
// If the searchfield is empty every item is visible
|
|
|
|
// Otherwise the filter gets applied
|
|
|
|
if (edit_filter_text.isEmpty()) {
|
2021-04-10 11:09:01 +02:00
|
|
|
tree_view->setRowHidden(0, item_model->invisibleRootItem()->index(),
|
|
|
|
UISettings::values.favorited_ids.size() == 0);
|
2021-06-02 16:17:01 +02:00
|
|
|
for (int i = 1; i < item_model->rowCount() - 1; ++i) {
|
2019-05-01 23:21:04 +02:00
|
|
|
folder = item_model->item(i, 0);
|
2019-05-03 19:21:57 +02:00
|
|
|
const QModelIndex folder_index = folder->index();
|
|
|
|
const int children_count = folder->rowCount();
|
|
|
|
for (int j = 0; j < children_count; ++j) {
|
|
|
|
++children_total;
|
2019-05-01 23:21:04 +02:00
|
|
|
tree_view->setRowHidden(j, folder_index, false);
|
|
|
|
}
|
2017-04-30 04:04:39 +02:00
|
|
|
}
|
2019-05-03 19:21:57 +02:00
|
|
|
search_field->setFilterResult(children_total, children_total);
|
2017-04-30 04:04:39 +02:00
|
|
|
} else {
|
2021-04-10 11:09:01 +02:00
|
|
|
tree_view->setRowHidden(0, item_model->invisibleRootItem()->index(), true);
|
2017-04-30 04:04:39 +02:00
|
|
|
int result_count = 0;
|
2021-06-02 16:17:01 +02:00
|
|
|
for (int i = 1; i < item_model->rowCount() - 1; ++i) {
|
2019-05-01 23:21:04 +02:00
|
|
|
folder = item_model->item(i, 0);
|
2019-05-03 19:21:57 +02:00
|
|
|
const QModelIndex folder_index = folder->index();
|
|
|
|
const int children_count = folder->rowCount();
|
|
|
|
for (int j = 0; j < children_count; ++j) {
|
|
|
|
++children_total;
|
2019-05-01 23:21:04 +02:00
|
|
|
const QStandardItem* child = folder->child(j, 0);
|
|
|
|
const QString file_path =
|
|
|
|
child->data(GameListItemPath::FullPathRole).toString().toLower();
|
|
|
|
const QString file_title =
|
|
|
|
child->data(GameListItemPath::TitleRole).toString().toLower();
|
|
|
|
const QString file_program_id =
|
|
|
|
child->data(GameListItemPath::ProgramIdRole).toString().toLower();
|
|
|
|
|
|
|
|
// Only items which filename in combination with its title contains all words
|
|
|
|
// that are in the searchfield will be visible in the gamelist
|
|
|
|
// The search is case insensitive because of toLower()
|
|
|
|
// I decided not to use Qt::CaseInsensitive in containsAllWords to prevent
|
|
|
|
// multiple conversions of edit_filter_text for each game in the gamelist
|
|
|
|
const QString file_name =
|
|
|
|
file_path.mid(file_path.lastIndexOf(QLatin1Char{'/'}) + 1) + QLatin1Char{' '} +
|
|
|
|
file_title;
|
|
|
|
if (ContainsAllWords(file_name, edit_filter_text) ||
|
|
|
|
(file_program_id.count() == 16 && edit_filter_text.contains(file_program_id))) {
|
|
|
|
tree_view->setRowHidden(j, folder_index, false);
|
|
|
|
++result_count;
|
|
|
|
} else {
|
|
|
|
tree_view->setRowHidden(j, folder_index, true);
|
|
|
|
}
|
2017-04-30 04:04:39 +02:00
|
|
|
}
|
2019-05-01 23:21:04 +02:00
|
|
|
}
|
2021-04-29 23:56:30 +02:00
|
|
|
search_field->setFilterResult(result_count, children_total);
|
2019-05-01 23:21:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-23 17:28:08 +02:00
|
|
|
void GameList::OnUpdateThemedIcons() {
|
2019-05-01 23:21:04 +02:00
|
|
|
for (int i = 0; i < item_model->invisibleRootItem()->rowCount(); i++) {
|
|
|
|
QStandardItem* child = item_model->invisibleRootItem()->child(i);
|
|
|
|
|
2021-08-01 18:59:36 +02:00
|
|
|
const int icon_size = UISettings::values.folder_icon_size.GetValue();
|
|
|
|
|
2019-05-01 23:21:04 +02:00
|
|
|
switch (child->data(GameListItem::TypeRole).value<GameListItemType>()) {
|
2019-05-05 03:07:09 +02:00
|
|
|
case GameListItemType::SdmcDir:
|
2019-05-01 23:21:04 +02:00
|
|
|
child->setData(
|
|
|
|
QIcon::fromTheme(QStringLiteral("sd_card"))
|
|
|
|
.pixmap(icon_size)
|
|
|
|
.scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
|
|
|
|
Qt::DecorationRole);
|
|
|
|
break;
|
2019-05-05 03:07:09 +02:00
|
|
|
case GameListItemType::UserNandDir:
|
|
|
|
child->setData(
|
|
|
|
QIcon::fromTheme(QStringLiteral("chip"))
|
|
|
|
.pixmap(icon_size)
|
|
|
|
.scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
|
|
|
|
Qt::DecorationRole);
|
|
|
|
break;
|
|
|
|
case GameListItemType::SysNandDir:
|
2019-05-01 23:21:04 +02:00
|
|
|
child->setData(
|
|
|
|
QIcon::fromTheme(QStringLiteral("chip"))
|
|
|
|
.pixmap(icon_size)
|
|
|
|
.scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
|
|
|
|
Qt::DecorationRole);
|
|
|
|
break;
|
|
|
|
case GameListItemType::CustomDir: {
|
2021-01-18 01:22:54 +01:00
|
|
|
const UISettings::GameDir& game_dir =
|
|
|
|
UISettings::values.game_dirs[child->data(GameListDir::GameDirRole).toInt()];
|
|
|
|
const QString icon_name = QFileInfo::exists(game_dir.path)
|
2019-05-03 19:21:57 +02:00
|
|
|
? QStringLiteral("folder")
|
|
|
|
: QStringLiteral("bad_folder");
|
2019-05-01 23:21:04 +02:00
|
|
|
child->setData(
|
|
|
|
QIcon::fromTheme(icon_name).pixmap(icon_size).scaled(
|
|
|
|
icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
|
|
|
|
Qt::DecorationRole);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case GameListItemType::AddDir:
|
|
|
|
child->setData(
|
2022-07-28 16:50:20 +02:00
|
|
|
QIcon::fromTheme(QStringLiteral("list-add"))
|
2019-05-01 23:21:04 +02:00
|
|
|
.pixmap(icon_size)
|
|
|
|
.scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
|
|
|
|
Qt::DecorationRole);
|
|
|
|
break;
|
2021-04-10 11:09:01 +02:00
|
|
|
case GameListItemType::Favorites:
|
|
|
|
child->setData(
|
|
|
|
QIcon::fromTheme(QStringLiteral("star"))
|
|
|
|
.pixmap(icon_size)
|
|
|
|
.scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
|
|
|
|
Qt::DecorationRole);
|
|
|
|
break;
|
2019-10-05 01:35:06 +02:00
|
|
|
default:
|
|
|
|
break;
|
2017-04-30 04:04:39 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-23 17:28:08 +02:00
|
|
|
void GameList::OnFilterCloseClicked() {
|
2017-04-30 04:04:39 +02:00
|
|
|
main_window->filterBarSetChecked(false);
|
|
|
|
}
|
|
|
|
|
2022-06-13 22:52:19 +02:00
|
|
|
GameList::GameList(FileSys::VirtualFilesystem vfs_, FileSys::ManualContentProvider* provider_,
|
2021-07-30 15:32:26 +02:00
|
|
|
Core::System& system_, GMainWindow* parent)
|
2022-06-13 22:52:19 +02:00
|
|
|
: QWidget{parent}, vfs{std::move(vfs_)}, provider{provider_}, system{system_} {
|
2017-04-18 04:53:40 +02:00
|
|
|
watcher = new QFileSystemWatcher(this);
|
|
|
|
connect(watcher, &QFileSystemWatcher::directoryChanged, this, &GameList::RefreshGameDirectory);
|
|
|
|
|
2017-04-30 04:04:39 +02:00
|
|
|
this->main_window = parent;
|
|
|
|
layout = new QVBoxLayout;
|
2015-09-01 06:35:33 +02:00
|
|
|
tree_view = new QTreeView;
|
2021-11-28 06:26:51 +01:00
|
|
|
controller_navigation = new ControllerNavigation(system.HIDCore(), this);
|
2018-07-23 12:43:34 +02:00
|
|
|
search_field = new GameListSearchField(this);
|
2015-09-01 06:35:33 +02:00
|
|
|
item_model = new QStandardItemModel(tree_view);
|
|
|
|
tree_view->setModel(item_model);
|
|
|
|
|
|
|
|
tree_view->setAlternatingRowColors(true);
|
|
|
|
tree_view->setSelectionMode(QHeaderView::SingleSelection);
|
|
|
|
tree_view->setSelectionBehavior(QHeaderView::SelectRows);
|
|
|
|
tree_view->setVerticalScrollMode(QHeaderView::ScrollPerPixel);
|
|
|
|
tree_view->setHorizontalScrollMode(QHeaderView::ScrollPerPixel);
|
|
|
|
tree_view->setSortingEnabled(true);
|
|
|
|
tree_view->setEditTriggers(QHeaderView::NoEditTriggers);
|
2016-12-15 10:55:03 +01:00
|
|
|
tree_view->setContextMenuPolicy(Qt::CustomContextMenu);
|
2019-05-20 21:18:36 +02:00
|
|
|
tree_view->setStyleSheet(QStringLiteral("QTreeView{ border: none; }"));
|
2015-09-01 06:35:33 +02:00
|
|
|
|
2021-06-02 07:27:08 +02:00
|
|
|
item_model->insertColumns(0, COLUMN_COUNT);
|
2018-10-24 14:20:32 +02:00
|
|
|
item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, tr("Name"));
|
|
|
|
item_model->setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, tr("Compatibility"));
|
2018-11-02 01:27:12 +01:00
|
|
|
|
2021-06-02 07:27:08 +02:00
|
|
|
item_model->setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
|
|
|
|
tree_view->setColumnHidden(COLUMN_ADD_ONS, !UISettings::values.show_add_ons);
|
|
|
|
item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
|
|
|
|
item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));
|
2020-04-06 03:12:17 +02:00
|
|
|
item_model->setSortRole(GameListItemPath::SortRole);
|
2015-09-01 06:35:33 +02:00
|
|
|
|
2020-09-23 17:28:08 +02:00
|
|
|
connect(main_window, &GMainWindow::UpdateThemedIcons, this, &GameList::OnUpdateThemedIcons);
|
2016-12-11 03:20:34 +01:00
|
|
|
connect(tree_view, &QTreeView::activated, this, &GameList::ValidateEntry);
|
2016-12-15 10:55:03 +01:00
|
|
|
connect(tree_view, &QTreeView::customContextMenuRequested, this, &GameList::PopupContextMenu);
|
2020-09-23 17:28:08 +02:00
|
|
|
connect(tree_view, &QTreeView::expanded, this, &GameList::OnItemExpanded);
|
|
|
|
connect(tree_view, &QTreeView::collapsed, this, &GameList::OnItemExpanded);
|
2021-11-28 06:26:51 +01:00
|
|
|
connect(controller_navigation, &ControllerNavigation::TriggerKeyboardEvent,
|
|
|
|
[this](Qt::Key key) {
|
|
|
|
// Avoid pressing buttons while playing
|
|
|
|
if (system.IsPoweredOn()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!this->isActiveWindow()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
QKeyEvent* event = new QKeyEvent(QEvent::KeyPress, key, Qt::NoModifier);
|
|
|
|
QCoreApplication::postEvent(tree_view, event);
|
|
|
|
});
|
2021-06-04 01:07:38 +02:00
|
|
|
|
2019-05-01 23:21:04 +02:00
|
|
|
// We must register all custom types with the Qt Automoc system so that we are able to use
|
|
|
|
// it with signals/slots. In this case, QList falls under the umbrells of custom types.
|
2015-09-01 06:35:33 +02:00
|
|
|
qRegisterMetaType<QList<QStandardItem*>>("QList<QStandardItem*>");
|
|
|
|
|
2017-02-18 21:09:14 +01:00
|
|
|
layout->setContentsMargins(0, 0, 0, 0);
|
2017-04-30 04:04:39 +02:00
|
|
|
layout->setSpacing(0);
|
2015-09-01 06:35:33 +02:00
|
|
|
layout->addWidget(tree_view);
|
2017-04-30 04:04:39 +02:00
|
|
|
layout->addWidget(search_field);
|
2015-09-01 06:35:33 +02:00
|
|
|
setLayout(layout);
|
|
|
|
}
|
|
|
|
|
2021-11-28 06:26:51 +01:00
|
|
|
void GameList::UnloadController() {
|
|
|
|
controller_navigation->UnloadController();
|
|
|
|
}
|
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
GameList::~GameList() {
|
2021-11-28 06:26:51 +01:00
|
|
|
UnloadController();
|
2015-09-01 06:35:33 +02:00
|
|
|
emit ShouldCancelWorker();
|
|
|
|
}
|
|
|
|
|
2020-09-23 17:28:08 +02:00
|
|
|
void GameList::SetFilterFocus() {
|
2017-05-06 12:08:28 +02:00
|
|
|
if (tree_view->model()->rowCount() > 0) {
|
|
|
|
search_field->setFocus();
|
|
|
|
}
|
2017-04-30 04:04:39 +02:00
|
|
|
}
|
|
|
|
|
2020-09-23 17:28:08 +02:00
|
|
|
void GameList::SetFilterVisible(bool visibility) {
|
2017-05-03 00:23:20 +02:00
|
|
|
search_field->setVisible(visibility);
|
2017-04-30 04:04:39 +02:00
|
|
|
}
|
|
|
|
|
2020-09-23 17:28:08 +02:00
|
|
|
void GameList::ClearFilter() {
|
2017-04-30 04:04:39 +02:00
|
|
|
search_field->clear();
|
|
|
|
}
|
|
|
|
|
2019-05-01 23:21:04 +02:00
|
|
|
void GameList::AddDirEntry(GameListDir* entry_items) {
|
2015-09-01 06:35:33 +02:00
|
|
|
item_model->invisibleRootItem()->appendRow(entry_items);
|
2019-05-01 23:21:04 +02:00
|
|
|
tree_view->setExpanded(
|
|
|
|
entry_items->index(),
|
2021-01-18 01:22:54 +01:00
|
|
|
UISettings::values.game_dirs[entry_items->data(GameListDir::GameDirRole).toInt()].expanded);
|
2015-09-01 06:35:33 +02:00
|
|
|
}
|
|
|
|
|
2019-05-01 23:21:04 +02:00
|
|
|
void GameList::AddEntry(const QList<QStandardItem*>& entry_items, GameListDir* parent) {
|
|
|
|
parent->appendRow(entry_items);
|
|
|
|
}
|
2018-08-06 20:57:14 +02:00
|
|
|
|
2019-05-01 23:21:04 +02:00
|
|
|
void GameList::ValidateEntry(const QModelIndex& item) {
|
2019-05-03 19:21:57 +02:00
|
|
|
const auto selected = item.sibling(item.row(), 0);
|
2019-05-01 23:21:04 +02:00
|
|
|
|
|
|
|
switch (selected.data(GameListItem::TypeRole).value<GameListItemType>()) {
|
|
|
|
case GameListItemType::Game: {
|
2019-05-03 19:21:57 +02:00
|
|
|
const QString file_path = selected.data(GameListItemPath::FullPathRole).toString();
|
2019-05-01 23:21:04 +02:00
|
|
|
if (file_path.isEmpty())
|
|
|
|
return;
|
2019-05-03 19:21:57 +02:00
|
|
|
const QFileInfo file_info(file_path);
|
2019-05-01 23:21:04 +02:00
|
|
|
if (!file_info.exists())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (file_info.isDir()) {
|
|
|
|
const QDir dir{file_path};
|
|
|
|
const QStringList matching_main = dir.entryList({QStringLiteral("main")}, QDir::Files);
|
|
|
|
if (matching_main.size() == 1) {
|
|
|
|
emit GameChosen(dir.path() + QDir::separator() + matching_main[0]);
|
|
|
|
}
|
|
|
|
return;
|
2018-06-14 23:25:40 +02:00
|
|
|
}
|
2019-05-01 23:21:04 +02:00
|
|
|
|
2021-07-20 07:10:05 +02:00
|
|
|
const auto title_id = selected.data(GameListItemPath::ProgramIdRole).toULongLong();
|
|
|
|
|
2019-05-01 23:21:04 +02:00
|
|
|
// Users usually want to run a different game after closing one
|
|
|
|
search_field->clear();
|
2021-07-20 07:10:05 +02:00
|
|
|
emit GameChosen(file_path, title_id);
|
2019-05-01 23:21:04 +02:00
|
|
|
break;
|
2018-06-14 23:25:40 +02:00
|
|
|
}
|
2019-05-01 23:21:04 +02:00
|
|
|
case GameListItemType::AddDir:
|
|
|
|
emit AddDirectory();
|
|
|
|
break;
|
2019-10-05 01:35:06 +02:00
|
|
|
default:
|
|
|
|
break;
|
2019-05-01 23:21:04 +02:00
|
|
|
}
|
|
|
|
}
|
2018-06-14 23:25:40 +02:00
|
|
|
|
2020-09-23 17:28:08 +02:00
|
|
|
bool GameList::IsEmpty() const {
|
2019-05-01 23:21:04 +02:00
|
|
|
for (int i = 0; i < item_model->rowCount(); i++) {
|
|
|
|
const QStandardItem* child = item_model->invisibleRootItem()->child(i);
|
2019-05-03 19:21:57 +02:00
|
|
|
const auto type = static_cast<GameListItemType>(child->type());
|
2020-09-23 17:28:08 +02:00
|
|
|
|
2019-05-01 23:21:04 +02:00
|
|
|
if (!child->hasChildren() &&
|
2019-05-05 03:07:09 +02:00
|
|
|
(type == GameListItemType::SdmcDir || type == GameListItemType::UserNandDir ||
|
|
|
|
type == GameListItemType::SysNandDir)) {
|
2019-05-01 23:21:04 +02:00
|
|
|
item_model->invisibleRootItem()->removeRow(child->row());
|
|
|
|
i--;
|
2020-08-15 17:14:09 +02:00
|
|
|
}
|
2019-05-01 23:21:04 +02:00
|
|
|
}
|
2020-09-23 17:28:08 +02:00
|
|
|
|
2019-05-01 23:21:04 +02:00
|
|
|
return !item_model->invisibleRootItem()->hasChildren();
|
2015-09-01 06:35:33 +02:00
|
|
|
}
|
|
|
|
|
2020-09-23 17:20:10 +02:00
|
|
|
void GameList::DonePopulating(const QStringList& watch_list) {
|
2020-09-23 17:28:08 +02:00
|
|
|
emit ShowList(!IsEmpty());
|
2019-05-01 23:21:04 +02:00
|
|
|
|
|
|
|
item_model->invisibleRootItem()->appendRow(new GameListAddDir());
|
2021-12-12 21:46:42 +01:00
|
|
|
|
|
|
|
// Add favorites row
|
2021-04-10 11:09:01 +02:00
|
|
|
item_model->invisibleRootItem()->insertRow(0, new GameListFavorites());
|
|
|
|
tree_view->setRowHidden(0, item_model->invisibleRootItem()->index(),
|
|
|
|
UISettings::values.favorited_ids.size() == 0);
|
2021-12-12 21:46:42 +01:00
|
|
|
tree_view->setExpanded(item_model->invisibleRootItem()->child(0)->index(),
|
|
|
|
UISettings::values.favorites_expanded.GetValue());
|
2021-04-10 11:09:01 +02:00
|
|
|
for (const auto id : UISettings::values.favorited_ids) {
|
|
|
|
AddFavorite(id);
|
|
|
|
}
|
2019-05-01 23:21:04 +02:00
|
|
|
|
2017-04-18 04:53:40 +02:00
|
|
|
// Clear out the old directories to watch for changes and add the new ones
|
|
|
|
auto watch_dirs = watcher->directories();
|
|
|
|
if (!watch_dirs.isEmpty()) {
|
|
|
|
watcher->removePaths(watch_dirs);
|
|
|
|
}
|
|
|
|
// Workaround: Add the watch paths in chunks to allow the gui to refresh
|
|
|
|
// This prevents the UI from stalling when a large number of watch paths are added
|
|
|
|
// Also artificially caps the watcher to a certain number of directories
|
|
|
|
constexpr int LIMIT_WATCH_DIRECTORIES = 5000;
|
|
|
|
constexpr int SLICE_SIZE = 25;
|
2022-05-12 16:03:37 +02:00
|
|
|
int len = std::min(static_cast<int>(watch_list.size()), LIMIT_WATCH_DIRECTORIES);
|
2017-04-18 04:53:40 +02:00
|
|
|
for (int i = 0; i < len; i += SLICE_SIZE) {
|
|
|
|
watcher->addPaths(watch_list.mid(i, i + SLICE_SIZE));
|
|
|
|
QCoreApplication::processEvents();
|
|
|
|
}
|
2015-09-01 06:35:33 +02:00
|
|
|
tree_view->setEnabled(true);
|
2019-05-03 19:21:57 +02:00
|
|
|
int children_total = 0;
|
2021-06-02 16:17:01 +02:00
|
|
|
for (int i = 1; i < item_model->rowCount() - 1; ++i) {
|
2019-05-05 01:52:17 +02:00
|
|
|
children_total += item_model->item(i, 0)->rowCount();
|
2019-05-01 23:21:04 +02:00
|
|
|
}
|
2019-05-03 19:21:57 +02:00
|
|
|
search_field->setFilterResult(children_total, children_total);
|
|
|
|
if (children_total > 0) {
|
2017-05-06 12:08:28 +02:00
|
|
|
search_field->setFocus();
|
|
|
|
}
|
2020-04-06 03:12:17 +02:00
|
|
|
item_model->sort(tree_view->header()->sortIndicatorSection(),
|
|
|
|
tree_view->header()->sortIndicatorOrder());
|
2021-12-25 20:27:52 +01:00
|
|
|
|
|
|
|
emit PopulatingCompleted();
|
2015-09-01 06:35:33 +02:00
|
|
|
}
|
|
|
|
|
2016-12-15 10:55:03 +01:00
|
|
|
void GameList::PopupContextMenu(const QPoint& menu_location) {
|
|
|
|
QModelIndex item = tree_view->indexAt(menu_location);
|
|
|
|
if (!item.isValid())
|
|
|
|
return;
|
|
|
|
|
2019-05-03 19:21:57 +02:00
|
|
|
const auto selected = item.sibling(item.row(), 0);
|
2016-12-15 10:55:03 +01:00
|
|
|
QMenu context_menu;
|
2019-05-01 23:21:04 +02:00
|
|
|
switch (selected.data(GameListItem::TypeRole).value<GameListItemType>()) {
|
|
|
|
case GameListItemType::Game:
|
|
|
|
AddGamePopup(context_menu, selected.data(GameListItemPath::ProgramIdRole).toULongLong(),
|
|
|
|
selected.data(GameListItemPath::FullPathRole).toString().toStdString());
|
|
|
|
break;
|
|
|
|
case GameListItemType::CustomDir:
|
|
|
|
AddPermDirPopup(context_menu, selected);
|
|
|
|
AddCustomDirPopup(context_menu, selected);
|
|
|
|
break;
|
2019-05-05 03:07:09 +02:00
|
|
|
case GameListItemType::SdmcDir:
|
|
|
|
case GameListItemType::UserNandDir:
|
|
|
|
case GameListItemType::SysNandDir:
|
2019-05-01 23:21:04 +02:00
|
|
|
AddPermDirPopup(context_menu, selected);
|
|
|
|
break;
|
2021-04-10 11:09:01 +02:00
|
|
|
case GameListItemType::Favorites:
|
|
|
|
AddFavoritesPopup(context_menu);
|
|
|
|
break;
|
2019-10-05 01:35:06 +02:00
|
|
|
default:
|
|
|
|
break;
|
2019-05-01 23:21:04 +02:00
|
|
|
}
|
|
|
|
context_menu.exec(tree_view->viewport()->mapToGlobal(menu_location));
|
|
|
|
}
|
|
|
|
|
2020-09-23 17:20:10 +02:00
|
|
|
void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, const std::string& path) {
|
2021-04-10 11:09:01 +02:00
|
|
|
QAction* favorite = context_menu.addAction(tr("Favorite"));
|
|
|
|
context_menu.addSeparator();
|
2021-06-08 02:22:39 +02:00
|
|
|
QAction* start_game = context_menu.addAction(tr("Start Game"));
|
|
|
|
QAction* start_game_global =
|
|
|
|
context_menu.addAction(tr("Start Game without Custom Configuration"));
|
|
|
|
context_menu.addSeparator();
|
2016-12-15 10:55:03 +01:00
|
|
|
QAction* open_save_location = context_menu.addAction(tr("Open Save Data Location"));
|
2020-07-17 11:20:27 +02:00
|
|
|
QAction* open_mod_location = context_menu.addAction(tr("Open Mod Data Location"));
|
2019-02-08 09:05:51 +01:00
|
|
|
QAction* open_transferable_shader_cache =
|
2021-09-06 20:53:04 +02:00
|
|
|
context_menu.addAction(tr("Open Transferable Pipeline Cache"));
|
2018-09-20 04:09:23 +02:00
|
|
|
context_menu.addSeparator();
|
2020-07-17 11:20:27 +02:00
|
|
|
QMenu* remove_menu = context_menu.addMenu(tr("Remove"));
|
|
|
|
QAction* remove_update = remove_menu->addAction(tr("Remove Installed Update"));
|
|
|
|
QAction* remove_dlc = remove_menu->addAction(tr("Remove All Installed DLC"));
|
|
|
|
QAction* remove_custom_config = remove_menu->addAction(tr("Remove Custom Configuration"));
|
2021-09-06 20:53:04 +02:00
|
|
|
QAction* remove_gl_shader_cache = remove_menu->addAction(tr("Remove OpenGL Pipeline Cache"));
|
|
|
|
QAction* remove_vk_shader_cache = remove_menu->addAction(tr("Remove Vulkan Pipeline Cache"));
|
2020-07-17 11:20:27 +02:00
|
|
|
remove_menu->addSeparator();
|
2021-09-06 20:53:04 +02:00
|
|
|
QAction* remove_shader_cache = remove_menu->addAction(tr("Remove All Pipeline Caches"));
|
2020-07-17 11:20:27 +02:00
|
|
|
QAction* remove_all_content = remove_menu->addAction(tr("Remove All Installed Contents"));
|
2021-06-14 23:13:08 +02:00
|
|
|
QMenu* dump_romfs_menu = context_menu.addMenu(tr("Dump RomFS"));
|
|
|
|
QAction* dump_romfs = dump_romfs_menu->addAction(tr("Dump RomFS"));
|
|
|
|
QAction* dump_romfs_sdmc = dump_romfs_menu->addAction(tr("Dump RomFS to SDMC"));
|
2018-09-20 04:09:23 +02:00
|
|
|
QAction* copy_tid = context_menu.addAction(tr("Copy Title ID to Clipboard"));
|
2018-08-29 15:42:53 +02:00
|
|
|
QAction* navigate_to_gamedb_entry = context_menu.addAction(tr("Navigate to GameDB entry"));
|
2018-12-04 19:34:46 +01:00
|
|
|
context_menu.addSeparator();
|
|
|
|
QAction* properties = context_menu.addAction(tr("Properties"));
|
2018-08-29 15:42:53 +02:00
|
|
|
|
2021-04-10 11:09:01 +02:00
|
|
|
favorite->setVisible(program_id != 0);
|
|
|
|
favorite->setCheckable(true);
|
|
|
|
favorite->setChecked(UISettings::values.favorited_ids.contains(program_id));
|
2020-07-17 19:04:07 +02:00
|
|
|
open_save_location->setVisible(program_id != 0);
|
|
|
|
open_mod_location->setVisible(program_id != 0);
|
|
|
|
open_transferable_shader_cache->setVisible(program_id != 0);
|
|
|
|
remove_update->setVisible(program_id != 0);
|
|
|
|
remove_dlc->setVisible(program_id != 0);
|
2021-07-11 20:39:13 +02:00
|
|
|
remove_gl_shader_cache->setVisible(program_id != 0);
|
|
|
|
remove_vk_shader_cache->setVisible(program_id != 0);
|
2020-07-17 19:04:07 +02:00
|
|
|
remove_shader_cache->setVisible(program_id != 0);
|
|
|
|
remove_all_content->setVisible(program_id != 0);
|
2018-08-29 15:42:53 +02:00
|
|
|
auto it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
|
|
|
|
navigate_to_gamedb_entry->setVisible(it != compatibility_list.end() && program_id != 0);
|
|
|
|
|
2021-04-10 11:09:01 +02:00
|
|
|
connect(favorite, &QAction::triggered, [this, program_id]() { ToggleFavorite(program_id); });
|
2020-04-14 21:08:13 +02:00
|
|
|
connect(open_save_location, &QAction::triggered, [this, program_id, path]() {
|
2020-07-19 13:14:46 +02:00
|
|
|
emit OpenFolderRequested(program_id, GameListOpenTarget::SaveData, path);
|
2019-05-01 23:21:04 +02:00
|
|
|
});
|
2021-06-08 02:22:39 +02:00
|
|
|
connect(start_game, &QAction::triggered, [this, path]() {
|
2021-07-20 07:10:05 +02:00
|
|
|
emit BootGame(QString::fromStdString(path), 0, 0, StartGameType::Normal);
|
2021-06-08 02:22:39 +02:00
|
|
|
});
|
|
|
|
connect(start_game_global, &QAction::triggered, [this, path]() {
|
2021-07-20 07:10:05 +02:00
|
|
|
emit BootGame(QString::fromStdString(path), 0, 0, StartGameType::Global);
|
2021-06-08 02:22:39 +02:00
|
|
|
});
|
2020-07-17 11:20:27 +02:00
|
|
|
connect(open_mod_location, &QAction::triggered, [this, program_id, path]() {
|
2020-07-19 13:14:46 +02:00
|
|
|
emit OpenFolderRequested(program_id, GameListOpenTarget::ModData, path);
|
2019-05-01 23:21:04 +02:00
|
|
|
});
|
2019-02-08 09:05:51 +01:00
|
|
|
connect(open_transferable_shader_cache, &QAction::triggered,
|
2019-05-01 23:21:04 +02:00
|
|
|
[this, program_id]() { emit OpenTransferableShaderCacheRequested(program_id); });
|
2020-07-17 11:20:27 +02:00
|
|
|
connect(remove_all_content, &QAction::triggered, [this, program_id]() {
|
|
|
|
emit RemoveInstalledEntryRequested(program_id, InstalledEntryType::Game);
|
|
|
|
});
|
|
|
|
connect(remove_update, &QAction::triggered, [this, program_id]() {
|
|
|
|
emit RemoveInstalledEntryRequested(program_id, InstalledEntryType::Update);
|
|
|
|
});
|
|
|
|
connect(remove_dlc, &QAction::triggered, [this, program_id]() {
|
|
|
|
emit RemoveInstalledEntryRequested(program_id, InstalledEntryType::AddOnContent);
|
|
|
|
});
|
2021-07-11 20:39:13 +02:00
|
|
|
connect(remove_gl_shader_cache, &QAction::triggered, [this, program_id, path]() {
|
|
|
|
emit RemoveFileRequested(program_id, GameListRemoveTarget::GlShaderCache, path);
|
|
|
|
});
|
|
|
|
connect(remove_vk_shader_cache, &QAction::triggered, [this, program_id, path]() {
|
|
|
|
emit RemoveFileRequested(program_id, GameListRemoveTarget::VkShaderCache, path);
|
|
|
|
});
|
2021-05-26 02:06:06 +02:00
|
|
|
connect(remove_shader_cache, &QAction::triggered, [this, program_id, path]() {
|
2021-07-11 20:39:13 +02:00
|
|
|
emit RemoveFileRequested(program_id, GameListRemoveTarget::AllShaderCache, path);
|
2020-07-17 11:20:27 +02:00
|
|
|
});
|
2021-05-26 02:06:06 +02:00
|
|
|
connect(remove_custom_config, &QAction::triggered, [this, program_id, path]() {
|
|
|
|
emit RemoveFileRequested(program_id, GameListRemoveTarget::CustomConfiguration, path);
|
2020-07-17 11:20:27 +02:00
|
|
|
});
|
2021-06-14 23:13:08 +02:00
|
|
|
connect(dump_romfs, &QAction::triggered, [this, program_id, path]() {
|
|
|
|
emit DumpRomFSRequested(program_id, path, DumpRomFSTarget::Normal);
|
|
|
|
});
|
|
|
|
connect(dump_romfs_sdmc, &QAction::triggered, [this, program_id, path]() {
|
|
|
|
emit DumpRomFSRequested(program_id, path, DumpRomFSTarget::SDMC);
|
|
|
|
});
|
2019-05-01 23:21:04 +02:00
|
|
|
connect(copy_tid, &QAction::triggered,
|
|
|
|
[this, program_id]() { emit CopyTIDRequested(program_id); });
|
|
|
|
connect(navigate_to_gamedb_entry, &QAction::triggered, [this, program_id]() {
|
|
|
|
emit NavigateToGamedbEntryRequested(program_id, compatibility_list);
|
|
|
|
});
|
|
|
|
connect(properties, &QAction::triggered,
|
|
|
|
[this, path]() { emit OpenPerGameGeneralRequested(path); });
|
|
|
|
};
|
|
|
|
|
|
|
|
void GameList::AddCustomDirPopup(QMenu& context_menu, QModelIndex selected) {
|
|
|
|
UISettings::GameDir& game_dir =
|
2021-01-18 01:22:54 +01:00
|
|
|
UISettings::values.game_dirs[selected.data(GameListDir::GameDirRole).toInt()];
|
2019-05-01 23:21:04 +02:00
|
|
|
|
|
|
|
QAction* deep_scan = context_menu.addAction(tr("Scan Subfolders"));
|
|
|
|
QAction* delete_dir = context_menu.addAction(tr("Remove Game Directory"));
|
|
|
|
|
|
|
|
deep_scan->setCheckable(true);
|
|
|
|
deep_scan->setChecked(game_dir.deep_scan);
|
|
|
|
|
|
|
|
connect(deep_scan, &QAction::triggered, [this, &game_dir] {
|
|
|
|
game_dir.deep_scan = !game_dir.deep_scan;
|
|
|
|
PopulateAsync(UISettings::values.game_dirs);
|
|
|
|
});
|
|
|
|
connect(delete_dir, &QAction::triggered, [this, &game_dir, selected] {
|
|
|
|
UISettings::values.game_dirs.removeOne(game_dir);
|
|
|
|
item_model->invisibleRootItem()->removeRow(selected.row());
|
2021-04-29 23:56:30 +02:00
|
|
|
OnTextChanged(search_field->filterText());
|
2019-05-01 23:21:04 +02:00
|
|
|
});
|
|
|
|
}
|
2018-08-29 15:42:53 +02:00
|
|
|
|
2019-05-01 23:21:04 +02:00
|
|
|
void GameList::AddPermDirPopup(QMenu& context_menu, QModelIndex selected) {
|
2021-01-18 01:22:54 +01:00
|
|
|
const int game_dir_index = selected.data(GameListDir::GameDirRole).toInt();
|
2019-05-01 23:21:04 +02:00
|
|
|
|
2020-07-11 01:24:23 +02:00
|
|
|
QAction* move_up = context_menu.addAction(tr("\u25B2 Move Up"));
|
|
|
|
QAction* move_down = context_menu.addAction(tr("\u25bc Move Down"));
|
2019-05-01 23:21:04 +02:00
|
|
|
QAction* open_directory_location = context_menu.addAction(tr("Open Directory Location"));
|
|
|
|
|
2019-05-03 19:21:57 +02:00
|
|
|
const int row = selected.row();
|
2019-05-01 23:21:04 +02:00
|
|
|
|
2021-04-10 11:09:01 +02:00
|
|
|
move_up->setEnabled(row > 1);
|
2019-05-01 23:21:04 +02:00
|
|
|
move_down->setEnabled(row < item_model->rowCount() - 2);
|
|
|
|
|
2021-01-18 01:22:54 +01:00
|
|
|
connect(move_up, &QAction::triggered, [this, selected, row, game_dir_index] {
|
|
|
|
const int other_index = selected.sibling(row - 1, 0).data(GameListDir::GameDirRole).toInt();
|
|
|
|
// swap the items in the settings
|
|
|
|
std::swap(UISettings::values.game_dirs[game_dir_index],
|
|
|
|
UISettings::values.game_dirs[other_index]);
|
|
|
|
// swap the indexes held by the QVariants
|
|
|
|
item_model->setData(selected, QVariant(other_index), GameListDir::GameDirRole);
|
|
|
|
item_model->setData(selected.sibling(row - 1, 0), QVariant(game_dir_index),
|
|
|
|
GameListDir::GameDirRole);
|
2019-05-01 23:21:04 +02:00
|
|
|
// move the treeview items
|
|
|
|
QList<QStandardItem*> item = item_model->takeRow(row);
|
|
|
|
item_model->invisibleRootItem()->insertRow(row - 1, item);
|
2021-04-30 12:18:38 +02:00
|
|
|
tree_view->setExpanded(selected.sibling(row - 1, 0),
|
|
|
|
UISettings::values.game_dirs[other_index].expanded);
|
2019-05-01 23:21:04 +02:00
|
|
|
});
|
|
|
|
|
2021-01-18 01:22:54 +01:00
|
|
|
connect(move_down, &QAction::triggered, [this, selected, row, game_dir_index] {
|
|
|
|
const int other_index = selected.sibling(row + 1, 0).data(GameListDir::GameDirRole).toInt();
|
|
|
|
// swap the items in the settings
|
|
|
|
std::swap(UISettings::values.game_dirs[game_dir_index],
|
|
|
|
UISettings::values.game_dirs[other_index]);
|
|
|
|
// swap the indexes held by the QVariants
|
|
|
|
item_model->setData(selected, QVariant(other_index), GameListDir::GameDirRole);
|
|
|
|
item_model->setData(selected.sibling(row + 1, 0), QVariant(game_dir_index),
|
|
|
|
GameListDir::GameDirRole);
|
2019-05-01 23:21:04 +02:00
|
|
|
// move the treeview items
|
2019-05-03 19:21:57 +02:00
|
|
|
const QList<QStandardItem*> item = item_model->takeRow(row);
|
2019-05-01 23:21:04 +02:00
|
|
|
item_model->invisibleRootItem()->insertRow(row + 1, item);
|
2021-04-30 12:18:38 +02:00
|
|
|
tree_view->setExpanded(selected.sibling(row + 1, 0),
|
|
|
|
UISettings::values.game_dirs[other_index].expanded);
|
2019-05-01 23:21:04 +02:00
|
|
|
});
|
|
|
|
|
2021-01-18 01:22:54 +01:00
|
|
|
connect(open_directory_location, &QAction::triggered, [this, game_dir_index] {
|
|
|
|
emit OpenDirectory(UISettings::values.game_dirs[game_dir_index].path);
|
|
|
|
});
|
2016-12-15 10:55:03 +01:00
|
|
|
}
|
|
|
|
|
2021-04-10 11:09:01 +02:00
|
|
|
void GameList::AddFavoritesPopup(QMenu& context_menu) {
|
2021-06-02 16:17:01 +02:00
|
|
|
QAction* clear = context_menu.addAction(tr("Clear"));
|
2021-04-10 11:09:01 +02:00
|
|
|
|
2021-06-02 16:17:01 +02:00
|
|
|
connect(clear, &QAction::triggered, [this] {
|
2021-04-10 11:09:01 +02:00
|
|
|
for (const auto id : UISettings::values.favorited_ids) {
|
|
|
|
RemoveFavorite(id);
|
|
|
|
}
|
|
|
|
UISettings::values.favorited_ids.clear();
|
|
|
|
tree_view->setRowHidden(0, item_model->invisibleRootItem()->index(), true);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2018-08-29 15:42:53 +02:00
|
|
|
void GameList::LoadCompatibilityList() {
|
2019-05-20 21:18:36 +02:00
|
|
|
QFile compat_list{QStringLiteral(":compatibility_list/compatibility_list.json")};
|
2018-08-29 15:42:53 +02:00
|
|
|
|
|
|
|
if (!compat_list.open(QFile::ReadOnly | QFile::Text)) {
|
|
|
|
LOG_ERROR(Frontend, "Unable to open game compatibility list");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (compat_list.size() == 0) {
|
|
|
|
LOG_WARNING(Frontend, "Game compatibility list is empty");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const QByteArray content = compat_list.readAll();
|
|
|
|
if (content.isEmpty()) {
|
|
|
|
LOG_ERROR(Frontend, "Unable to completely read game compatibility list");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-05-20 21:18:36 +02:00
|
|
|
const QJsonDocument json = QJsonDocument::fromJson(content);
|
|
|
|
const QJsonArray arr = json.array();
|
2018-08-29 15:42:53 +02:00
|
|
|
|
2019-05-20 21:18:36 +02:00
|
|
|
for (const QJsonValue value : arr) {
|
|
|
|
const QJsonObject game = value.toObject();
|
|
|
|
const QString compatibility_key = QStringLiteral("compatibility");
|
2018-08-29 15:42:53 +02:00
|
|
|
|
2019-05-20 21:18:36 +02:00
|
|
|
if (!game.contains(compatibility_key) || !game[compatibility_key].isDouble()) {
|
|
|
|
continue;
|
|
|
|
}
|
2018-08-29 15:42:53 +02:00
|
|
|
|
2019-05-20 21:18:36 +02:00
|
|
|
const int compatibility = game[compatibility_key].toInt();
|
|
|
|
const QString directory = game[QStringLiteral("directory")].toString();
|
|
|
|
const QJsonArray ids = game[QStringLiteral("releases")].toArray();
|
|
|
|
|
|
|
|
for (const QJsonValue id_ref : ids) {
|
|
|
|
const QJsonObject id_object = id_ref.toObject();
|
|
|
|
const QString id = id_object[QStringLiteral("id")].toString();
|
|
|
|
|
|
|
|
compatibility_list.emplace(id.toUpper().toStdString(),
|
|
|
|
std::make_pair(QString::number(compatibility), directory));
|
2018-08-29 15:42:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 20:27:52 +01:00
|
|
|
QStandardItemModel* GameList::GetModel() const {
|
|
|
|
return item_model;
|
|
|
|
}
|
|
|
|
|
2019-06-08 00:51:58 +02:00
|
|
|
void GameList::PopulateAsync(QVector<UISettings::GameDir>& game_dirs) {
|
2015-09-01 06:35:33 +02:00
|
|
|
tree_view->setEnabled(false);
|
2018-11-02 01:27:12 +01:00
|
|
|
|
|
|
|
// Update the columns in case UISettings has changed
|
2021-06-02 07:27:08 +02:00
|
|
|
tree_view->setColumnHidden(COLUMN_ADD_ONS, !UISettings::values.show_add_ons);
|
2018-11-02 01:27:12 +01:00
|
|
|
|
2015-09-01 06:35:33 +02:00
|
|
|
// Delete any rows that might already exist if we're repopulating
|
|
|
|
item_model->removeRows(0, item_model->rowCount());
|
2019-05-01 23:21:04 +02:00
|
|
|
search_field->clear();
|
2015-09-01 06:35:33 +02:00
|
|
|
|
|
|
|
emit ShouldCancelWorker();
|
2017-02-23 22:29:00 +01:00
|
|
|
|
2021-07-30 15:32:26 +02:00
|
|
|
GameListWorker* worker =
|
|
|
|
new GameListWorker(vfs, provider, game_dirs, compatibility_list, system);
|
2015-09-01 06:35:33 +02:00
|
|
|
|
2016-12-11 03:20:34 +01:00
|
|
|
connect(worker, &GameListWorker::EntryReady, this, &GameList::AddEntry, Qt::QueuedConnection);
|
2019-05-01 23:21:04 +02:00
|
|
|
connect(worker, &GameListWorker::DirEntryReady, this, &GameList::AddDirEntry,
|
|
|
|
Qt::QueuedConnection);
|
2016-12-11 03:20:34 +01:00
|
|
|
connect(worker, &GameListWorker::Finished, this, &GameList::DonePopulating,
|
|
|
|
Qt::QueuedConnection);
|
2019-05-01 23:21:04 +02:00
|
|
|
// Use DirectConnection here because worker->Cancel() is thread-safe and we want it to
|
|
|
|
// cancel without delay.
|
2016-12-11 03:20:34 +01:00
|
|
|
connect(this, &GameList::ShouldCancelWorker, worker, &GameListWorker::Cancel,
|
|
|
|
Qt::DirectConnection);
|
2015-09-01 06:35:33 +02:00
|
|
|
|
|
|
|
QThreadPool::globalInstance()->start(worker);
|
|
|
|
current_worker = std::move(worker);
|
2015-09-07 08:51:57 +02:00
|
|
|
}
|
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
void GameList::SaveInterfaceLayout() {
|
2016-01-24 21:23:55 +01:00
|
|
|
UISettings::values.gamelist_header_state = tree_view->header()->saveState();
|
2015-09-07 08:51:57 +02:00
|
|
|
}
|
|
|
|
|
2016-09-18 02:38:01 +02:00
|
|
|
void GameList::LoadInterfaceLayout() {
|
2020-09-23 17:20:10 +02:00
|
|
|
auto* header = tree_view->header();
|
|
|
|
|
|
|
|
if (header->restoreState(UISettings::values.gamelist_header_state)) {
|
|
|
|
return;
|
2016-04-30 01:40:54 +02:00
|
|
|
}
|
2020-09-23 17:20:10 +02:00
|
|
|
|
|
|
|
// We are using the name column to display icons and titles
|
|
|
|
// so make it as large as possible as default.
|
|
|
|
header->resizeSection(COLUMN_NAME, header->width());
|
2015-09-01 06:35:33 +02:00
|
|
|
}
|
|
|
|
|
2019-05-20 21:18:36 +02:00
|
|
|
const QStringList GameList::supported_file_extensions = {
|
|
|
|
QStringLiteral("nso"), QStringLiteral("nro"), QStringLiteral("nca"),
|
2019-06-05 06:33:00 +02:00
|
|
|
QStringLiteral("xci"), QStringLiteral("nsp"), QStringLiteral("kip")};
|
2017-02-12 21:28:56 +01:00
|
|
|
|
2017-02-23 22:29:00 +01:00
|
|
|
void GameList::RefreshGameDirectory() {
|
2019-05-01 23:21:04 +02:00
|
|
|
if (!UISettings::values.game_dirs.isEmpty() && current_worker != nullptr) {
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_INFO(Frontend, "Change detected in the games directory. Reloading game list.");
|
2019-05-01 23:21:04 +02:00
|
|
|
PopulateAsync(UISettings::values.game_dirs);
|
2017-02-23 22:29:00 +01:00
|
|
|
}
|
|
|
|
}
|
2019-05-01 23:21:04 +02:00
|
|
|
|
2021-04-10 11:09:01 +02:00
|
|
|
void GameList::ToggleFavorite(u64 program_id) {
|
|
|
|
if (!UISettings::values.favorited_ids.contains(program_id)) {
|
|
|
|
tree_view->setRowHidden(0, item_model->invisibleRootItem()->index(),
|
2021-04-29 23:56:30 +02:00
|
|
|
!search_field->filterText().isEmpty());
|
2021-04-10 11:09:01 +02:00
|
|
|
UISettings::values.favorited_ids.append(program_id);
|
|
|
|
AddFavorite(program_id);
|
|
|
|
item_model->sort(tree_view->header()->sortIndicatorSection(),
|
|
|
|
tree_view->header()->sortIndicatorOrder());
|
|
|
|
} else {
|
|
|
|
UISettings::values.favorited_ids.removeOne(program_id);
|
|
|
|
RemoveFavorite(program_id);
|
|
|
|
if (UISettings::values.favorited_ids.size() == 0) {
|
|
|
|
tree_view->setRowHidden(0, item_model->invisibleRootItem()->index(), true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GameList::AddFavorite(u64 program_id) {
|
|
|
|
auto* favorites_row = item_model->item(0);
|
|
|
|
|
|
|
|
for (int i = 1; i < item_model->rowCount() - 1; i++) {
|
|
|
|
const auto* folder = item_model->item(i);
|
|
|
|
for (int j = 0; j < folder->rowCount(); j++) {
|
|
|
|
if (folder->child(j)->data(GameListItemPath::ProgramIdRole).toULongLong() ==
|
|
|
|
program_id) {
|
|
|
|
QList<QStandardItem*> list;
|
2021-06-02 07:27:08 +02:00
|
|
|
for (int k = 0; k < COLUMN_COUNT; k++) {
|
2021-04-10 11:09:01 +02:00
|
|
|
list.append(folder->child(j, k)->clone());
|
|
|
|
}
|
|
|
|
list[0]->setData(folder->child(j)->data(GameListItem::SortRole),
|
|
|
|
GameListItem::SortRole);
|
|
|
|
list[0]->setText(folder->child(j)->data(Qt::DisplayRole).toString());
|
|
|
|
|
|
|
|
favorites_row->appendRow(list);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GameList::RemoveFavorite(u64 program_id) {
|
|
|
|
auto* favorites_row = item_model->item(0);
|
|
|
|
|
|
|
|
for (int i = 0; i < favorites_row->rowCount(); i++) {
|
|
|
|
const auto* game = favorites_row->child(i);
|
|
|
|
if (game->data(GameListItemPath::ProgramIdRole).toULongLong() == program_id) {
|
|
|
|
favorites_row->removeRow(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-01 23:21:04 +02:00
|
|
|
GameListPlaceholder::GameListPlaceholder(GMainWindow* parent) : QWidget{parent} {
|
2019-05-05 01:52:17 +02:00
|
|
|
connect(parent, &GMainWindow::UpdateThemedIcons, this,
|
2019-05-01 23:21:04 +02:00
|
|
|
&GameListPlaceholder::onUpdateThemedIcons);
|
|
|
|
|
|
|
|
layout = new QVBoxLayout;
|
|
|
|
image = new QLabel;
|
|
|
|
text = new QLabel;
|
|
|
|
layout->setAlignment(Qt::AlignCenter);
|
|
|
|
image->setPixmap(QIcon::fromTheme(QStringLiteral("plus_folder")).pixmap(200));
|
|
|
|
|
2022-06-11 04:17:18 +02:00
|
|
|
RetranslateUI();
|
2019-05-01 23:21:04 +02:00
|
|
|
QFont font = text->font();
|
|
|
|
font.setPointSize(20);
|
|
|
|
text->setFont(font);
|
|
|
|
text->setAlignment(Qt::AlignHCenter);
|
|
|
|
image->setAlignment(Qt::AlignHCenter);
|
|
|
|
|
|
|
|
layout->addWidget(image);
|
|
|
|
layout->addWidget(text);
|
|
|
|
setLayout(layout);
|
|
|
|
}
|
|
|
|
|
|
|
|
GameListPlaceholder::~GameListPlaceholder() = default;
|
|
|
|
|
|
|
|
void GameListPlaceholder::onUpdateThemedIcons() {
|
|
|
|
image->setPixmap(QIcon::fromTheme(QStringLiteral("plus_folder")).pixmap(200));
|
|
|
|
}
|
|
|
|
|
|
|
|
void GameListPlaceholder::mouseDoubleClickEvent(QMouseEvent* event) {
|
|
|
|
emit GameListPlaceholder::AddDirectory();
|
|
|
|
}
|
2022-06-11 04:17:18 +02:00
|
|
|
|
|
|
|
void GameListPlaceholder::changeEvent(QEvent* event) {
|
|
|
|
if (event->type() == QEvent::LanguageChange) {
|
|
|
|
RetranslateUI();
|
|
|
|
}
|
|
|
|
|
|
|
|
QWidget::changeEvent(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
void GameListPlaceholder::RetranslateUI() {
|
|
|
|
text->setText(tr("Double-click to add a new folder to the game list"));
|
|
|
|
}
|