ShuriZma
/
rpcs3
mirror of https://github.com/RPCS3/rpcs3.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Qt: allow hiding trophy table columns

This commit is contained in:
Megamouse 2023-05-18 11:29:23 +02:00
parent a1e19e1cf8
commit bd09dc8ea8
11 changed files with 387 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
rpcs3/rpcs3qt/game_list.cpp
View File

@ -2,6 +2,10 @@
#include "game_list.h"
#include "movie_item.h"
#include <QApplication>
#include <QHeaderView>
#include <QMenu>
game_list::game_list() : QTableWidget(), game_list_base()
{
m_icon_ready_callback = [this](const game_info& game)
@ -10,6 +14,55 @@ game_list::game_list() : QTableWidget(), game_list_base()
};
}
void game_list::create_header_actions(QList<QAction*>& actions, std::function<bool(int)> get_visibility, std::function<void(int, bool)> set_visibility)
{
ensure(get_visibility);
ensure(set_visibility);
horizontalHeader()->setContextMenuPolicy(Qt::CustomContextMenu);
connect(horizontalHeader(), &QHeaderView::customContextMenuRequested, this, [this, &actions](const QPoint& pos)
{
QMenu* configure = new QMenu(this);
configure->addActions(actions);
configure->exec(horizontalHeader()->viewport()->mapToGlobal(pos));
});
for (int col = 0; col < actions.count(); ++col)
{
actions[col]->setCheckable(true);
connect(actions[col], &QAction::triggered, this, [this, &actions, get_visibility, set_visibility, col](bool checked)
{
if (!checked) // be sure to have at least one column left so you can call the context menu at all time
{
int c = 0;
for (int i = 0; i < actions.count(); ++i)
{
if (get_visibility(i) && ++c > 1)
break;
}
if (c < 2)
{
actions[col]->setChecked(true); // re-enable the checkbox if we don't change the actual state
return;
}
}
setColumnHidden(col, !checked); // Negate because it's a set col hidden and we have menu say show.
set_visibility(col, checked);
if (checked) // handle hidden columns that have zero width after showing them (stuck between others)
{
fix_narrow_columns();
}
});
const bool vis = get_visibility(col);
actions[col]->setChecked(vis);
setColumnHidden(col, !vis);
}
}
void game_list::clear_list()
{
m_last_hover_item = nullptr;
@ -17,6 +70,25 @@ void game_list::clear_list()
clearContents();
}
void game_list::fix_narrow_columns()
{
QApplication::processEvents();
// handle columns (other than the icon column) that have zero width after showing them (stuck between others)
for (int col = 1; col < columnCount(); ++col)
{
if (isColumnHidden(col))
{
continue;
}
if (columnWidth(col) <= horizontalHeader()->minimumSectionSize())
{
setColumnWidth(col, horizontalHeader()->minimumSectionSize());
}
}
}
void game_list::mousePressEvent(QMouseEvent *event)
{
if (QTableWidgetItem* item = itemAt(event->pos()); !item || !item->data(Qt::UserRole).isValid())

9
rpcs3/rpcs3qt/game_list.h
View File

@ -1,5 +1,7 @@
#pragma once
#include <QAction>
#include <QList>
#include <QTableWidget>
#include <QMouseEvent>
#include <QKeyEvent>
@ -7,6 +9,8 @@
#include "game_list_base.h"
#include "util/atomic.hpp"
#include <functional>
class movie_item;
/*
@ -20,8 +24,13 @@ class game_list : public QTableWidget, public game_list_base
public:
game_list();
void create_header_actions(QList<QAction*>& actions, std::function<bool(int)> get_visibility, std::function<void(int, bool)> set_visibility);
void clear_list() override; // Use this instead of clearContents
/** Fix columns with width smaller than the minimal section size */
void fix_narrow_columns();
public Q_SLOTS:
void FocusAndSelectFirstEntryIfNoneIs();

8
rpcs3/rpcs3qt/game_list_delegate.cpp
View File

@ -13,7 +13,7 @@ void game_list_delegate::paint(QPainter* painter, const QStyleOptionViewItem& op
table_item_delegate::paint(painter, option, index);
// Find out if the icon or size items are visible
if (index.column() == gui::game_list_columns::column_dir_size || (m_has_icons && index.column() == gui::game_list_columns::column_icon))
if (index.column() == static_cast<int>(gui::game_list_columns::dir_size) || (m_has_icons && index.column() == static_cast<int>(gui::game_list_columns::icon)))
{
if (const QTableWidget* table = static_cast<const QTableWidget*>(parent()))
{
@ -24,16 +24,16 @@ void game_list_delegate::paint(QPainter* painter, const QStyleOptionViewItem& op
if (const QTableWidgetItem* current_item = table->item(index.row(), index.column());
current_item && visible_region.intersects(table->visualItemRect(current_item)))
{
if (movie_item* item = static_cast<movie_item*>(table->item(index.row(), gui::game_list_columns::column_icon)))
if (movie_item* item = static_cast<movie_item*>(table->item(index.row(), static_cast<int>(gui::game_list_columns::icon))))
{
if (index.column() == gui::game_list_columns::column_dir_size)
if (index.column() == static_cast<int>(gui::game_list_columns::dir_size))
{
if (!item->size_on_disk_loading())
{
item->call_size_calc_func();
}
}
else if (m_has_icons && index.column() == gui::game_list_columns::column_icon)
else if (m_has_icons && index.column() == static_cast<int>(gui::game_list_columns::icon))
{
if (!item->icon_loading())
{

84
rpcs3/rpcs3qt/game_list_frame.cpp
View File

@ -118,25 +118,25 @@ game_list_frame::game_list_frame(std::shared_ptr<gui_settings> gui_settings, std
// Actions regarding showing/hiding columns
auto add_column = [this](gui::game_list_columns col, const QString& header_text, const QString& action_text)
{
m_game_list->setHorizontalHeaderItem(col, new QTableWidgetItem(header_text));
m_game_list->setHorizontalHeaderItem(static_cast<int>(col), new QTableWidgetItem(header_text));
m_columnActs.append(new QAction(action_text, this));
};
add_column(gui::column_icon, tr("Icon"), tr("Show Icons"));
add_column(gui::column_name, tr("Name"), tr("Show Names"));
add_column(gui::column_serial, tr("Serial"), tr("Show Serials"));
add_column(gui::column_firmware, tr("Firmware"), tr("Show Firmwares"));
add_column(gui::column_version, tr("Version"), tr("Show Versions"));
add_column(gui::column_category, tr("Category"), tr("Show Categories"));
add_column(gui::column_path, tr("Path"), tr("Show Paths"));
add_column(gui::column_move, tr("PlayStation Move"), tr("Show PlayStation Move"));
add_column(gui::column_resolution, tr("Supported Resolutions"), tr("Show Supported Resolutions"));
add_column(gui::column_sound, tr("Sound Formats"), tr("Show Sound Formats"));
add_column(gui::column_parental, tr("Parental Level"), tr("Show Parental Levels"));
add_column(gui::column_last_play, tr("Last Played"), tr("Show Last Played"));
add_column(gui::column_playtime, tr("Time Played"), tr("Show Time Played"));
add_column(gui::column_compat, tr("Compatibility"), tr("Show Compatibility"));
add_column(gui::column_dir_size, tr("Space On Disk"), tr("Show Space On Disk"));
add_column(gui::game_list_columns::icon, tr("Icon"), tr("Show Icons"));
add_column(gui::game_list_columns::name, tr("Name"), tr("Show Names"));
add_column(gui::game_list_columns::serial, tr("Serial"), tr("Show Serials"));
add_column(gui::game_list_columns::firmware, tr("Firmware"), tr("Show Firmwares"));
add_column(gui::game_list_columns::version, tr("Version"), tr("Show Versions"));
add_column(gui::game_list_columns::category, tr("Category"), tr("Show Categories"));
add_column(gui::game_list_columns::path, tr("Path"), tr("Show Paths"));
add_column(gui::game_list_columns::move, tr("PlayStation Move"), tr("Show PlayStation Move"));
add_column(gui::game_list_columns::resolution, tr("Supported Resolutions"), tr("Show Supported Resolutions"));
add_column(gui::game_list_columns::sound, tr("Sound Formats"), tr("Show Sound Formats"));
add_column(gui::game_list_columns::parental, tr("Parental Level"), tr("Show Parental Levels"));
add_column(gui::game_list_columns::last_play, tr("Last Played"), tr("Show Last Played"));
add_column(gui::game_list_columns::playtime, tr("Time Played"), tr("Show Time Played"));
add_column(gui::game_list_columns::compat, tr("Compatibility"), tr("Show Compatibility"));
add_column(gui::game_list_columns::dir_size, tr("Space On Disk"), tr("Show Space On Disk"));
// Events
connect(&m_parsing_watcher, &QFutureWatcher<void>::finished, this, &game_list_frame::OnParsingFinished);
@ -169,12 +169,6 @@ game_list_frame::game_list_frame(std::shared_ptr<gui_settings> gui_settings, std
connect(m_game_list, &QTableWidget::itemDoubleClicked, this, QOverload<QTableWidgetItem*>::of(&game_list_frame::doubleClickedSlot));
connect(m_game_list->horizontalHeader(), &QHeaderView::sectionClicked, this, &game_list_frame::OnColClicked);
connect(m_game_list->horizontalHeader(), &QHeaderView::customContextMenuRequested, this, [this](const QPoint& pos)
{
QMenu* configure = new QMenu(this);
configure->addActions(m_columnActs);
configure->exec(m_game_list->horizontalHeader()->viewport()->mapToGlobal(pos));
});
connect(m_game_grid, &QWidget::customContextMenuRequested, this, &game_list_frame::ShowContextMenu);
connect(m_game_grid, &game_list_grid::ItemSelectionChanged, this, &game_list_frame::NotifyGameSelection);
@ -199,35 +193,9 @@ game_list_frame::game_list_frame(std::shared_ptr<gui_settings> gui_settings, std
connect(m_game_list, &game_list::FocusToSearchBar, this, &game_list_frame::FocusToSearchBar);
connect(m_game_grid, &game_list_grid::FocusToSearchBar, this, &game_list_frame::FocusToSearchBar);
for (int col = 0; col < m_columnActs.count(); ++col)
{
m_columnActs[col]->setCheckable(true);
connect(m_columnActs[col], &QAction::triggered, this, [this, col](bool checked)
{
if (!checked) // be sure to have at least one column left so you can call the context menu at all time
{
int c = 0;
for (int i = 0; i < m_columnActs.count(); ++i)
{
if (m_gui_settings->GetGamelistColVisibility(i) && ++c > 1)
break;
}
if (c < 2)
{
m_columnActs[col]->setChecked(true); // re-enable the checkbox if we don't change the actual state
return;
}
}
m_game_list->setColumnHidden(col, !checked); // Negate because it's a set col hidden and we have menu say show.
m_gui_settings->SetGamelistColVisibility(col, checked);
if (checked) // handle hidden columns that have zero width after showing them (stuck between others)
{
m_game_list->fix_narrow_columns();
}
});
}
m_game_list->create_header_actions(m_columnActs,
[this](int col) { return m_gui_settings->GetGamelistColVisibility(static_cast<gui::game_list_columns>(col)); },
[this](int col, bool visible) { m_gui_settings->SetGamelistColVisibility(static_cast<gui::game_list_columns>(col), visible); });
}
void game_list_frame::LoadSettings()
@ -242,7 +210,7 @@ void game_list_frame::LoadSettings()
for (int col = 0; col < m_columnActs.count(); ++col)
{
const bool vis = m_gui_settings->GetGamelistColVisibility(col);
const bool vis = m_gui_settings->GetGamelistColVisibility(static_cast<gui::game_list_columns>(col));
m_columnActs[col]->setChecked(vis);
m_game_list->setColumnHidden(col, !vis);
}
@ -260,7 +228,7 @@ game_list_frame::~game_list_frame()
void game_list_frame::OnColClicked(int col)
{
if (col == gui::column_icon) return; // Don't "sort" icons.
if (col == static_cast<int>(gui::game_list_columns::icon)) return; // Don't "sort" icons.
if (col == m_sort_column)
{
@ -862,7 +830,7 @@ void game_list_frame::SaveSettings()
{
for (int col = 0; col < m_columnActs.count(); ++col)
{
m_gui_settings->SetGamelistColVisibility(col, m_columnActs[col]->isChecked());
m_gui_settings->SetGamelistColVisibility(static_cast<gui::game_list_columns>(col), m_columnActs[col]->isChecked());
}
m_gui_settings->SetValue(gui::gl_sortCol, m_sort_column);
m_gui_settings->SetValue(gui::gl_sortAsc, m_col_sort_order == Qt::AscendingOrder);
@ -896,7 +864,7 @@ void game_list_frame::ItemSelectionChangedSlot()
if (m_is_list_layout)
{
if (const auto item = m_game_list->item(m_game_list->currentRow(), gui::column_icon); item && item->isSelected())
if (const auto item = m_game_list->item(m_game_list->currentRow(), static_cast<int>(gui::game_list_columns::icon)); item && item->isSelected())
{
game = GetGameInfoByMode(item);
}
@ -1017,7 +985,7 @@ void game_list_frame::ShowContextMenu(const QPoint &pos)
if (m_is_list_layout)
{
QTableWidgetItem* item = m_game_list->item(m_game_list->indexAt(pos).row(), gui::column_icon);
QTableWidgetItem* item = m_game_list->item(m_game_list->indexAt(pos).row(), static_cast<int>(gui::game_list_columns::icon));
global_pos = m_game_list->viewport()->mapToGlobal(pos);
gameinfo = GetGameInfoFromItem(item);
}
@ -2302,7 +2270,7 @@ bool game_list_frame::eventFilter(QObject *object, QEvent *event)
if (object == m_game_list)
{
QTableWidgetItem* item = m_game_list->item(m_game_list->currentRow(), gui::column_icon);
QTableWidgetItem* item = m_game_list->item(m_game_list->currentRow(), static_cast<int>(gui::game_list_columns::icon));
if (!item || !item->isSelected())
return false;
@ -2418,7 +2386,7 @@ game_info game_list_frame::GetGameInfoByMode(const QTableWidgetItem* item) const
if (m_is_list_layout)
{
return GetGameInfoFromItem(m_game_list->item(item->row(), gui::column_icon));
return GetGameInfoFromItem(m_game_list->item(item->row(), static_cast<int>(gui::game_list_columns::icon)));
}
return GetGameInfoFromItem(item);

75
rpcs3/rpcs3qt/game_list_table.cpp
View File

@ -11,7 +11,6 @@
#include "Emu/vfs_config.h"
#include "Utilities/StrUtil.h"
#include <QApplication>
#include <QHeaderView>
#include <QScrollBar>
#include <QStringBuilder>
@ -32,7 +31,6 @@ game_list_table::game_list_table(game_list_frame* frame, std::shared_ptr<persist
horizontalScrollBar()->setSingleStep(20);
verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
verticalHeader()->setVisible(false);
horizontalHeader()->setContextMenuPolicy(Qt::CustomContextMenu);
horizontalHeader()->setHighlightSections(false);
horizontalHeader()->setSortIndicatorShown(true);
horizontalHeader()->setStretchLastSection(true);
@ -40,13 +38,13 @@ game_list_table::game_list_table(game_list_frame* frame, std::shared_ptr<persist
horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
setContextMenuPolicy(Qt::CustomContextMenu);
setAlternatingRowColors(true);
setColumnCount(gui::column_count);
setColumnCount(static_cast<int>(gui::game_list_columns::count));
setMouseTracking(true);
connect(this, &game_list_table::size_on_disk_ready, this, [this](const game_info& game)
{
if (!game || !game->item) return;
if (QTableWidgetItem* size_item = item(static_cast<movie_item*>(game->item)->row(), gui::column_dir_size))
if (QTableWidgetItem* size_item = item(static_cast<movie_item*>(game->item)->row(), static_cast<int>(gui::game_list_columns::dir_size)))
{
const u64& game_size = game->info.size_on_disk;
size_item->setText(game_size != umax ? gui::utils::format_byte_size(game_size) : tr("Unknown"));
@ -65,7 +63,7 @@ void game_list_table::restore_layout(const QByteArray& state)
{
// Resize to fit and get the ideal icon column width
resize_columns_to_contents();
const int icon_column_width = columnWidth(gui::column_icon);
const int icon_column_width = columnWidth(static_cast<int>(gui::game_list_columns::icon));
// Restore header layout from last session
if (!horizontalHeader()->restoreState(state) && rowCount())
@ -78,31 +76,12 @@ void game_list_table::restore_layout(const QByteArray& state)
// Make sure that the icon column is large enough for the actual items.
// This is important if the list appeared as empty when closing the software before.
horizontalHeader()->resizeSection(gui::column_icon, icon_column_width);
horizontalHeader()->resizeSection(static_cast<int>(gui::game_list_columns::icon), icon_column_width);
// Save new header state
horizontalHeader()->restoreState(horizontalHeader()->saveState());
}
void game_list_table::fix_narrow_columns()
{
QApplication::processEvents();
// handle columns (other than the icon column) that have zero width after showing them (stuck between others)
for (int col = 1; col < columnCount(); ++col)
{
if (isColumnHidden(col))
{
continue;
}
if (columnWidth(col) <= horizontalHeader()->minimumSectionSize())
{
setColumnWidth(col, horizontalHeader()->minimumSectionSize());
}
}
}
void game_list_table::resize_columns_to_contents(int spacing)
{
verticalHeader()->resizeSections(QHeaderView::ResizeMode::ResizeToContents);
@ -128,10 +107,10 @@ void game_list_table::adjust_icon_column()
verticalHeader()->setMaximumSectionSize(m_icon_size.height());
// Resize the icon column
resizeColumnToContents(gui::column_icon);
resizeColumnToContents(static_cast<int>(gui::game_list_columns::icon));
// Shorten the last section to remove horizontal scrollbar if possible
resizeColumnToContents(gui::column_count - 1);
resizeColumnToContents(static_cast<int>(gui::game_list_columns::count) - 1);
}
void game_list_table::sort(int game_count, int sort_column, Qt::SortOrder col_sort_order)
@ -175,7 +154,7 @@ void game_list_table::sort(int game_count, int sort_column, Qt::SortOrder col_so
setColumnWidth(i, column_widths[i]);
}
horizontalHeader()->setSectionResizeMode(gui::column_icon, QHeaderView::Fixed);
horizontalHeader()->setSectionResizeMode(static_cast<int>(gui::game_list_columns::icon), QHeaderView::Fixed);
return;
}
@ -191,14 +170,14 @@ void game_list_table::sort(int game_count, int sort_column, Qt::SortOrder col_so
}
else
{
resizeColumnToContents(gui::column_icon);
resizeColumnToContents(static_cast<int>(gui::game_list_columns::icon));
}
// Fixate icon column
horizontalHeader()->setSectionResizeMode(gui::column_icon, QHeaderView::Fixed);
horizontalHeader()->setSectionResizeMode(static_cast<int>(gui::game_list_columns::icon), QHeaderView::Fixed);
// Shorten the last section to remove horizontal scrollbar if possible
resizeColumnToContents(gui::column_count - 1);
resizeColumnToContents(static_cast<int>(gui::game_list_columns::count) - 1);
}
void game_list_table::set_custom_config_icon(const game_info& game)
@ -212,9 +191,9 @@ void game_list_table::set_custom_config_icon(const game_info& game)
for (int row = 0; row < rowCount(); ++row)
{
if (QTableWidgetItem* title_item = item(row, gui::column_name))
if (QTableWidgetItem* title_item = item(row, static_cast<int>(gui::game_list_columns::name)))
{
if (const QTableWidgetItem* serial_item = item(row, gui::column_serial); serial_item && serial_item->text() == serial)
if (const QTableWidgetItem* serial_item = item(row, static_cast<int>(gui::game_list_columns::serial)); serial_item && serial_item->text() == serial)
{
title_item->setIcon(game_list_base::GetCustomConfigIcon(game));
}
@ -379,21 +358,21 @@ void game_list_table::populate(
const u64 game_size = game->info.size_on_disk;
setItem(row, gui::column_icon, icon_item);
setItem(row, gui::column_name, title_item);
setItem(row, gui::column_serial, serial_item);
setItem(row, gui::column_firmware, new custom_table_widget_item(game->info.fw));
setItem(row, gui::column_version, new custom_table_widget_item(app_version));
setItem(row, gui::column_category, new custom_table_widget_item(game->localized_category));
setItem(row, gui::column_path, new custom_table_widget_item(game->info.path));
setItem(row, gui::column_move, new custom_table_widget_item((supports_move ? tr("Supported") : tr("Not Supported")).toStdString(), Qt::UserRole, !supports_move));
setItem(row, gui::column_resolution, new custom_table_widget_item(Localized::GetStringFromU32(game->info.resolution, localized.resolution.mode, true)));
setItem(row, gui::column_sound, new custom_table_widget_item(Localized::GetStringFromU32(game->info.sound_format, localized.sound.format, true)));
setItem(row, gui::column_parental, new custom_table_widget_item(Localized::GetStringFromU32(game->info.parental_lvl, localized.parental.level), Qt::UserRole, game->info.parental_lvl));
setItem(row, gui::column_last_play, new custom_table_widget_item(locale.toString(last_played, last_played >= QDateTime::currentDateTime().addDays(-7) ? gui::persistent::last_played_date_with_time_of_day_format : gui::persistent::last_played_date_format_new), Qt::UserRole, last_played));
setItem(row, gui::column_playtime, new custom_table_widget_item(elapsed_ms == 0 ? tr("Never played") : localized.GetVerboseTimeByMs(elapsed_ms), Qt::UserRole, elapsed_ms));
setItem(row, gui::column_compat, compat_item);
setItem(row, gui::column_dir_size, new custom_table_widget_item(game_size != umax ? gui::utils::format_byte_size(game_size) : tr("Unknown"), Qt::UserRole, QVariant::fromValue<qulonglong>(game_size)));
setItem(row, static_cast<int>(gui::game_list_columns::icon), icon_item);
setItem(row, static_cast<int>(gui::game_list_columns::name), title_item);
setItem(row, static_cast<int>(gui::game_list_columns::serial), serial_item);
setItem(row, static_cast<int>(gui::game_list_columns::firmware), new custom_table_widget_item(game->info.fw));
setItem(row, static_cast<int>(gui::game_list_columns::version), new custom_table_widget_item(app_version));
setItem(row, static_cast<int>(gui::game_list_columns::category), new custom_table_widget_item(game->localized_category));
setItem(row, static_cast<int>(gui::game_list_columns::path), new custom_table_widget_item(game->info.path));
setItem(row, static_cast<int>(gui::game_list_columns::move), new custom_table_widget_item((supports_move ? tr("Supported") : tr("Not Supported")).toStdString(), Qt::UserRole, !supports_move));
setItem(row, static_cast<int>(gui::game_list_columns::resolution), new custom_table_widget_item(Localized::GetStringFromU32(game->info.resolution, localized.resolution.mode, true)));
setItem(row, static_cast<int>(gui::game_list_columns::sound), new custom_table_widget_item(Localized::GetStringFromU32(game->info.sound_format, localized.sound.format, true)));
setItem(row, static_cast<int>(gui::game_list_columns::parental), new custom_table_widget_item(Localized::GetStringFromU32(game->info.parental_lvl, localized.parental.level), Qt::UserRole, game->info.parental_lvl));
setItem(row, static_cast<int>(gui::game_list_columns::last_play), new custom_table_widget_item(locale.toString(last_played, last_played >= QDateTime::currentDateTime().addDays(-7) ? gui::persistent::last_played_date_with_time_of_day_format : gui::persistent::last_played_date_format_new), Qt::UserRole, last_played));
setItem(row, static_cast<int>(gui::game_list_columns::playtime), new custom_table_widget_item(elapsed_ms == 0 ? tr("Never played") : localized.GetVerboseTimeByMs(elapsed_ms), Qt::UserRole, elapsed_ms));
setItem(row, static_cast<int>(gui::game_list_columns::compat), compat_item);
setItem(row, static_cast<int>(gui::game_list_columns::dir_size), new custom_table_widget_item(game_size != umax ? gui::utils::format_byte_size(game_size) : tr("Unknown"), Qt::UserRole, QVariant::fromValue<qulonglong>(game_size)));
if (selected_item_id == game->info.path + game->info.icon_path)
{

3
rpcs3/rpcs3qt/game_list_table.h
View File

@ -15,9 +15,6 @@ public:
/** Restores the initial layout of the table */
void restore_layout(const QByteArray& state);
/** Fix columns with width smaller than the minimal section size */
void fix_narrow_columns();
/** Resizes the columns to their contents and adds a small spacing */
void resize_columns_to_contents(int spacing = 20);

134
rpcs3/rpcs3qt/gui_settings.cpp
View File

@ -11,7 +11,91 @@
LOG_CHANNEL(cfg_log, "CFG");
inline std::string sstr(const QString& _in) { return _in.toStdString(); }
namespace gui
{
QString get_game_list_column_name(game_list_columns col)
{
switch (col)
{
case game_list_columns::icon:
return "column_icon";
case game_list_columns::name:
return "column_name";
case game_list_columns::serial:
return "column_serial";
case game_list_columns::firmware:
return "column_firmware";
case game_list_columns::version:
return "column_version";
case game_list_columns::category:
return "column_category";
case game_list_columns::path:
return "column_path";
case game_list_columns::move:
return "column_move";
case game_list_columns::resolution:
return "column_resolution";
case game_list_columns::sound:
return "column_sound";
case game_list_columns::parental:
return "column_parental";
case game_list_columns::last_play:
return "column_last_play";
case game_list_columns::playtime:
return "column_playtime";
case game_list_columns::compat:
return "column_compat";
case game_list_columns::dir_size:
return "column_dir_size";
case game_list_columns::count:
return "";
}
fmt::throw_exception("get_game_list_column_name: Invalid column");
}
QString get_trophy_list_column_name(trophy_list_columns col)
{
switch (col)
{
case trophy_list_columns::icon:
return "trophy_column_icon";
case trophy_list_columns::name:
return "trophy_column_name";
case trophy_list_columns::description:
return "trophy_column_description";
case trophy_list_columns::type:
return "trophy_column_type";
case trophy_list_columns::is_unlocked:
return "trophy_column_is_unlocked";
case trophy_list_columns::id:
return "trophy_column_id";
case trophy_list_columns::platinum_link:
return "trophy_column_platinum_link";
case trophy_list_columns::count:
return "";
}
fmt::throw_exception("get_trophy_list_column_name: Invalid column");
}
QString get_trophy_game_list_column_name(trophy_game_list_columns col)
{
switch (col)
{
case trophy_game_list_columns::icon:
return "trophy_game_column_icon";
case trophy_game_list_columns::name:
return "trophy_game_column_name";
case trophy_game_list_columns::progress:
return "trophy_game_column_progress";
case trophy_game_list_columns::count:
return "";
}
fmt::throw_exception("get_trophy_game_list_column_name: Invalid column");
}
}
gui_settings::gui_settings(QObject* parent) : settings(parent)
{
@ -55,7 +139,7 @@ void gui_settings::ShowBox(QMessageBox::Icon icon, const QString& title, const Q
if (has_gui_setting && !GetValue(entry).toBool())
{
cfg_log.notice("%s Dialog for Entry %s was ignored", dialog_type, sstr(entry.name));
cfg_log.notice("%s Dialog for Entry %s was ignored", dialog_type, entry.name.toStdString());
return;
}
@ -81,7 +165,7 @@ void gui_settings::ShowBox(QMessageBox::Icon icon, const QString& title, const Q
if (checkBox && checkBox->isChecked())
{
SetValue(entry, false);
cfg_log.notice("%s Dialog for Entry %s is now disabled", dialog_type, sstr(entry.name));
cfg_log.notice("%s Dialog for Entry %s is now disabled", dialog_type, entry.name.toStdString());
}
});
@ -130,9 +214,19 @@ bool gui_settings::GetBootConfirmation(QWidget* parent, const gui_save& gui_save
return true;
}
void gui_settings::SetGamelistColVisibility(int col, bool val) const
void gui_settings::SetTrophyGamelistColVisibility(gui::trophy_game_list_columns col, bool val) const
{
SetValue(GetGuiSaveForColumn(col), val);
SetValue(GetGuiSaveForTrophyGameColumn(col), val);
}
void gui_settings::SetTrophylistColVisibility(gui::trophy_list_columns col, bool val) const
{
SetValue(GetGuiSaveForTrophyColumn(col), val);
}
void gui_settings::SetGamelistColVisibility(gui::game_list_columns col, bool val) const
{
SetValue(GetGuiSaveForGameColumn(col), val);
}
void gui_settings::SetCustomColor(int col, const QColor& val) const
@ -145,9 +239,19 @@ logs::level gui_settings::GetLogLevel() const
return logs::level(GetValue(gui::l_level).toUInt());
}
bool gui_settings::GetGamelistColVisibility(int col) const
bool gui_settings::GetTrophyGamelistColVisibility(gui::trophy_game_list_columns col) const
{
return GetValue(GetGuiSaveForColumn(col)).toBool();
return GetValue(GetGuiSaveForTrophyGameColumn(col)).toBool();
}
bool gui_settings::GetTrophylistColVisibility(gui::trophy_list_columns col) const
{
return GetValue(GetGuiSaveForTrophyColumn(col)).toBool();
}
bool gui_settings::GetGamelistColVisibility(gui::game_list_columns col) const
{
return GetValue(GetGuiSaveForGameColumn(col)).toBool();
}
QColor gui_settings::GetCustomColor(int col) const
@ -183,11 +287,21 @@ QSize gui_settings::SizeFromSlider(int pos)
return gui::gl_icon_size_min + (gui::gl_icon_size_max - gui::gl_icon_size_min) * (1.f * pos / gui::gl_max_slider_pos);
}
gui_save gui_settings::GetGuiSaveForColumn(int col)
gui_save gui_settings::GetGuiSaveForTrophyGameColumn(gui::trophy_game_list_columns col)
{
return gui_save{ gui::trophy, "visibility_" + gui::get_trophy_game_list_column_name(col), true };
}
gui_save gui_settings::GetGuiSaveForTrophyColumn(gui::trophy_list_columns col)
{
return gui_save{ gui::trophy, "visibility_" + gui::get_trophy_list_column_name(col), true };
}
gui_save gui_settings::GetGuiSaveForGameColumn(gui::game_list_columns col)
{
// hide sound format, parental level, firmware version and path by default
const bool show = col != gui::column_sound && col != gui::column_parental && col != gui::column_firmware && col != gui::column_path;
return gui_save{ gui::game_list, "visibility_" + gui::get_game_list_column_name(static_cast<gui::game_list_columns>(col)), show };
const bool show = col != gui::game_list_columns::sound && col != gui::game_list_columns::parental && col != gui::game_list_columns::firmware && col != gui::game_list_columns::path;
return gui_save{ gui::game_list, "visibility_" + gui::get_game_list_column_name(col), show };
}
gui_save gui_settings::GetGuiSaveForCategory(int cat, bool is_list_mode)

113
rpcs3/rpcs3qt/gui_settings.h
View File

@ -17,67 +17,52 @@ namespace gui
game_role = Qt::UserRole + 1337,
};
enum game_list_columns
enum class game_list_columns
{
column_icon,
column_name,
column_serial,
column_firmware,
column_version,
column_category,
column_path,
column_move,
column_resolution,
column_sound,
column_parental,
column_last_play,
column_playtime,
column_compat,
column_dir_size,
icon,
name,
serial,
firmware,
version,
category,
path,
move,
resolution,
sound,
parental,
last_play,
playtime,
compat,
dir_size,
column_count
count
};
inline QString get_game_list_column_name(game_list_columns col)
enum class trophy_list_columns
{
switch (col)
{
case column_icon:
return "column_icon";
case column_name:
return "column_name";
case column_serial:
return "column_serial";
case column_firmware:
return "column_firmware";
case column_version:
return "column_version";
case column_category:
return "column_category";
case column_path:
return "column_path";
case column_move:
return "column_move";
case column_resolution:
return "column_resolution";
case column_sound:
return "column_sound";
case column_parental:
return "column_parental";
case column_last_play:
return "column_last_play";
case column_playtime:
return "column_playtime";
case column_compat:
return "column_compat";
case column_dir_size:
return "column_dir_size";
case column_count:
return "";
}
icon = 0,
name = 1,
description = 2,
type = 3,
is_unlocked = 4,
id = 5,
platinum_link = 6,
fmt::throw_exception("get_game_list_column_name: Invalid column");
}
count
};
enum class trophy_game_list_columns
{
icon = 0,
name = 1,
progress = 2,
count
};
QString get_trophy_game_list_column_name(trophy_game_list_columns col);
QString get_trophy_list_column_name(trophy_list_columns col);
QString get_game_list_column_name(game_list_columns col);
const QSize gl_icon_size_min = QSize(40, 22);
const QSize gl_icon_size_small = QSize(80, 44);
@ -295,23 +280,29 @@ public:
bool GetBootConfirmation(QWidget* parent, const gui_save& gui_save_entry = gui_save());
logs::level GetLogLevel() const;
bool GetGamelistColVisibility(int col) const;
bool GetTrophyGamelistColVisibility(gui::trophy_game_list_columns col) const;
bool GetTrophylistColVisibility(gui::trophy_list_columns col) const;
bool GetGamelistColVisibility(gui::game_list_columns col) const;
QColor GetCustomColor(int col) const;
QStringList GetStylesheetEntries() const;
QStringList GetGameListCategoryFilters(bool is_list_mode) const;
public Q_SLOTS:
static QSize SizeFromSlider(int pos);
/** Sets the visibility of the chosen category. */
void SetCategoryVisibility(int cat, bool val, bool is_list_mode) const;
void SetGamelistColVisibility(int col, bool val) const;
void SetTrophyGamelistColVisibility(gui::trophy_game_list_columns col, bool val) const;
void SetTrophylistColVisibility(gui::trophy_list_columns col, bool val) const;
void SetGamelistColVisibility(gui::game_list_columns col, bool val) const;
void SetCustomColor(int col, const QColor& val) const;
static QSize SizeFromSlider(int pos);
static gui_save GetGuiSaveForColumn(int col);
private:
static gui_save GetGuiSaveForTrophyGameColumn(gui::trophy_game_list_columns col);
static gui_save GetGuiSaveForTrophyColumn(gui::trophy_list_columns col);
static gui_save GetGuiSaveForGameColumn(gui::game_list_columns col);
static gui_save GetGuiSaveForCategory(int cat, bool is_list_mode);
private:
void ShowBox(QMessageBox::Icon icon, const QString& title, const QString& text, const gui_save& entry, int* result, QWidget* parent, bool always_on_top);
};

2
rpcs3/rpcs3qt/table_item_delegate.cpp
View File

@ -26,7 +26,7 @@ void table_item_delegate::initStyleOption(QStyleOptionViewItem *option, const QM
void table_item_delegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
if (m_has_icons && index.column() == gui::game_list_columns::column_icon && option.state & QStyle::State_Selected)
if (m_has_icons && index.column() == static_cast<int>(gui::game_list_columns::icon) && option.state & QStyle::State_Selected)
{
// Add background highlight color to icons
painter->fillRect(option.rect, option.palette.color(QPalette::Highlight));

130
rpcs3/rpcs3qt/trophy_manager_dialog.cpp
View File

@ -41,28 +41,6 @@ namespace
inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
}
enum TrophyColumns
{
Icon = 0,
Name = 1,
Description = 2,
Type = 3,
IsUnlocked = 4,
Id = 5,
PlatinumLink = 6,
Count
};
enum GameColumns
{
GameIcon = 0,
GameName = 1,
GameProgress = 2,
GameColumnsCount
};
enum GameUserRole
{
GameIndex = Qt::UserRole,
@ -116,8 +94,7 @@ trophy_manager_dialog::trophy_manager_dialog(std::shared_ptr<gui_settings> gui_s
m_game_table->setSelectionBehavior(QAbstractItemView::SelectRows);
m_game_table->setSelectionMode(QAbstractItemView::SingleSelection);
m_game_table->setEditTriggers(QAbstractItemView::NoEditTriggers);
m_game_table->setColumnCount(GameColumns::GameColumnsCount);
m_game_table->setHorizontalHeaderLabels(QStringList{ tr("Icon"), tr("Game"), tr("Progress") });
m_game_table->setColumnCount(static_cast<int>(gui::trophy_game_list_columns::count));
m_game_table->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
m_game_table->horizontalHeader()->setStretchLastSection(true);
m_game_table->verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
@ -126,6 +103,16 @@ trophy_manager_dialog::trophy_manager_dialog(std::shared_ptr<gui_settings> gui_s
m_game_table->setAlternatingRowColors(true);
m_game_table->installEventFilter(this);
auto add_game_column = [this](gui::trophy_game_list_columns col, const QString& header_text, const QString& action_text)
{
m_game_table->setHorizontalHeaderItem(static_cast<int>(col), new QTableWidgetItem(header_text));
m_game_column_acts.append(new QAction(action_text, this));
};
add_game_column(gui::trophy_game_list_columns::icon, tr("Icon"), tr("Show Icons"));
add_game_column(gui::trophy_game_list_columns::name, tr("Game"), tr("Show Games"));
add_game_column(gui::trophy_game_list_columns::progress, tr("Progress"), tr("Show Progress"));
// Trophy Table
m_trophy_table = new game_list();
m_trophy_table->setObjectName("trophy_manager_trophy_table");
@ -138,17 +125,30 @@ trophy_manager_dialog::trophy_manager_dialog(std::shared_ptr<gui_settings> gui_s
m_trophy_table->setItemDelegate(new game_list_delegate(m_trophy_table));
m_trophy_table->setSelectionBehavior(QAbstractItemView::SelectRows);
m_trophy_table->setEditTriggers(QAbstractItemView::NoEditTriggers);
m_trophy_table->setColumnCount(TrophyColumns::Count);
m_trophy_table->setHorizontalHeaderLabels(QStringList{ tr("Icon"), tr("Name"), tr("Description"), tr("Type"), tr("Status"), tr("ID"), tr("Platinum Relevant") });
m_trophy_table->setColumnCount(static_cast<int>(gui::trophy_list_columns::count));
m_trophy_table->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
m_trophy_table->horizontalHeader()->setStretchLastSection(true);
m_trophy_table->horizontalHeader()->setSectionResizeMode(TrophyColumns::Icon, QHeaderView::Fixed);
m_trophy_table->horizontalHeader()->setSectionResizeMode(static_cast<int>(gui::trophy_list_columns::icon), QHeaderView::Fixed);
m_trophy_table->verticalHeader()->setVisible(false);
m_trophy_table->verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
m_trophy_table->setContextMenuPolicy(Qt::CustomContextMenu);
m_trophy_table->setAlternatingRowColors(true);
m_trophy_table->installEventFilter(this);
auto add_trophy_column = [this](gui::trophy_list_columns col, const QString& header_text, const QString& action_text)
{
m_trophy_table->setHorizontalHeaderItem(static_cast<int>(col), new QTableWidgetItem(header_text));
m_trophy_column_acts.append(new QAction(action_text, this));
};
add_trophy_column(gui::trophy_list_columns::icon, tr("Icon"), tr("Show Icons"));
add_trophy_column(gui::trophy_list_columns::name, tr("Name"), tr("Show Names"));
add_trophy_column(gui::trophy_list_columns::description, tr("Description"), tr("Show Descriptions"));
add_trophy_column(gui::trophy_list_columns::type, tr("Type"), tr("Show Types"));
add_trophy_column(gui::trophy_list_columns::is_unlocked, tr("Status"), tr("Show Status"));
add_trophy_column(gui::trophy_list_columns::id, tr("ID"), tr("Show IDs"));
add_trophy_column(gui::trophy_list_columns::platinum_link, tr("Platinum Relevant"), tr("Show Platinum Relevant"));
m_splitter = new QSplitter();
m_splitter->addWidget(m_game_table);
m_splitter->addWidget(m_trophy_table);
@ -364,7 +364,7 @@ trophy_manager_dialog::trophy_manager_dialog(std::shared_ptr<gui_settings> gui_s
{
return;
}
QTableWidgetItem* item = m_game_table->item(m_game_table->selectedItems().first()->row(), GameColumns::GameName);
QTableWidgetItem* item = m_game_table->item(m_game_table->selectedItems().first()->row(), static_cast<int>(gui::trophy_game_list_columns::name));
if (!item)
{
return;
@ -374,7 +374,7 @@ trophy_manager_dialog::trophy_manager_dialog(std::shared_ptr<gui_settings> gui_s
connect(this, &trophy_manager_dialog::TrophyIconReady, this, [this](int index, const QPixmap& pixmap)
{
if (QTableWidgetItem* icon_item = m_trophy_table->item(index, TrophyColumns::Icon))
if (QTableWidgetItem* icon_item = m_trophy_table->item(index, static_cast<int>(gui::trophy_list_columns::icon)))
{
icon_item->setData(Qt::DecorationRole, pixmap);
}
@ -382,12 +382,20 @@ trophy_manager_dialog::trophy_manager_dialog(std::shared_ptr<gui_settings> gui_s
connect(this, &trophy_manager_dialog::GameIconReady, this, [this](int index, const QPixmap& pixmap)
{
if (QTableWidgetItem* icon_item = m_game_table->item(index, GameColumns::GameIcon))
if (QTableWidgetItem* icon_item = m_game_table->item(index, static_cast<int>(gui::trophy_game_list_columns::icon)))
{
icon_item->setData(Qt::DecorationRole, pixmap);
}
});
m_trophy_table->create_header_actions(m_trophy_column_acts,
[this](int col) { return m_gui_settings->GetTrophylistColVisibility(static_cast<gui::trophy_list_columns>(col)); },
[this](int col, bool visible) { m_gui_settings->SetTrophylistColVisibility(static_cast<gui::trophy_list_columns>(col), visible); });
m_game_table->create_header_actions(m_game_column_acts,
[this](int col) { return m_gui_settings->GetTrophyGamelistColVisibility(static_cast<gui::trophy_game_list_columns>(col)); },
[this](int col, bool visible) { m_gui_settings->SetTrophyGamelistColVisibility(static_cast<gui::trophy_game_list_columns>(col), visible); });
RepaintUI(true);
StartTrophyLoadThreads();
@ -553,7 +561,7 @@ void trophy_manager_dialog::ResizeGameIcons()
{
indices.append(i);
if (QTableWidgetItem* icon_item = m_game_table->item(i, GameColumns::GameIcon))
if (QTableWidgetItem* icon_item = m_game_table->item(i, static_cast<int>(gui::trophy_game_list_columns::icon)))
{
icon_item->setData(Qt::DecorationRole, placeholder);
}
@ -563,7 +571,7 @@ void trophy_manager_dialog::ResizeGameIcons()
for (int i = 0; i < m_game_table->rowCount(); ++i)
{
if (movie_item* item = static_cast<movie_item*>(m_game_table->item(i, GameColumns::GameIcon)))
if (movie_item* item = static_cast<movie_item*>(m_game_table->item(i, static_cast<int>(gui::trophy_game_list_columns::icon))))
{
const qreal dpr = devicePixelRatioF();
const int trophy_index = item->data(GameUserRole::GameIndex).toInt();
@ -578,7 +586,7 @@ void trophy_manager_dialog::ResizeGameIcons()
QPixmap icon;
if (movie_item* item = static_cast<movie_item*>(m_game_table->item(index, GameColumns::GameIcon)))
if (movie_item* item = static_cast<movie_item*>(m_game_table->item(index, static_cast<int>(gui::trophy_game_list_columns::icon))))
{
if (!item->data(GameUserRole::GamePixmapLoaded).toBool())
{
@ -641,7 +649,7 @@ void trophy_manager_dialog::ResizeTrophyIcons()
for (int i = 0; i < m_trophy_table->rowCount(); ++i)
{
if (QTableWidgetItem* icon_item = m_trophy_table->item(i, TrophyColumns::Icon))
if (QTableWidgetItem* icon_item = m_trophy_table->item(i, static_cast<int>(gui::trophy_list_columns::icon)))
{
icon_item->setData(Qt::DecorationRole, placeholder);
}
@ -651,9 +659,9 @@ void trophy_manager_dialog::ResizeTrophyIcons()
for (int i = 0; i < m_trophy_table->rowCount(); ++i)
{
if (QTableWidgetItem* id_item = m_trophy_table->item(i, TrophyColumns::Id))
if (QTableWidgetItem* id_item = m_trophy_table->item(i, static_cast<int>(gui::trophy_list_columns::id)))
{
if (movie_item* item = static_cast<movie_item*>(m_trophy_table->item(i, TrophyColumns::Icon)))
if (movie_item* item = static_cast<movie_item*>(m_trophy_table->item(i, static_cast<int>(gui::trophy_list_columns::icon))))
{
item->set_icon_load_func([this, data = ::at32(m_trophies_db, db_pos).get(), trophy_id = id_item->text().toInt(), cancel = item->icon_loading_aborted(), dpr, new_height](int index)
{
@ -740,9 +748,9 @@ void trophy_manager_dialog::ApplyFilter()
for (int i = 0; i < m_trophy_table->rowCount(); ++i)
{
QTableWidgetItem* item = m_trophy_table->item(i, TrophyColumns::Id);
QTableWidgetItem* type_item = m_trophy_table->item(i, TrophyColumns::Type);
QTableWidgetItem* icon_item = m_trophy_table->item(i, TrophyColumns::Icon);
QTableWidgetItem* item = m_trophy_table->item(i, static_cast<int>(gui::trophy_list_columns::id));
QTableWidgetItem* type_item = m_trophy_table->item(i, static_cast<int>(gui::trophy_list_columns::type));
QTableWidgetItem* icon_item = m_trophy_table->item(i, static_cast<int>(gui::trophy_list_columns::icon));
if (!item || !type_item || !icon_item)
{
@ -784,7 +792,7 @@ void trophy_manager_dialog::ShowTrophyTableContextMenu(const QPoint& pos)
{
const int row = m_trophy_table->currentRow();
if (!m_trophy_table->item(row, TrophyColumns::Icon))
if (!m_trophy_table->item(row, static_cast<int>(gui::trophy_list_columns::icon)))
{
return;
}
@ -802,8 +810,8 @@ void trophy_manager_dialog::ShowTrophyTableContextMenu(const QPoint& pos)
menu->addAction(show_trophy_dir);
const QTableWidgetItem* name_item = m_trophy_table->item(row, TrophyColumns::Name);
const QTableWidgetItem* desc_item = m_trophy_table->item(row, TrophyColumns::Description);
const QTableWidgetItem* name_item = m_trophy_table->item(row, static_cast<int>(gui::trophy_list_columns::name));
const QTableWidgetItem* desc_item = m_trophy_table->item(row, static_cast<int>(gui::trophy_list_columns::description));
const QString name = name_item ? name_item->text() : "";
const QString desc = desc_item ? desc_item->text() : "";
@ -852,7 +860,7 @@ void trophy_manager_dialog::ShowGameTableContextMenu(const QPoint& pos)
{
const int row = m_game_table->currentRow();
if (!m_game_table->item(row, GameColumns::GameIcon))
if (!m_game_table->item(row, static_cast<int>(gui::trophy_game_list_columns::icon)))
{
return;
}
@ -870,7 +878,7 @@ void trophy_manager_dialog::ShowGameTableContextMenu(const QPoint& pos)
menu->addAction(show_trophy_dir);
const QTableWidgetItem* name_item = m_game_table->item(row, GameColumns::GameName);
const QTableWidgetItem* name_item = m_game_table->item(row, static_cast<int>(gui::trophy_game_list_columns::name));
const QString name = name_item ? name_item->text() : "";
if (!name.isEmpty())
@ -980,9 +988,9 @@ void trophy_manager_dialog::PopulateGameTable()
icon_item->setData(GameUserRole::GamePixmapLoaded, false);
icon_item->setData(GameUserRole::GamePixmap, QPixmap());
m_game_table->setItem(i, GameColumns::GameIcon, icon_item);
m_game_table->setItem(i, GameColumns::GameName, new custom_table_widget_item(name));
m_game_table->setItem(i, GameColumns::GameProgress, new custom_table_widget_item(progress, Qt::UserRole, percentage));
m_game_table->setItem(i, static_cast<int>(gui::trophy_game_list_columns::icon), icon_item);
m_game_table->setItem(i, static_cast<int>(gui::trophy_game_list_columns::name), new custom_table_widget_item(name));
m_game_table->setItem(i, static_cast<int>(gui::trophy_game_list_columns::progress), new custom_table_widget_item(progress, Qt::UserRole, percentage));
m_game_combo->addItem(name, i);
}
@ -1080,13 +1088,13 @@ void trophy_manager_dialog::PopulateTrophyTable()
custom_table_widget_item* type_item = new custom_table_widget_item(trophy_type);
type_item->setData(Qt::UserRole, static_cast<uint>(details.trophyGrade), true);
m_trophy_table->setItem(i, TrophyColumns::Icon, icon_item);
m_trophy_table->setItem(i, TrophyColumns::Name, new custom_table_widget_item(qstr(details.name)));
m_trophy_table->setItem(i, TrophyColumns::Description, new custom_table_widget_item(qstr(details.description)));
m_trophy_table->setItem(i, TrophyColumns::Type, type_item);
m_trophy_table->setItem(i, TrophyColumns::IsUnlocked, new custom_table_widget_item(unlockstate));
m_trophy_table->setItem(i, TrophyColumns::Id, new custom_table_widget_item(QString::number(trophy_id), Qt::UserRole, trophy_id));
m_trophy_table->setItem(i, TrophyColumns::PlatinumLink, new custom_table_widget_item(platinum_relevant, Qt::UserRole, platinum_link_id));
m_trophy_table->setItem(i, static_cast<int>(gui::trophy_list_columns::icon), icon_item);
m_trophy_table->setItem(i, static_cast<int>(gui::trophy_list_columns::name), new custom_table_widget_item(qstr(details.name)));
m_trophy_table->setItem(i, static_cast<int>(gui::trophy_list_columns::description), new custom_table_widget_item(qstr(details.description)));
m_trophy_table->setItem(i, static_cast<int>(gui::trophy_list_columns::type), type_item);
m_trophy_table->setItem(i, static_cast<int>(gui::trophy_list_columns::is_unlocked), new custom_table_widget_item(unlockstate));
m_trophy_table->setItem(i, static_cast<int>(gui::trophy_list_columns::id), new custom_table_widget_item(QString::number(trophy_id), Qt::UserRole, trophy_id));
m_trophy_table->setItem(i, static_cast<int>(gui::trophy_list_columns::platinum_link), new custom_table_widget_item(platinum_relevant, Qt::UserRole, platinum_link_id));
++i;
}
@ -1104,11 +1112,11 @@ void trophy_manager_dialog::ReadjustGameTable() const
m_game_table->resizeRowsToContents();
// Resize and fixate icon column
m_game_table->resizeColumnToContents(GameColumns::GameIcon);
m_game_table->horizontalHeader()->setSectionResizeMode(GameColumns::GameIcon, QHeaderView::Fixed);
m_game_table->resizeColumnToContents(static_cast<int>(gui::trophy_game_list_columns::icon));
m_game_table->horizontalHeader()->setSectionResizeMode(static_cast<int>(gui::trophy_game_list_columns::icon), QHeaderView::Fixed);
// Shorten the last section to remove horizontal scrollbar if possible
m_game_table->resizeColumnToContents(GameColumns::GameColumnsCount - 1);
m_game_table->resizeColumnToContents(static_cast<int>(gui::trophy_game_list_columns::count) - 1);
}
void trophy_manager_dialog::ReadjustTrophyTable() const
@ -1119,10 +1127,10 @@ void trophy_manager_dialog::ReadjustTrophyTable() const
m_trophy_table->resizeRowsToContents();
// Resize and fixate icon column
m_trophy_table->resizeColumnToContents(TrophyColumns::Icon);
m_trophy_table->resizeColumnToContents(static_cast<int>(gui::trophy_list_columns::icon));
// Shorten the last section to remove horizontal scrollbar if possible
m_trophy_table->resizeColumnToContents(TrophyColumns::Count - 1);
m_trophy_table->resizeColumnToContents(static_cast<int>(gui::trophy_list_columns::count) - 1);
}
bool trophy_manager_dialog::eventFilter(QObject *object, QEvent *event)
@ -1200,7 +1208,7 @@ void trophy_manager_dialog::WaitAndAbortGameRepaintThreads()
{
for (int i = 0; i < m_game_table->rowCount(); i++)
{
if (movie_item* item = static_cast<movie_item*>(m_game_table->item(i, GameColumns::GameIcon)))
if (movie_item* item = static_cast<movie_item*>(m_game_table->item(i, static_cast<int>(gui::trophy_game_list_columns::icon))))
{
item->wait_for_icon_loading(true);
}
@ -1211,7 +1219,7 @@ void trophy_manager_dialog::WaitAndAbortTrophyRepaintThreads()
{
for (int i = 0; i < m_trophy_table->rowCount(); i++)
{
if (movie_item* item = static_cast<movie_item*>(m_trophy_table->item(i, TrophyColumns::Icon)))
if (movie_item* item = static_cast<movie_item*>(m_trophy_table->item(i, static_cast<int>(gui::trophy_list_columns::icon))))
{
item->wait_for_icon_loading(true);
}

3
rpcs3/rpcs3qt/trophy_manager_dialog.h
View File

@ -90,6 +90,9 @@ private:
game_list* m_trophy_table; //! UI element to display trophy stuff.
game_list* m_game_table; //! UI element to display games.
QList<QAction*> m_trophy_column_acts;
QList<QAction*> m_game_column_acts;
bool m_show_hidden_trophies = false;
bool m_show_unlocked_trophies = true;
bool m_show_locked_trophies = true;