2015-09-01 10:05:33 +05:30
|
|
|
// Copyright 2015 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2017-02-13 01:58:56 +05:30
|
|
|
#include <QFileInfo>
|
2015-09-01 10:05:33 +05:30
|
|
|
#include <QHeaderView>
|
2016-12-15 15:25:03 +05:30
|
|
|
#include <QMenu>
|
2015-09-01 10:05:33 +05:30
|
|
|
#include <QThreadPool>
|
|
|
|
#include <QVBoxLayout>
|
|
|
|
#include "common/common_paths.h"
|
|
|
|
#include "common/logging/log.h"
|
|
|
|
#include "common/string_util.h"
|
2016-09-20 20:51:23 +05:30
|
|
|
#include "core/loader/loader.h"
|
2016-09-21 12:22:38 +05:30
|
|
|
#include "game_list.h"
|
2016-09-20 20:51:23 +05:30
|
|
|
#include "game_list_p.h"
|
|
|
|
#include "ui_settings.h"
|
2015-09-01 10:05:33 +05:30
|
|
|
|
2016-12-11 07:37:16 +05:30
|
|
|
GameList::GameList(QWidget* parent) : QWidget{parent} {
|
2015-09-01 10:05:33 +05:30
|
|
|
QVBoxLayout* layout = new QVBoxLayout;
|
|
|
|
|
|
|
|
tree_view = new QTreeView;
|
|
|
|
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);
|
|
|
|
tree_view->setUniformRowHeights(true);
|
2016-12-15 15:25:03 +05:30
|
|
|
tree_view->setContextMenuPolicy(Qt::CustomContextMenu);
|
2015-09-01 10:05:33 +05:30
|
|
|
|
|
|
|
item_model->insertColumns(0, COLUMN_COUNT);
|
|
|
|
item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, "Name");
|
2016-04-14 02:34:05 +05:30
|
|
|
item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, "File type");
|
2015-09-01 10:05:33 +05:30
|
|
|
item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, "Size");
|
|
|
|
|
2016-12-11 07:50:34 +05:30
|
|
|
connect(tree_view, &QTreeView::activated, this, &GameList::ValidateEntry);
|
2016-12-15 15:25:03 +05:30
|
|
|
connect(tree_view, &QTreeView::customContextMenuRequested, this, &GameList::PopupContextMenu);
|
2017-02-24 02:59:00 +05:30
|
|
|
connect(&watcher, &QFileSystemWatcher::directoryChanged, this, &GameList::RefreshGameDirectory);
|
2015-09-01 10:05:33 +05:30
|
|
|
|
2016-09-18 06:08:01 +05:30
|
|
|
// We must register all custom types with the Qt Automoc system so that we are able to use it
|
2016-12-15 15:25:03 +05:30
|
|
|
// with signals/slots. In this case, QList falls under the umbrells of custom types.
|
2015-09-01 10:05:33 +05:30
|
|
|
qRegisterMetaType<QList<QStandardItem*>>("QList<QStandardItem*>");
|
|
|
|
|
2017-02-19 01:39:14 +05:30
|
|
|
layout->setContentsMargins(0, 0, 0, 0);
|
2015-09-01 10:05:33 +05:30
|
|
|
layout->addWidget(tree_view);
|
|
|
|
setLayout(layout);
|
|
|
|
}
|
|
|
|
|
2016-09-18 06:08:01 +05:30
|
|
|
GameList::~GameList() {
|
2015-09-01 10:05:33 +05:30
|
|
|
emit ShouldCancelWorker();
|
|
|
|
}
|
|
|
|
|
2016-12-11 07:57:38 +05:30
|
|
|
void GameList::AddEntry(const QList<QStandardItem*>& entry_items) {
|
2015-09-01 10:05:33 +05:30
|
|
|
item_model->invisibleRootItem()->appendRow(entry_items);
|
|
|
|
}
|
|
|
|
|
2016-09-18 06:08:01 +05:30
|
|
|
void GameList::ValidateEntry(const QModelIndex& item) {
|
2015-09-01 10:05:33 +05:30
|
|
|
// We don't care about the individual QStandardItem that was selected, but its row.
|
|
|
|
int row = item_model->itemFromIndex(item)->row();
|
|
|
|
QStandardItem* child_file = item_model->invisibleRootItem()->child(row, COLUMN_NAME);
|
|
|
|
QString file_path = child_file->data(GameListItemPath::FullPathRole).toString();
|
|
|
|
|
|
|
|
if (file_path.isEmpty())
|
|
|
|
return;
|
2016-03-31 16:28:37 +05:30
|
|
|
std::string std_file_path(file_path.toStdString());
|
2015-09-01 10:05:33 +05:30
|
|
|
if (!FileUtil::Exists(std_file_path) || FileUtil::IsDirectory(std_file_path))
|
|
|
|
return;
|
|
|
|
emit GameChosen(file_path);
|
|
|
|
}
|
|
|
|
|
2016-09-18 06:08:01 +05:30
|
|
|
void GameList::DonePopulating() {
|
2015-09-01 10:05:33 +05:30
|
|
|
tree_view->setEnabled(true);
|
|
|
|
}
|
|
|
|
|
2016-12-15 15:25:03 +05:30
|
|
|
void GameList::PopupContextMenu(const QPoint& menu_location) {
|
|
|
|
QModelIndex item = tree_view->indexAt(menu_location);
|
|
|
|
if (!item.isValid())
|
|
|
|
return;
|
|
|
|
|
|
|
|
int row = item_model->itemFromIndex(item)->row();
|
|
|
|
QStandardItem* child_file = item_model->invisibleRootItem()->child(row, COLUMN_NAME);
|
|
|
|
u64 program_id = child_file->data(GameListItemPath::ProgramIdRole).toULongLong();
|
|
|
|
|
|
|
|
QMenu context_menu;
|
|
|
|
QAction* open_save_location = context_menu.addAction(tr("Open Save Data Location"));
|
|
|
|
open_save_location->setEnabled(program_id != 0);
|
|
|
|
connect(open_save_location, &QAction::triggered,
|
|
|
|
[&]() { emit OpenSaveFolderRequested(program_id); });
|
|
|
|
context_menu.exec(tree_view->viewport()->mapToGlobal(menu_location));
|
|
|
|
}
|
|
|
|
|
2016-09-18 06:08:01 +05:30
|
|
|
void GameList::PopulateAsync(const QString& dir_path, bool deep_scan) {
|
|
|
|
if (!FileUtil::Exists(dir_path.toStdString()) ||
|
|
|
|
!FileUtil::IsDirectory(dir_path.toStdString())) {
|
2015-10-20 23:28:23 +05:30
|
|
|
LOG_ERROR(Frontend, "Could not find game list folder at %s", dir_path.toLocal8Bit().data());
|
2015-09-01 10:05:33 +05:30
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
tree_view->setEnabled(false);
|
|
|
|
// Delete any rows that might already exist if we're repopulating
|
|
|
|
item_model->removeRows(0, item_model->rowCount());
|
|
|
|
|
|
|
|
emit ShouldCancelWorker();
|
2017-02-24 02:59:00 +05:30
|
|
|
|
|
|
|
auto watch_dirs = watcher.directories();
|
|
|
|
if (!watch_dirs.isEmpty()) {
|
|
|
|
watcher.removePaths(watch_dirs);
|
|
|
|
}
|
|
|
|
UpdateWatcherList(dir_path.toStdString(), deep_scan ? 256 : 0);
|
2015-09-01 10:05:33 +05:30
|
|
|
GameListWorker* worker = new GameListWorker(dir_path, deep_scan);
|
|
|
|
|
2016-12-11 07:50:34 +05:30
|
|
|
connect(worker, &GameListWorker::EntryReady, this, &GameList::AddEntry, Qt::QueuedConnection);
|
|
|
|
connect(worker, &GameListWorker::Finished, this, &GameList::DonePopulating,
|
|
|
|
Qt::QueuedConnection);
|
2016-09-18 06:08:01 +05:30
|
|
|
// Use DirectConnection here because worker->Cancel() is thread-safe and we want it to cancel
|
|
|
|
// without delay.
|
2016-12-11 07:50:34 +05:30
|
|
|
connect(this, &GameList::ShouldCancelWorker, worker, &GameListWorker::Cancel,
|
|
|
|
Qt::DirectConnection);
|
2015-09-01 10:05:33 +05:30
|
|
|
|
|
|
|
QThreadPool::globalInstance()->start(worker);
|
|
|
|
current_worker = std::move(worker);
|
2015-09-07 12:21:57 +05:30
|
|
|
}
|
|
|
|
|
2016-09-18 06:08:01 +05:30
|
|
|
void GameList::SaveInterfaceLayout() {
|
2016-01-25 01:53:55 +05:30
|
|
|
UISettings::values.gamelist_header_state = tree_view->header()->saveState();
|
2015-09-07 12:21:57 +05:30
|
|
|
}
|
|
|
|
|
2016-09-18 06:08:01 +05:30
|
|
|
void GameList::LoadInterfaceLayout() {
|
2015-09-07 12:21:57 +05:30
|
|
|
auto header = tree_view->header();
|
2016-04-30 05:10:54 +05:30
|
|
|
if (!header->restoreState(UISettings::values.gamelist_header_state)) {
|
|
|
|
// 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-07 12:21:57 +05:30
|
|
|
|
|
|
|
item_model->sort(header->sortIndicatorSection(), header->sortIndicatorOrder());
|
2015-09-01 10:05:33 +05:30
|
|
|
}
|
|
|
|
|
2017-02-13 01:58:56 +05:30
|
|
|
const QStringList GameList::supported_file_extensions = {"3ds", "3dsx", "elf", "axf",
|
|
|
|
"cci", "cxi", "app"};
|
|
|
|
|
|
|
|
static bool HasSupportedFileExtension(const std::string& file_name) {
|
|
|
|
QFileInfo file = QFileInfo(file_name.c_str());
|
2017-02-14 08:32:53 +05:30
|
|
|
return GameList::supported_file_extensions.contains(file.suffix(), Qt::CaseInsensitive);
|
2017-02-13 01:58:56 +05:30
|
|
|
}
|
|
|
|
|
2017-02-24 02:59:00 +05:30
|
|
|
void GameList::RefreshGameDirectory() {
|
|
|
|
if (!UISettings::values.gamedir.isEmpty() && current_worker != nullptr) {
|
|
|
|
LOG_INFO(Frontend, "Change detected in the games directory. Reloading game list.");
|
|
|
|
PopulateAsync(UISettings::values.gamedir, UISettings::values.gamedir_deepscan);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds the game list folder to the QFileSystemWatcher to check for updates.
|
|
|
|
*
|
|
|
|
* The file watcher will fire off an update to the game list when a change is detected in the game
|
|
|
|
* list folder.
|
|
|
|
*
|
|
|
|
* Notice: This method is run on the UI thread because QFileSystemWatcher is not thread safe and
|
|
|
|
* this function is fast enough to not stall the UI thread. If performance is an issue, it should
|
|
|
|
* be moved to another thread and properly locked to prevent concurrency issues.
|
|
|
|
*
|
|
|
|
* @param dir folder to check for changes in
|
|
|
|
* @param recursion 0 if recursion is disabled. Any positive number passed to this will add each
|
|
|
|
* directory recursively to the watcher and will update the file list if any of the folders
|
|
|
|
* change. The number determines how deep the recursion should traverse.
|
|
|
|
*/
|
|
|
|
void GameList::UpdateWatcherList(const std::string& dir, unsigned int recursion) {
|
|
|
|
const auto callback = [this, recursion](unsigned* num_entries_out, const std::string& directory,
|
|
|
|
const std::string& virtual_name) -> bool {
|
|
|
|
std::string physical_name = directory + DIR_SEP + virtual_name;
|
|
|
|
|
|
|
|
if (FileUtil::IsDirectory(physical_name)) {
|
|
|
|
UpdateWatcherList(physical_name, recursion - 1);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
|
|
|
|
watcher.addPath(QString::fromStdString(dir));
|
|
|
|
if (recursion > 0) {
|
|
|
|
FileUtil::ForeachDirectoryEntry(nullptr, dir, callback);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-18 06:08:01 +05:30
|
|
|
void GameListWorker::AddFstEntriesToGameList(const std::string& dir_path, unsigned int recursion) {
|
|
|
|
const auto callback = [this, recursion](unsigned* num_entries_out, const std::string& directory,
|
2016-06-19 12:39:16 +05:30
|
|
|
const std::string& virtual_name) -> bool {
|
2015-09-01 10:05:33 +05:30
|
|
|
std::string physical_name = directory + DIR_SEP + virtual_name;
|
|
|
|
|
|
|
|
if (stop_processing)
|
2015-11-26 14:04:26 +05:30
|
|
|
return false; // Breaks the callback loop.
|
2015-09-01 10:05:33 +05:30
|
|
|
|
2017-02-13 01:58:56 +05:30
|
|
|
if (!FileUtil::IsDirectory(physical_name) && HasSupportedFileExtension(physical_name)) {
|
2016-05-19 02:36:50 +05:30
|
|
|
std::unique_ptr<Loader::AppLoader> loader = Loader::GetLoader(physical_name);
|
|
|
|
if (!loader)
|
2015-11-26 14:04:26 +05:30
|
|
|
return true;
|
2015-09-01 10:05:33 +05:30
|
|
|
|
2016-04-14 02:34:05 +05:30
|
|
|
std::vector<u8> smdh;
|
2016-05-19 02:36:50 +05:30
|
|
|
loader->ReadIcon(smdh);
|
2016-04-14 02:34:05 +05:30
|
|
|
|
2016-12-15 15:25:03 +05:30
|
|
|
u64 program_id = 0;
|
|
|
|
loader->ReadProgramId(program_id);
|
|
|
|
|
2015-09-01 10:05:33 +05:30
|
|
|
emit EntryReady({
|
2016-12-15 15:25:03 +05:30
|
|
|
new GameListItemPath(QString::fromStdString(physical_name), smdh, program_id),
|
2016-09-18 06:08:01 +05:30
|
|
|
new GameListItem(
|
|
|
|
QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType()))),
|
2015-09-01 10:05:33 +05:30
|
|
|
new GameListItemSize(FileUtil::GetSize(physical_name)),
|
|
|
|
});
|
2016-06-01 11:34:58 +05:30
|
|
|
} else if (recursion > 0) {
|
|
|
|
AddFstEntriesToGameList(physical_name, recursion - 1);
|
2015-09-01 10:05:33 +05:30
|
|
|
}
|
|
|
|
|
2015-11-26 14:04:26 +05:30
|
|
|
return true;
|
2015-09-01 10:05:33 +05:30
|
|
|
};
|
2015-11-26 14:04:26 +05:30
|
|
|
|
|
|
|
FileUtil::ForeachDirectoryEntry(nullptr, dir_path, callback);
|
2015-09-01 10:05:33 +05:30
|
|
|
}
|
|
|
|
|
2016-09-18 06:08:01 +05:30
|
|
|
void GameListWorker::run() {
|
2015-09-01 10:05:33 +05:30
|
|
|
stop_processing = false;
|
2015-09-06 12:29:04 +05:30
|
|
|
AddFstEntriesToGameList(dir_path.toStdString(), deep_scan ? 256 : 0);
|
2015-09-01 10:05:33 +05:30
|
|
|
emit Finished();
|
|
|
|
}
|
|
|
|
|
2016-09-18 06:08:01 +05:30
|
|
|
void GameListWorker::Cancel() {
|
2017-02-24 02:59:00 +05:30
|
|
|
this->disconnect();
|
2015-09-01 10:05:33 +05:30
|
|
|
stop_processing = true;
|
|
|
|
}
|