mirror of https://github.com/PCSX2/pcsx2.git
608 lines
17 KiB
C++
608 lines
17 KiB
C++
// SPDX-FileCopyrightText: 2002-2024 PCSX2 Dev Team
|
|
// SPDX-License-Identifier: GPL-3.0+
|
|
|
|
#include "GameListModel.h"
|
|
#include "QtHost.h"
|
|
#include "QtUtils.h"
|
|
#include "common/FileSystem.h"
|
|
#include "common/Path.h"
|
|
#include "common/StringUtil.h"
|
|
#include "fmt/format.h"
|
|
#include <QtCore/QDate>
|
|
#include <QtCore/QDateTime>
|
|
#include <QtCore/QFuture>
|
|
#include <QtCore/QFutureWatcher>
|
|
#include <QtConcurrent/QtConcurrent>
|
|
#include <QtGui/QGuiApplication>
|
|
#include <QtGui/QIcon>
|
|
#include <QtGui/QPainter>
|
|
|
|
static constexpr std::array<const char*, GameListModel::Column_Count> s_column_names = {
|
|
{"Type", "Code", "Title", "File Title", "CRC", "Time Played", "Last Played", "Size", "Region", "Compatibility", "Cover"}};
|
|
|
|
static constexpr int COVER_ART_WIDTH = 350;
|
|
static constexpr int COVER_ART_HEIGHT = 512;
|
|
static constexpr int COVER_ART_SPACING = 32;
|
|
static constexpr int MIN_COVER_CACHE_SIZE = 256;
|
|
|
|
static int DPRScale(int size, float dpr)
|
|
{
|
|
return static_cast<int>(static_cast<float>(size) * dpr);
|
|
}
|
|
|
|
static int DPRUnscale(int size, float dpr)
|
|
{
|
|
return static_cast<int>(static_cast<float>(size) / dpr);
|
|
}
|
|
|
|
static void resizeAndPadPixmap(QPixmap* pm, int expected_width, int expected_height, float dpr)
|
|
{
|
|
const int dpr_expected_width = DPRScale(expected_width, dpr);
|
|
const int dpr_expected_height = DPRScale(expected_height, dpr);
|
|
if (pm->width() == dpr_expected_width && pm->height() == dpr_expected_height)
|
|
return;
|
|
|
|
*pm = pm->scaled(dpr_expected_width, dpr_expected_height, Qt::KeepAspectRatio, Qt::SmoothTransformation);
|
|
if (pm->width() == dpr_expected_width && pm->height() == dpr_expected_height)
|
|
return;
|
|
|
|
// QPainter works in unscaled coordinates.
|
|
int xoffs = 0;
|
|
int yoffs = 0;
|
|
if (pm->width() < dpr_expected_width)
|
|
xoffs = DPRUnscale((dpr_expected_width - pm->width()) / 2, dpr);
|
|
if (pm->height() < dpr_expected_height)
|
|
yoffs = DPRUnscale((dpr_expected_height - pm->height()) / 2, dpr);
|
|
|
|
QPixmap padded_image(dpr_expected_width, dpr_expected_height);
|
|
padded_image.setDevicePixelRatio(dpr);
|
|
padded_image.fill(Qt::transparent);
|
|
QPainter painter;
|
|
if (painter.begin(&padded_image))
|
|
{
|
|
painter.setCompositionMode(QPainter::CompositionMode_Source);
|
|
painter.drawPixmap(xoffs, yoffs, *pm);
|
|
painter.setCompositionMode(QPainter::CompositionMode_Destination);
|
|
painter.fillRect(padded_image.rect(), QColor(0, 0, 0, 0));
|
|
painter.end();
|
|
}
|
|
|
|
*pm = padded_image;
|
|
}
|
|
|
|
static QPixmap createPlaceholderImage(const QPixmap& placeholder_pixmap, int width, int height, float scale,
|
|
const std::string& title)
|
|
{
|
|
const float dpr = qApp->devicePixelRatio();
|
|
QPixmap pm(placeholder_pixmap.copy());
|
|
pm.setDevicePixelRatio(dpr);
|
|
if (pm.isNull())
|
|
return QPixmap();
|
|
|
|
resizeAndPadPixmap(&pm, width, height, dpr);
|
|
QPainter painter;
|
|
if (painter.begin(&pm))
|
|
{
|
|
QFont font;
|
|
font.setPointSize(std::max(static_cast<int>(32.0f * scale), 1));
|
|
painter.setFont(font);
|
|
painter.setPen(Qt::white);
|
|
|
|
const QRect text_rc(0, 0, static_cast<int>(static_cast<float>(width)),
|
|
static_cast<int>(static_cast<float>(height)));
|
|
painter.drawText(text_rc, Qt::AlignCenter | Qt::TextWordWrap, QString::fromStdString(title));
|
|
painter.end();
|
|
}
|
|
|
|
return pm;
|
|
}
|
|
|
|
std::optional<GameListModel::Column> GameListModel::getColumnIdForName(std::string_view name)
|
|
{
|
|
for (int column = 0; column < Column_Count; column++)
|
|
{
|
|
if (name == s_column_names[column])
|
|
return static_cast<Column>(column);
|
|
}
|
|
|
|
return std::nullopt;
|
|
}
|
|
|
|
const char* GameListModel::getColumnName(Column col)
|
|
{
|
|
return s_column_names[static_cast<int>(col)];
|
|
}
|
|
|
|
GameListModel::GameListModel(float cover_scale, bool show_cover_titles, QObject* parent /* = nullptr */)
|
|
: QAbstractTableModel(parent)
|
|
, m_show_titles_for_covers(show_cover_titles)
|
|
{
|
|
loadSettings();
|
|
loadCommonImages();
|
|
setCoverScale(cover_scale);
|
|
setColumnDisplayNames();
|
|
}
|
|
GameListModel::~GameListModel() = default;
|
|
|
|
void GameListModel::reloadThemeSpecificImages()
|
|
{
|
|
loadThemeSpecificImages();
|
|
refresh();
|
|
}
|
|
|
|
void GameListModel::setCoverScale(float scale)
|
|
{
|
|
if (m_cover_scale == scale)
|
|
return;
|
|
|
|
m_cover_pixmap_cache.Clear();
|
|
m_cover_scale = scale;
|
|
m_cover_scale_counter.fetch_add(1, std::memory_order_release);
|
|
m_loading_pixmap = QPixmap(getCoverArtWidth(), getCoverArtHeight());
|
|
m_loading_pixmap.fill(QColor(0, 0, 0, 0));
|
|
|
|
emit coverScaleChanged();
|
|
}
|
|
|
|
void GameListModel::refreshCovers()
|
|
{
|
|
m_cover_pixmap_cache.Clear();
|
|
refresh();
|
|
}
|
|
|
|
void GameListModel::updateCacheSize(int width, int height)
|
|
{
|
|
// This is a bit conversative, since it doesn't consider padding, but better to be over than under.
|
|
const int cover_width = getCoverArtWidth();
|
|
const int cover_height = getCoverArtHeight();
|
|
const int num_columns = ((width + (cover_width - 1)) / cover_width);
|
|
const int num_rows = ((height + (cover_height - 1)) / cover_height);
|
|
m_cover_pixmap_cache.SetMaxCapacity(static_cast<int>(std::max(num_columns * num_rows, MIN_COVER_CACHE_SIZE)));
|
|
}
|
|
|
|
void GameListModel::loadOrGenerateCover(const GameList::Entry* ge)
|
|
{
|
|
// Why this counter: Every time we change the cover scale, we increment the counter variable. This way if the scale is changed
|
|
// while there's outstanding jobs, the old jobs won't proceed (at the wrong size), or get added into the grid.
|
|
const u32 counter = m_cover_scale_counter.load(std::memory_order_acquire);
|
|
|
|
QFuture<QPixmap> future = QtConcurrent::run([this, entry = *ge, counter]() -> QPixmap {
|
|
QPixmap image;
|
|
if (m_cover_scale_counter.load(std::memory_order_acquire) == counter)
|
|
{
|
|
const std::string cover_path(GameList::GetCoverImagePathForEntry(&entry));
|
|
if (!cover_path.empty())
|
|
{
|
|
const float dpr = qApp->devicePixelRatio();
|
|
image = QPixmap(QString::fromStdString(cover_path));
|
|
if (!image.isNull())
|
|
{
|
|
image.setDevicePixelRatio(dpr);
|
|
resizeAndPadPixmap(&image, getCoverArtWidth(), getCoverArtHeight(), dpr);
|
|
}
|
|
}
|
|
}
|
|
|
|
const std::string& title = entry.GetTitle(m_prefer_english_titles);
|
|
|
|
if (image.isNull())
|
|
image = createPlaceholderImage(m_placeholder_pixmap, getCoverArtWidth(), getCoverArtHeight(), m_cover_scale, title);
|
|
|
|
if (m_cover_scale_counter.load(std::memory_order_acquire) != counter)
|
|
image = {};
|
|
|
|
return image;
|
|
});
|
|
|
|
// Context must be 'this' so we run on the UI thread.
|
|
future.then(this, [this, path = ge->path, counter](QPixmap pm) {
|
|
if (m_cover_scale_counter.load(std::memory_order_acquire) != counter)
|
|
return;
|
|
|
|
m_cover_pixmap_cache.Insert(std::move(path), std::move(pm));
|
|
invalidateCoverForPath(path);
|
|
});
|
|
}
|
|
|
|
void GameListModel::invalidateCoverForPath(const std::string& path)
|
|
{
|
|
// This isn't ideal, but not sure how else we can get the row, when it might change while scanning...
|
|
auto lock = GameList::GetLock();
|
|
const u32 count = GameList::GetEntryCount();
|
|
std::optional<u32> row;
|
|
for (u32 i = 0; i < count; i++)
|
|
{
|
|
if (GameList::GetEntryByIndex(i)->path == path)
|
|
{
|
|
row = i;
|
|
break;
|
|
}
|
|
}
|
|
if (!row.has_value())
|
|
{
|
|
// Game removed?
|
|
return;
|
|
}
|
|
|
|
const QModelIndex mi(index(static_cast<int>(row.value()), Column_Cover));
|
|
emit dataChanged(mi, mi, {Qt::DecorationRole});
|
|
}
|
|
|
|
int GameListModel::getCoverArtWidth() const
|
|
{
|
|
return std::max(static_cast<int>(static_cast<float>(COVER_ART_WIDTH) * m_cover_scale), 1);
|
|
}
|
|
|
|
int GameListModel::getCoverArtHeight() const
|
|
{
|
|
return std::max(static_cast<int>(static_cast<float>(COVER_ART_HEIGHT) * m_cover_scale), 1);
|
|
}
|
|
|
|
int GameListModel::getCoverArtSpacing() const
|
|
{
|
|
return std::max(static_cast<int>(static_cast<float>(COVER_ART_SPACING) * m_cover_scale), 1);
|
|
}
|
|
|
|
int GameListModel::rowCount(const QModelIndex& parent) const
|
|
{
|
|
if (parent.isValid())
|
|
return 0;
|
|
|
|
return static_cast<int>(GameList::GetEntryCount());
|
|
}
|
|
|
|
int GameListModel::columnCount(const QModelIndex& parent) const
|
|
{
|
|
if (parent.isValid())
|
|
return 0;
|
|
|
|
return Column_Count;
|
|
}
|
|
|
|
QString GameListModel::formatTimespan(time_t timespan)
|
|
{
|
|
// avoid an extra string conversion
|
|
const u32 hours = static_cast<u32>(timespan / 3600);
|
|
const u32 minutes = static_cast<u32>((timespan % 3600) / 60);
|
|
if (hours > 0)
|
|
return qApp->translate("GameList", "%n hours", "", hours);
|
|
else
|
|
return qApp->translate("GameList", "%n minutes", "", minutes);
|
|
}
|
|
|
|
QVariant GameListModel::data(const QModelIndex& index, int role) const
|
|
{
|
|
if (!index.isValid())
|
|
return {};
|
|
|
|
const int row = index.row();
|
|
if (row < 0 || row >= static_cast<int>(GameList::GetEntryCount()))
|
|
return {};
|
|
|
|
const auto lock = GameList::GetLock();
|
|
const GameList::Entry* ge = GameList::GetEntryByIndex(row);
|
|
if (!ge)
|
|
return {};
|
|
|
|
switch (role)
|
|
{
|
|
case Qt::DisplayRole:
|
|
{
|
|
switch (index.column())
|
|
{
|
|
case Column_Serial:
|
|
return QString::fromStdString(ge->serial);
|
|
|
|
case Column_Title:
|
|
return QString::fromStdString(ge->GetTitle(m_prefer_english_titles));
|
|
|
|
case Column_FileTitle:
|
|
return QtUtils::StringViewToQString(Path::GetFileTitle(ge->path));
|
|
|
|
case Column_CRC:
|
|
return QString::fromStdString(fmt::format("{:08X}", ge->crc));
|
|
|
|
case Column_TimePlayed:
|
|
{
|
|
if (ge->total_played_time == 0)
|
|
return {};
|
|
else
|
|
return formatTimespan(ge->total_played_time);
|
|
}
|
|
|
|
case Column_LastPlayed:
|
|
return QString::fromStdString(GameList::FormatTimestamp(ge->last_played_time));
|
|
|
|
case Column_Size:
|
|
return QString("%1 MB").arg(static_cast<double>(ge->total_size) / 1048576.0, 0, 'f', 2);
|
|
|
|
case Column_Cover:
|
|
{
|
|
if (m_show_titles_for_covers)
|
|
return QString::fromStdString(ge->GetTitle(m_prefer_english_titles));
|
|
else
|
|
return {};
|
|
}
|
|
|
|
default:
|
|
return {};
|
|
}
|
|
}
|
|
|
|
case Qt::InitialSortOrderRole:
|
|
{
|
|
switch (index.column())
|
|
{
|
|
case Column_Type:
|
|
return static_cast<int>(ge->type);
|
|
|
|
case Column_Serial:
|
|
return QString::fromStdString(ge->serial);
|
|
|
|
case Column_Title:
|
|
case Column_Cover:
|
|
return QString::fromStdString(ge->GetTitleSort(m_prefer_english_titles));
|
|
|
|
case Column_FileTitle:
|
|
return QtUtils::StringViewToQString(Path::GetFileTitle(ge->path));
|
|
|
|
case Column_CRC:
|
|
return static_cast<int>(ge->crc);
|
|
|
|
case Column_TimePlayed:
|
|
return static_cast<qlonglong>(ge->total_played_time);
|
|
|
|
case Column_LastPlayed:
|
|
return static_cast<qlonglong>(ge->last_played_time);
|
|
|
|
case Column_Region:
|
|
return static_cast<int>(ge->region);
|
|
|
|
case Column_Compatibility:
|
|
return static_cast<int>(ge->compatibility_rating);
|
|
|
|
case Column_Size:
|
|
return static_cast<qulonglong>(ge->total_size);
|
|
|
|
default:
|
|
return {};
|
|
}
|
|
}
|
|
|
|
case Qt::DecorationRole:
|
|
{
|
|
switch (index.column())
|
|
{
|
|
case Column_Type:
|
|
{
|
|
return m_type_pixmaps[static_cast<u32>(ge->type)];
|
|
}
|
|
|
|
case Column_Region:
|
|
{
|
|
return m_region_pixmaps[static_cast<u32>(ge->region)];
|
|
}
|
|
|
|
case Column_Compatibility:
|
|
{
|
|
return m_compatibility_pixmaps[static_cast<u32>(
|
|
(static_cast<u32>(ge->compatibility_rating) >= GameList::CompatibilityRatingCount) ?
|
|
GameList::CompatibilityRating::Unknown :
|
|
ge->compatibility_rating)];
|
|
}
|
|
|
|
case Column_Cover:
|
|
{
|
|
QPixmap* pm = m_cover_pixmap_cache.Lookup(ge->path);
|
|
if (pm)
|
|
return *pm;
|
|
|
|
// We insert the placeholder into the cache, so that we don't repeatedly
|
|
// queue loading jobs for this game.
|
|
const_cast<GameListModel*>(this)->loadOrGenerateCover(ge);
|
|
return *m_cover_pixmap_cache.Insert(ge->path, m_loading_pixmap);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return {};
|
|
}
|
|
|
|
default:
|
|
return {};
|
|
}
|
|
}
|
|
}
|
|
|
|
QVariant GameListModel::headerData(int section, Qt::Orientation orientation, int role) const
|
|
{
|
|
if (orientation != Qt::Horizontal || role != Qt::DisplayRole || section < 0 || section >= Column_Count)
|
|
return {};
|
|
|
|
return m_column_display_names[section];
|
|
}
|
|
|
|
void GameListModel::refresh()
|
|
{
|
|
beginResetModel();
|
|
loadSettings();
|
|
endResetModel();
|
|
}
|
|
|
|
bool GameListModel::titlesLessThan(int left_row, int right_row) const
|
|
{
|
|
if (left_row < 0 || left_row >= static_cast<int>(GameList::GetEntryCount()) || right_row < 0 ||
|
|
right_row >= static_cast<int>(GameList::GetEntryCount()))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const GameList::Entry* left = GameList::GetEntryByIndex(left_row);
|
|
const GameList::Entry* right = GameList::GetEntryByIndex(right_row);
|
|
return QtHost::LocaleSensitiveCompare(QString::fromStdString(left->GetTitleSort(m_prefer_english_titles)),
|
|
QString::fromStdString(right->GetTitleSort(m_prefer_english_titles))) < 0;
|
|
}
|
|
|
|
bool GameListModel::lessThan(const QModelIndex& left_index, const QModelIndex& right_index, int column) const
|
|
{
|
|
if (!left_index.isValid() || !right_index.isValid())
|
|
return false;
|
|
|
|
const int left_row = left_index.row();
|
|
const int right_row = right_index.row();
|
|
if (left_row < 0 || left_row >= static_cast<int>(GameList::GetEntryCount()) || right_row < 0 ||
|
|
right_row >= static_cast<int>(GameList::GetEntryCount()))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const auto lock = GameList::GetLock();
|
|
const GameList::Entry* left = GameList::GetEntryByIndex(left_row);
|
|
const GameList::Entry* right = GameList::GetEntryByIndex(right_row);
|
|
if (!left || !right)
|
|
return false;
|
|
|
|
switch (column)
|
|
{
|
|
case Column_Type:
|
|
{
|
|
if (left->type == right->type)
|
|
return titlesLessThan(left_row, right_row);
|
|
|
|
return static_cast<int>(left->type) < static_cast<int>(right->type);
|
|
}
|
|
|
|
case Column_Serial:
|
|
{
|
|
if (left->serial == right->serial)
|
|
return titlesLessThan(left_row, right_row);
|
|
return (StringUtil::Strcasecmp(left->serial.c_str(), right->serial.c_str()) < 0);
|
|
}
|
|
|
|
case Column_Title:
|
|
{
|
|
return titlesLessThan(left_row, right_row);
|
|
}
|
|
|
|
case Column_FileTitle:
|
|
{
|
|
const std::string_view file_title_left(Path::GetFileTitle(left->path));
|
|
const std::string_view file_title_right(Path::GetFileTitle(right->path));
|
|
if (file_title_left == file_title_right)
|
|
return titlesLessThan(left_row, right_row);
|
|
|
|
const std::size_t smallest = std::min(file_title_left.size(), file_title_right.size());
|
|
return (StringUtil::Strncasecmp(file_title_left.data(), file_title_right.data(), smallest) < 0);
|
|
}
|
|
|
|
case Column_Region:
|
|
{
|
|
if (left->region == right->region)
|
|
return titlesLessThan(left_row, right_row);
|
|
return (static_cast<int>(left->region) < static_cast<int>(right->region));
|
|
}
|
|
|
|
case Column_Compatibility:
|
|
{
|
|
if (left->compatibility_rating == right->compatibility_rating)
|
|
return titlesLessThan(left_row, right_row);
|
|
|
|
return (static_cast<int>(left->compatibility_rating) < static_cast<int>(right->compatibility_rating));
|
|
}
|
|
|
|
case Column_Size:
|
|
{
|
|
if (left->total_size == right->total_size)
|
|
return titlesLessThan(left_row, right_row);
|
|
|
|
return (left->total_size < right->total_size);
|
|
}
|
|
|
|
case Column_CRC:
|
|
{
|
|
if (left->crc == right->crc)
|
|
return titlesLessThan(left_row, right_row);
|
|
|
|
return (left->crc < right->crc);
|
|
}
|
|
|
|
case Column_TimePlayed:
|
|
{
|
|
if (left->total_played_time == right->total_played_time)
|
|
return titlesLessThan(left_row, right_row);
|
|
|
|
return (left->total_played_time < right->total_played_time);
|
|
}
|
|
|
|
case Column_LastPlayed:
|
|
{
|
|
if (left->last_played_time == right->last_played_time)
|
|
return titlesLessThan(left_row, right_row);
|
|
|
|
return (left->last_played_time < right->last_played_time);
|
|
}
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void GameListModel::loadSettings()
|
|
{
|
|
m_prefer_english_titles = Host::GetBaseBoolSettingValue("UI", "PreferEnglishGameList", false);
|
|
}
|
|
|
|
QIcon GameListModel::getIconForType(GameList::EntryType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case GameList::EntryType::PS2Disc:
|
|
case GameList::EntryType::PS1Disc:
|
|
return QIcon(QStringLiteral(":/icons/media-optical-24.png"));
|
|
|
|
case GameList::EntryType::ELF:
|
|
default:
|
|
return QIcon(QStringLiteral(":/icons/applications-system-24.png"));
|
|
}
|
|
}
|
|
|
|
QIcon GameListModel::getIconForRegion(GameList::Region region)
|
|
{
|
|
return QIcon(
|
|
QStringLiteral("%1/icons/flags/%2.png").arg(QtHost::GetResourcesBasePath()).arg(GameList::RegionToString(region)));
|
|
}
|
|
|
|
void GameListModel::loadThemeSpecificImages()
|
|
{
|
|
for (u32 type = 0; type < static_cast<u32>(GameList::EntryType::Count); type++)
|
|
m_type_pixmaps[type] = getIconForType(static_cast<GameList::EntryType>(type)).pixmap(QSize(24, 24));
|
|
|
|
for (u32 i = 0; i < static_cast<u32>(GameList::Region::Count); i++)
|
|
m_region_pixmaps[i] = getIconForRegion(static_cast<GameList::Region>(i)).pixmap(QSize(42, 30));
|
|
}
|
|
|
|
void GameListModel::loadCommonImages()
|
|
{
|
|
loadThemeSpecificImages();
|
|
|
|
const QString base_path(QtHost::GetResourcesBasePath());
|
|
for (u32 i = 1; i < GameList::CompatibilityRatingCount; i++)
|
|
m_compatibility_pixmaps[i].load(QStringLiteral("%1/icons/star-%2.png").arg(base_path).arg(i - 1));
|
|
|
|
m_placeholder_pixmap.load(QStringLiteral("%1/cover-placeholder.png").arg(base_path));
|
|
}
|
|
|
|
void GameListModel::setColumnDisplayNames()
|
|
{
|
|
m_column_display_names[Column_Type] = tr("Type");
|
|
m_column_display_names[Column_Serial] = tr("Code");
|
|
m_column_display_names[Column_Title] = tr("Title");
|
|
m_column_display_names[Column_FileTitle] = tr("File Title");
|
|
m_column_display_names[Column_CRC] = tr("CRC");
|
|
m_column_display_names[Column_TimePlayed] = tr("Time Played");
|
|
m_column_display_names[Column_LastPlayed] = tr("Last Played");
|
|
m_column_display_names[Column_Size] = tr("Size");
|
|
m_column_display_names[Column_Region] = tr("Region");
|
|
m_column_display_names[Column_Compatibility] = tr("Compatibility");
|
|
}
|