- Gui rewrite.

- Gui: Bug fixes and cleanup.
- Gui: Performance improvement (loading, resizing...etc)
- Added a simple PKG Viewer(Settings-> Utils -> PKG Viewer), added pkg folders will be saved.
- PKG Viewer: Shows game info(name, id, region...etc)
- PKG Viewer: Right click -> Install PKG to install/extract a game. Patch installation is also possible.
- Added option to dump game list  (Settings -> Utils -> Dump Game List), will be dumped to emu folder GameList.txt

CMakeLists.txt

@@ -152,26 +152,21 @@ qt_add_resources(RESOURCE_FILES src/shadps4.qrc)
     src/qt_gui/main_window.h
     src/qt_gui/gui_settings.cpp
     src/qt_gui/gui_settings.h
-    src/qt_gui/settings.cpp
-    src/qt_gui/settings.h
     src/qt_gui/gui_save.h
-    src/qt_gui/custom_dock_widget.h
+    src/qt_gui/gui_context_menus.h
-    src/qt_gui/custom_table_widget_item.cpp
-    src/qt_gui/custom_table_widget_item.h
-    src/qt_gui/game_list_item.h
-    src/qt_gui/game_list_table.cpp
-    src/qt_gui/game_list_table.h
     src/qt_gui/game_list_utils.h
+    src/qt_gui/game_info.cpp
     src/qt_gui/game_info.h
-    src/qt_gui/game_list_grid.cpp
-    src/qt_gui/game_list_grid.h
-    src/qt_gui/game_list_grid_delegate.cpp
-    src/qt_gui/game_list_grid_delegate.h
     src/qt_gui/game_list_frame.cpp
     src/qt_gui/game_list_frame.h
-    src/qt_gui/qt_utils.h
+    src/qt_gui/game_grid_frame.cpp
+    src/qt_gui/game_grid_frame.h
     src/qt_gui/game_install_dialog.cpp
     src/qt_gui/game_install_dialog.h
+    src/qt_gui/pkg_viewer.cpp
+    src/qt_gui/pkg_viewer.h
+    src/qt_gui/settings.cpp
+    src/qt_gui/settings.h
     src/qt_gui/main_window_themes.cpp
     src/qt_gui/main_window_themes.h
     src/qt_gui/main.cpp

src/core/file_format/pkg.h

@@ -73,6 +73,19 @@ struct PKGHeader {
     u8 pkg_digest[0x20];
 };
 
+enum class PKGContentFlag {
+    FIRST_PATCH = 0x100000,
+    PATCHGO = 0x200000,
+    REMASTER = 0x400000,
+    PS_CLOUD = 0x800000,
+    GD_AC = 0x2000000,
+    NON_GAME = 0x4000000,
+    UNKNOWN_0x8000000 = 0x8000000,
+    SUBSEQUENT_PATCH = 0x40000000,
+    DELTA_PATCH = 0x41000000,
+    CUMULATIVE_PATCH = 0x60000000
+};
+
 struct PKGEntry {
     u32_be id;              // File ID, useful for files without a filename entry
     u32_be filename_offset; // Offset into the filenames table (ID 0x200) where this file's name is

src/qt_gui/custom_dock_widget.h

@@ -1,62 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <QDockWidget>
-#include <QPainter>
-#include <QStyleOption>
-
-class CustomDockWidget : public QDockWidget {
-private:
-    std::shared_ptr<QWidget> m_title_bar_widget;
-    bool m_is_title_bar_visible = true;
-
-public:
-    explicit CustomDockWidget(const QString& title, QWidget* parent = Q_NULLPTR,
-                              Qt::WindowFlags flags = Qt::WindowFlags())
-        : QDockWidget(title, parent, flags) {
-        m_title_bar_widget.reset(titleBarWidget());
-
-        connect(this, &QDockWidget::topLevelChanged, [this](bool /* topLevel*/) {
-            SetTitleBarVisible(m_is_title_bar_visible);
-            style()->unpolish(this);
-            style()->polish(this);
-        });
-    }
-
-    void SetTitleBarVisible(bool visible) {
-        if (visible || isFloating()) {
-            if (m_title_bar_widget.get() != titleBarWidget()) {
-                setTitleBarWidget(m_title_bar_widget.get());
-                QMargins margins = widget()->contentsMargins();
-                margins.setTop(0);
-                widget()->setContentsMargins(margins);
-            }
-        } else {
-            setTitleBarWidget(new QWidget());
-            QMargins margins = widget()->contentsMargins();
-            margins.setTop(1);
-            widget()->setContentsMargins(margins);
-        }
-
-        m_is_title_bar_visible = visible;
-    }
-
-protected:
-    void paintEvent(QPaintEvent* event) override {
-        // We need to repaint the dock widgets as plain widgets in floating mode.
-        // Source:
-        // https://stackoverflow.com/questions/10272091/cannot-add-a-background-image-to-a-qdockwidget
-        if (isFloating()) {
-            QStyleOption opt;
-            opt.initFrom(this);
-            QPainter p(this);
-            style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
-            return;
-        }
-
-        // Use inherited method for docked mode because otherwise the dock would lose the title etc.
-        QDockWidget::paintEvent(event);
-    }
-};

src/qt_gui/custom_table_widget_item.cpp

@@ -1,67 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <QDateTime>
-#include "custom_table_widget_item.h"
-
-CustomTableWidgetItem::CustomTableWidgetItem(const std::string& text, int sort_role,
-                                             const QVariant& sort_value)
-    : GameListItem(
-          QString::fromStdString(text).simplified()) // simplified() forces single line text
-{
-    if (sort_role != Qt::DisplayRole) {
-        setData(sort_role, sort_value, true);
-    }
-}
-
-CustomTableWidgetItem::CustomTableWidgetItem(const QString& text, int sort_role,
-                                             const QVariant& sort_value)
-    : GameListItem(text.simplified()) // simplified() forces single line text
-{
-    if (sort_role != Qt::DisplayRole) {
-        setData(sort_role, sort_value, true);
-    }
-}
-
-bool CustomTableWidgetItem::operator<(const QTableWidgetItem& other) const {
-    if (m_sort_role == Qt::DisplayRole) {
-        return QTableWidgetItem::operator<(other);
-    }
-
-    const QVariant data_l = data(m_sort_role);
-    const QVariant data_r = other.data(m_sort_role);
-    const QVariant::Type type_l = data_l.type();
-    const QVariant::Type type_r = data_r.type();
-
-    switch (type_l) {
-    case QVariant::Type::Bool:
-    case QVariant::Type::Int:
-        return data_l.toInt() < data_r.toInt();
-    case QVariant::Type::UInt:
-        return data_l.toUInt() < data_r.toUInt();
-    case QVariant::Type::LongLong:
-        return data_l.toLongLong() < data_r.toLongLong();
-    case QVariant::Type::ULongLong:
-        return data_l.toULongLong() < data_r.toULongLong();
-    case QVariant::Type::Double:
-        return data_l.toDouble() < data_r.toDouble();
-    case QVariant::Type::Date:
-        return data_l.toDate() < data_r.toDate();
-    case QVariant::Type::Time:
-        return data_l.toTime() < data_r.toTime();
-    case QVariant::Type::DateTime:
-        return data_l.toDateTime() < data_r.toDateTime();
-    case QVariant::Type::Char:
-    case QVariant::Type::String:
-        return data_l.toString() < data_r.toString();
-    default:
-        throw std::runtime_error("unsupported type");
-    }
-}
-
-void CustomTableWidgetItem::setData(int role, const QVariant& value, bool assign_sort_role) {
-    if (assign_sort_role) {
-        m_sort_role = role;
-    }
-    QTableWidgetItem::setData(role, value);
-}

src/qt_gui/custom_table_widget_item.h

@@ -1,26 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <QTableWidgetItem>
-
-#include "game_list_item.h"
-
-class CustomTableWidgetItem : public GameListItem {
-private:
-    int m_sort_role = Qt::DisplayRole;
-
-public:
-    using QTableWidgetItem::setData;
-
-    CustomTableWidgetItem() = default;
-    CustomTableWidgetItem(const std::string& text, int sort_role = Qt::DisplayRole,
-                          const QVariant& sort_value = 0);
-    CustomTableWidgetItem(const QString& text, int sort_role = Qt::DisplayRole,
-                          const QVariant& sort_value = 0);
-
-    bool operator<(const QTableWidgetItem& other) const override;
-
-    void setData(int role, const QVariant& value, bool assign_sort_role);
-};

src/qt_gui/game_grid_frame.cpp

@@ -0,0 +1,154 @@
+#include "game_grid_frame.h"
+
+GameGridFrame::GameGridFrame(std::shared_ptr<GameInfoClass> game_info_get,
+                             std::shared_ptr<GuiSettings> m_gui_settings, QWidget* parent)
+    : QTableWidget(parent) {
+    m_game_info = game_info_get;
+    m_gui_settings_ = m_gui_settings;
+    icon_size = m_gui_settings->GetValue(gui::m_icon_size_grid).toInt();
+    windowWidth = parent->width();
+    this->setShowGrid(false);
+    this->setEditTriggers(QAbstractItemView::NoEditTriggers);
+    this->setSelectionBehavior(QAbstractItemView::SelectItems);
+    this->setSelectionMode(QAbstractItemView::SingleSelection);
+    this->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
+    this->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
+    this->verticalScrollBar()->installEventFilter(this);
+    this->verticalScrollBar()->setSingleStep(20);
+    this->horizontalScrollBar()->setSingleStep(20);
+    this->horizontalHeader()->setVisible(false);
+    this->verticalHeader()->setVisible(false);
+    this->setContextMenuPolicy(Qt::CustomContextMenu);
+    PopulateGameGrid(m_game_info->m_games, false);
+
+    connect(this, &QTableWidget::cellClicked, this, &GameGridFrame::SetGridBackgroundImage);
+
+    connect(this->verticalScrollBar(), &QScrollBar::valueChanged, this,
+            &GameGridFrame::RefreshGridBackgroundImage);
+    connect(this->horizontalScrollBar(), &QScrollBar::valueChanged, this,
+            &GameGridFrame::RefreshGridBackgroundImage);
+    connect(this, &QTableWidget::customContextMenuRequested, this, [=, this](const QPoint& pos) {
+        m_gui_context_menus.RequestGameMenu(pos, m_game_info->m_games, this, false);
+    });
+}
+
+void GameGridFrame::PopulateGameGrid(QVector<GameInfo> m_games_search, bool fromSearch) {
+    QVector<GameInfo> m_games_;
+    this->clearContents();
+    if (fromSearch)
+        m_games_ = m_games_search;
+    else
+        m_games_ = m_game_info->m_games;
+    m_games_shared = std::make_shared<QVector<GameInfo>>(m_games_);
+
+    icon_size = m_gui_settings_->GetValue(gui::m_icon_size_grid)
+                    .toInt(); // update icon size for resize event.
+
+    int gamesPerRow = windowWidth / (icon_size + 20); // 2 x cell widget border size.
+    int row = 0;
+    int gameCounter = 0;
+    int rowCount = m_games_.size() / gamesPerRow;
+    if (m_games_.size() % gamesPerRow != 0) {
+        rowCount += 1; // Add an extra row for the remainder
+    }
+    std::vector<int> indices;
+    for (int i = 0; i < m_games_.size(); i++) {
+        indices.push_back(i);
+    }
+    std::vector<std::future<QPixmap>> futures;
+    for (int index : indices) {
+        futures.push_back(std::async(std::launch::async, [=, this]() {
+            return m_games_[index].icon.scaled(QSize(icon_size, icon_size), Qt::IgnoreAspectRatio,
+                                               Qt::SmoothTransformation);
+        }));
+    }
+
+    std::vector<QPixmap> scaledPixmaps;
+    for (auto& future : futures) {
+        scaledPixmaps.push_back(future.get());
+    }
+    int column = 0;
+    this->setColumnCount(gamesPerRow);
+    this->setRowCount(rowCount);
+    for (int i = 0; i < m_games_.size(); i++) {
+        QWidget* widget = new QWidget();
+        QVBoxLayout* layout = new QVBoxLayout();
+        QLabel* image_label = new QLabel();
+        image_label->setFixedSize(scaledPixmaps[gameCounter].width(),
+                                  scaledPixmaps[gameCounter].height());
+        image_label->setPixmap(scaledPixmaps[gameCounter]);
+        QLabel* name_label = new QLabel(QString::fromStdString(m_games_[gameCounter].serial));
+        name_label->setAlignment(Qt::AlignHCenter);
+        layout->addWidget(image_label);
+        layout->addWidget(name_label);
+
+        name_label->setStyleSheet("color: white; font-size: 12px; font-weight: bold;");
+        QGraphicsDropShadowEffect* shadowEffect = new QGraphicsDropShadowEffect();
+        shadowEffect->setBlurRadius(5);               // Set the blur radius of the shadow
+        shadowEffect->setColor(QColor(0, 0, 0, 160)); // Set the color and opacity of the shadow
+        shadowEffect->setOffset(2, 2);                // Set the offset of the shadow
+
+        name_label->setGraphicsEffect(shadowEffect);
+        widget->setLayout(layout);
+        QString tooltipText = QString::fromStdString(m_games_[gameCounter].name);
+        widget->setToolTip(tooltipText);
+        QString tooltipStyle = QString("QToolTip {"
+                                       "background-color: #ffffff;"
+                                       "color: #000000;"
+                                       "border: 1px solid #000000;"
+                                       "padding: 2px;"
+                                       "font-size: 12px; }")
+                                   .arg(tooltipText);
+        widget->setStyleSheet(tooltipStyle);
+        this->setCellWidget(row, column, widget);
+
+        column++;
+        if (column == gamesPerRow) {
+            column = 0;
+            row++;
+        }
+
+        gameCounter++;
+        if (gameCounter >= m_games_.size()) {
+            break;
+        }
+    }
+    m_games_.clear();
+    this->resizeRowsToContents();
+    this->resizeColumnsToContents();
+}
+
+void GameGridFrame::SetGridBackgroundImage(int row, int column) {
+
+    int itemID = (row * this->columnCount()) + column;
+    QWidget* item = this->cellWidget(row, column);
+    if (item) {
+        QString pic1Path = QString::fromStdString((*m_games_shared)[itemID].pic_path);
+        QString blurredPic1Path =
+            qApp->applicationDirPath() +
+            QString::fromStdString("/game_data/" + (*m_games_shared)[itemID].serial + "/pic1.png");
+
+        backgroundImage = QImage(blurredPic1Path);
+        if (backgroundImage.isNull()) {
+            QImage image(pic1Path);
+            backgroundImage = m_game_list_utils.BlurImage(image, image.rect(), 16);
+
+            std::filesystem::path img_path =
+                std::filesystem::path("game_data/") / (*m_games_shared)[itemID].serial;
+            std::filesystem::create_directories(img_path);
+            if (!backgroundImage.save(blurredPic1Path, "PNG")) {
+                // qDebug() << "Error: Unable to save image.";
+            }
+        }
+        RefreshGridBackgroundImage();
+    }
+}
+
+void GameGridFrame::RefreshGridBackgroundImage() {
+    QPixmap blurredPixmap = QPixmap::fromImage(backgroundImage);
+    QPalette palette;
+    palette.setBrush(QPalette::Base, QBrush(blurredPixmap.scaled(size(), Qt::IgnoreAspectRatio)));
+    QColor transparentColor = QColor(135, 206, 235, 40);
+    palette.setColor(QPalette::Highlight, transparentColor);
+    this->setPalette(palette);
+}

src/qt_gui/game_grid_frame.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <QFutureWatcher>
+#include <QGraphicsBlurEffect>
+#include <QHeaderView>
+#include <QLabel>
+#include <QPixmap>
+#include <QScrollBar>
+#include <QStyleOptionViewItem>
+#include <QTableWidget>
+#include <QVBoxLayout>
+#include <QWidget>
+#include <QtConcurrent/QtConcurrent>
+#include "game_info.h"
+#include "game_list_utils.h"
+#include "gui_context_menus.h"
+
+class GameGridFrame : public QTableWidget {
+    Q_OBJECT
+
+Q_SIGNALS:
+    void GameGridFrameClosed();
+
+public Q_SLOTS:
+    void SetGridBackgroundImage(int row, int column);
+    void RefreshGridBackgroundImage();
+
+private:
+    QImage backgroundImage;
+    GameListUtils m_game_list_utils;
+    GuiContextMenus m_gui_context_menus;
+    std::shared_ptr<GameInfoClass> m_game_info;
+    std::shared_ptr<GuiSettings> m_gui_settings_;
+    std::shared_ptr<QVector<GameInfo>> m_games_shared;
+
+public:
+    explicit GameGridFrame(std::shared_ptr<GameInfoClass> game_info_get,
+                           std::shared_ptr<GuiSettings> m_gui_settings, QWidget* parent = nullptr);
+    void PopulateGameGrid(QVector<GameInfo> m_games, bool fromSearch);
+
+    int icon_size;
+    int windowWidth;
+};

src/qt_gui/game_info.cpp

@@ -0,0 +1,24 @@
+#include <future>
+#include <thread>
+#include "game_info.h"
+
+void GameInfoClass::GetGameInfo() {
+    QString installDir = m_gui_settings->GetValue(gui::settings_install_dir).toString();
+    std::filesystem::path parent_folder(installDir.toStdString());
+    std::vector<std::string> filePaths;
+    for (const auto& dir : std::filesystem::directory_iterator(parent_folder)) {
+        if (dir.is_directory()) {
+            filePaths.push_back(dir.path().string());
+        }
+    }
+    std::vector<std::future<GameInfo>> futures;
+
+    for (const auto& filePath : filePaths) {
+        futures.emplace_back(std::async(std::launch::async, readGameInfo, filePath));
+    }
+
+    for (auto& future : futures) {
+        m_games.push_back(future.get());
+    }
+    std::sort(m_games.begin(), m_games.end(), CompareStrings);
+}

src/qt_gui/game_info.h

@@ -4,17 +4,62 @@
 #pragma once
 
 #include <string>
+#include <QFuture>
+#include <QPixmap>
+#include <QtConcurrent/QtConcurrent>
+#include "core/file_format/psf.h"
+#include "game_list_utils.h"
+#include "gui_settings.h"
 
 struct GameInfo {
     std::string path; // root path of game directory (normaly directory that contains eboot.bin)
     std::string icon_path; // path of icon0.png
     std::string pic_path;  // path of pic1.png
-
+    QPixmap icon;
+    std::string size;
     // variables extracted from param.sfo
     std::string name = "Unknown";
     std::string serial = "Unknown";
-    std::string app_ver = "Unknown";
     std::string version = "Unknown";
     std::string category = "Unknown";
     std::string fw = "Unknown";
 };
+
+class GameInfoClass {
+
+public:
+    void GetGameInfo();
+
+    std::shared_ptr<GuiSettings> m_gui_settings = std::make_shared<GuiSettings>();
+    QVector<GameInfo> m_games;
+
+    static bool CompareStrings(GameInfo& a, GameInfo& b) {
+        return a.name < b.name;
+    }
+
+    static GameInfo readGameInfo(const std::string& filePath) {
+        GameInfo game;
+        GameListUtils game_util;
+        game.size = game_util.GetFolderSize(QDir(QString::fromStdString(filePath))).toStdString();
+        game.path = filePath;
+
+        PSF psf;
+        if (psf.open(game.path + "/sce_sys/param.sfo")) {
+            QString iconpath(QString::fromStdString(game.path) + "/sce_sys/icon0.png");
+            QString picpath(QString::fromStdString(game.path) + "/sce_sys/pic1.png");
+            game.icon_path = iconpath.toStdString();
+            game.icon = QPixmap(iconpath);
+            game.pic_path = picpath.toStdString();
+            game.name = psf.GetString("TITLE");
+            game.serial = psf.GetString("TITLE_ID");
+            u32 fw_int = psf.GetInteger("SYSTEM_VER");
+            QString fw = QString::number(fw_int, 16);
+            QString fw_ = fw.length() > 7 ? QString::number(fw_int, 16).left(3).insert(2, '.')
+                                          : fw.left(3).insert(1, '.');
+            game.fw = (fw_int == 0) ? "0.00" : fw_.toStdString();
+            game.version = psf.GetString("APP_VER");
+            game.category = psf.GetString("CATEGORY");
+        }
+        return game;
+    }
+};

src/qt_gui/game_list_frame.h

@@ -1,126 +1,53 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
 #pragma once
 
 #include <QFutureWatcher>
 #include <QGraphicsBlurEffect>
 #include <QHeaderView>
 #include <QLabel>
-#include <QStackedWidget>
+#include <QMainWindow>
+#include <QPixmap>
+#include <QScrollBar>
+#include <QStyleOptionViewItem>
+#include <QTableWidget>
+#include <QTableWidgetItem>
 #include <QVBoxLayout>
 #include <QWidget>
-#include <QtConcurrent>
+#include <QtConcurrent/QtConcurrent>
-#include "custom_dock_widget.h"
+#include "game_info.h"
-#include "game_list_grid.h"
-#include "game_list_item.h"
-#include "game_list_table.h"
 #include "game_list_utils.h"
-#include "gui_settings.h"
+#include "gui_context_menus.h"
 
-class GameListFrame : public CustomDockWidget {
+class GameListFrame : public QTableWidget {
     Q_OBJECT
 public:
-    explicit GameListFrame(std::shared_ptr<GuiSettings> gui_settings, QWidget* parent = nullptr);
+    explicit GameListFrame(std::shared_ptr<GameInfoClass> game_info_get,
-    ~GameListFrame();
+                           std::shared_ptr<GuiSettings> m_gui_settings, QWidget* parent = nullptr);
-    /** Fix columns with width smaller than the minimal section size */
-    void FixNarrowColumns() const;
-
-    /** Loads from settings. Public so that main frame can easily reset these settings if needed. */
-    void LoadSettings();
-
-    /** Saves settings. Public so that main frame can save this when a caching of column widths is
-     * needed for settings backup */
-    void SaveSettings();
-
-    /** Resizes the columns to their contents and adds a small spacing */
-    void ResizeColumnsToContents(int spacing = 20) const;
-
-    /** Refresh the gamelist with/without loading game data from files. Public so that main frame
-     * can refresh after vfs or install */
-    void Refresh(const bool from_drive = false, const bool scroll_after = true);
-
-    /** Repaint Gamelist Icons with new background color */
-    void RepaintIcons(const bool& from_settings = false);
-
-    /** Resize Gamelist Icons to size given by slider position */
-    void ResizeIcons(const int& slider_pos);
-
-public Q_SLOTS:
-    void SetSearchText(const QString& text);
-    void SetListMode(const bool& is_list);
-private Q_SLOTS:
-    void OnHeaderColumnClicked(int col);
-    void OnRepaintFinished();
-    void OnRefreshFinished();
-    void RequestGameMenu(const QPoint& pos);
-    void SetListBackgroundImage(QTableWidgetItem* item);
-    void RefreshListBackgroundImage();
-
 Q_SIGNALS:
     void GameListFrameClosed();
-    void RequestIconSizeChange(const int& val);
-    void ResizedWindow(QTableWidgetItem* item);
 
-protected:
+public Q_SLOTS:
-    void closeEvent(QCloseEvent* event) override;
+    void SetListBackgroundImage(QTableWidgetItem* item);
-    void resizeEvent(QResizeEvent* event) override;
+    void RefreshListBackgroundImage();
+    void SortNameAscending(int columnIndex);
+    void SortNameDescending(int columnIndex);
 
 private:
-    QPixmap PaintedPixmap(const QPixmap& icon) const;
-    void SortGameList() const;
-    std::string CurrentSelectionPath();
-    void PopulateGameList();
-    void PopulateGameGrid(int maxCols, const QSize& image_size, const QColor& image_color);
-    bool SearchMatchesApp(const QString& name, const QString& serial) const;
-    bool IsEntryVisible(const game_info& game);
-    static game_info GetGameInfoFromItem(const QTableWidgetItem* item);
-
-    // Which widget we are displaying depends on if we are in grid or list mode.
-    QMainWindow* m_game_dock = nullptr;
-    QStackedWidget* m_central_widget = nullptr;
-
-    // Game Grid
-    GameListGrid* m_game_grid = nullptr;
-
-    // Game List
-    GameListTable* m_game_list = nullptr;
     QList<QAction*> m_columnActs;
-    Qt::SortOrder m_col_sort_order;
+    GameInfoClass* game_inf_get = nullptr;
-    int m_sort_column;
+    bool ListSortedAsc = true;
-    QMap<QString, QString> m_titles;
 
-    // Game List Utils
+public:
-    GameListUtils m_game_list_utils;
+    void PopulateGameList();
+    void ResizeIcons(int iconSize);
 
-    // List Mode
-    bool m_is_list_layout = true;
-    bool m_old_layout_is_list = true;
-
-    // data
-    std::shared_ptr<GuiSettings> m_gui_settings;
-    QList<game_info> m_game_data;
-    std::vector<std::string> m_path_list;
-    std::vector<game_info> m_games;
-    QFutureWatcher<GameListItem*> m_repaint_watcher;
-    QFutureWatcher<void> m_refresh_watcher;
-
-    // Search
-    QString m_search_text;
-
-    // Icon Size
-    int m_icon_size_index = 0;
-
-    // Icons
-    QSize m_icon_size;
-    QColor m_icon_color;
-    qreal m_margin_factor;
-    qreal m_text_factor;
-
-    // Background Image
     QImage backgroundImage;
+    GameListUtils m_game_list_utils;
+    GuiContextMenus m_gui_context_menus;
+    std::shared_ptr<GameInfoClass> m_game_info;
 
-    void SetTableItem(GameListTable* game_list, int row, int column, QString itemStr) {
+    int icon_size;
+
+    void SetTableItem(QTableWidget* game_list, int row, int column, QString itemStr) {
         QWidget* widget = new QWidget();
         QVBoxLayout* layout = new QVBoxLayout();
         QLabel* label = new QLabel(itemStr);
@@ -143,4 +70,26 @@ private:
         game_list->setItem(row, column, item);
         game_list->setCellWidget(row, column, widget);
     }
+
+    static bool CompareStringsAscending(GameInfo a, GameInfo b, int columnIndex) {
+        if (columnIndex == 1) {
+            return a.name < b.name;
+        } else if (columnIndex == 2) {
+            return a.serial < b.serial;
+        } else if (columnIndex == 3) {
+            return a.fw < b.fw;
+        }
+        return false;
+    }
+
+    static bool CompareStringsDescending(GameInfo a, GameInfo b, int columnIndex) {
+        if (columnIndex == 1) {
+            return a.name > b.name;
+        } else if (columnIndex == 2) {
+            return a.serial > b.serial;
+        } else if (columnIndex == 3) {
+            return a.fw > b.fw;
+        }
+        return false;
+    }
 };

src/qt_gui/game_list_grid.cpp

@@ -1,164 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <QHeaderView>
-#include <QScrollBar>
-#include "game_list_grid.h"
-#include "game_list_grid_delegate.h"
-#include "game_list_item.h"
-
-GameListGrid::GameListGrid(const QSize& icon_size, QColor icon_color, const qreal& margin_factor,
-                           const qreal& text_factor, const bool& showText)
-    : m_icon_size(icon_size), m_icon_color(std::move(icon_color)), m_margin_factor(margin_factor),
-      m_text_factor(text_factor), m_text_enabled(showText) {
-    setObjectName("game_grid");
-
-    QSize item_size;
-    if (m_text_enabled) {
-        item_size =
-            m_icon_size + QSize(m_icon_size.width() * m_margin_factor * 2,
-                                m_icon_size.height() * m_margin_factor * (m_text_factor + 1));
-    } else {
-        item_size = m_icon_size + m_icon_size * m_margin_factor * 2;
-    }
-
-    grid_item_delegate = new GameListGridDelegate(item_size, m_margin_factor, m_text_factor, this);
-    setItemDelegate(grid_item_delegate);
-    setEditTriggers(QAbstractItemView::NoEditTriggers);
-    setSelectionBehavior(QAbstractItemView::SelectItems);
-    setSelectionMode(QAbstractItemView::SingleSelection);
-    setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
-    setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
-    verticalScrollBar()->setSingleStep(20);
-    horizontalScrollBar()->setSingleStep(20);
-    setContextMenuPolicy(Qt::CustomContextMenu);
-    verticalHeader()->setVisible(false);
-    horizontalHeader()->setVisible(false);
-    setShowGrid(false);
-    QPalette palette;
-    palette.setColor(QPalette::Base, QColor(230, 230, 230, 80));
-    setPalette(palette);
-
-    connect(this, &GameListTable::itemClicked, this, &GameListGrid::SetGridBackgroundImage);
-    connect(this, &GameListGrid::ResizedWindowGrid, this, &GameListGrid::SetGridBackgroundImage);
-    connect(this->verticalScrollBar(), &QScrollBar::valueChanged, this,
-            &GameListGrid::RefreshBackgroundImage);
-    connect(this->horizontalScrollBar(), &QScrollBar::valueChanged, this,
-            &GameListGrid::RefreshBackgroundImage);
-}
-
-void GameListGrid::enableText(const bool& enabled) {
-    m_text_enabled = enabled;
-}
-
-void GameListGrid::setIconSize(const QSize& size) const {
-    if (m_text_enabled) {
-        grid_item_delegate->setItemSize(
-            size + QSize(size.width() * m_margin_factor * 2,
-                         size.height() * m_margin_factor * (m_text_factor + 1)));
-    } else {
-        grid_item_delegate->setItemSize(size + size * m_margin_factor * 2);
-    }
-}
-
-GameListItem* GameListGrid::addItem(const game_info& app, const QString& name, const int& row,
-                                    const int& col) {
-    GameListItem* item = new GameListItem;
-    item->set_icon_func([this, app, item](int) {
-        const qreal device_pixel_ratio = devicePixelRatioF();
-
-        // define size of expanded image, which is raw image size + margins
-        QSizeF exp_size_f;
-        if (m_text_enabled) {
-            exp_size_f =
-                m_icon_size + QSizeF(m_icon_size.width() * m_margin_factor * 2,
-                                     m_icon_size.height() * m_margin_factor * (m_text_factor + 1));
-        } else {
-            exp_size_f = m_icon_size + m_icon_size * m_margin_factor * 2;
-        }
-
-        // define offset for raw image placement
-        QPoint offset(m_icon_size.width() * m_margin_factor,
-                      m_icon_size.height() * m_margin_factor);
-        const QSize exp_size = (exp_size_f * device_pixel_ratio).toSize();
-
-        // create empty canvas for expanded image
-        QImage exp_img(exp_size, QImage::Format_ARGB32);
-        exp_img.setDevicePixelRatio(device_pixel_ratio);
-        exp_img.fill(Qt::transparent);
-
-        // create background for image
-        QImage bg_img(app->pxmap.size(), QImage::Format_ARGB32);
-        bg_img.setDevicePixelRatio(device_pixel_ratio);
-        bg_img.fill(m_icon_color);
-
-        // place raw image inside expanded image
-        QPainter painter(&exp_img);
-        painter.setRenderHint(QPainter::SmoothPixmapTransform);
-        painter.drawImage(offset, bg_img);
-        painter.drawPixmap(offset, app->pxmap);
-        app->pxmap = {};
-        painter.end();
-
-        // create item with expanded image, title and position
-        item->setData(Qt::ItemDataRole::DecorationRole, QPixmap::fromImage(exp_img));
-    });
-    if (m_text_enabled) {
-        item->setData(Qt::ItemDataRole::DisplayRole, name);
-    }
-
-    setItem(row, col, item);
-    return item;
-}
-
-qreal GameListGrid::getMarginFactor() const {
-    return m_margin_factor;
-}
-void GameListGrid::RefreshBackgroundImage() {
-    QPixmap blurredPixmap = QPixmap::fromImage(backgroundImage);
-    QPalette palette;
-    palette.setBrush(QPalette::Base, QBrush(blurredPixmap.scaled(size(), Qt::IgnoreAspectRatio)));
-    QColor transparentColor = QColor(135, 206, 235, 40);
-    palette.setColor(QPalette::Highlight, transparentColor);
-    this->setPalette(palette);
-}
-void GameListGrid::SetGridBackgroundImage(QTableWidgetItem* item) {
-    if (!item) {
-        // handle case where icon item does not exist
-        return;
-    }
-    QTableWidgetItem* iconItem = this->item(item->row(), item->column());
-
-    if (!iconItem) {
-        // handle case where icon item does not exist
-        return;
-    }
-    game_info gameinfo = GetGameInfoFromItem(iconItem);
-    QString pic1Path = QString::fromStdString(gameinfo->info.pic_path);
-    QString blurredPic1Path =
-        qApp->applicationDirPath() +
-        QString::fromStdString("/game_data/" + gameinfo->info.serial + "/pic1.png");
-
-    backgroundImage = QImage(blurredPic1Path);
-    if (backgroundImage.isNull()) {
-        QImage image(pic1Path);
-        backgroundImage = m_game_list_utils.BlurImage(image, image.rect(), 18);
-
-        std::filesystem::path img_path =
-            std::filesystem::path("game_data/") / gameinfo->info.serial;
-        std::filesystem::create_directories(img_path);
-        if (!backgroundImage.save(blurredPic1Path, "PNG")) {
-            // qDebug() << "Error: Unable to save image.";
-        }
-    }
-    QPixmap blurredPixmap = QPixmap::fromImage(backgroundImage);
-    QPalette palette;
-    palette.setBrush(QPalette::Base, QBrush(blurredPixmap.scaled(size(), Qt::IgnoreAspectRatio)));
-    QColor transparentColor = QColor(135, 206, 235, 40);
-    palette.setColor(QPalette::Highlight, transparentColor);
-    this->setPalette(palette);
-}
-
-void GameListGrid::resizeEvent(QResizeEvent* event) {
-    Q_EMIT ResizedWindowGrid(this->currentItem());
-}

src/qt_gui/game_list_grid.h

@@ -1,62 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <QCoreApplication>
-#include "custom_dock_widget.h"
-#include "game_list_table.h"
-#include "game_list_utils.h"
-#include "gui_settings.h"
-
-class GameListGridDelegate;
-
-class GameListGrid : public GameListTable {
-    Q_OBJECT
-
-    QSize m_icon_size;
-    QColor m_icon_color;
-    qreal m_margin_factor;
-    qreal m_text_factor;
-    bool m_text_enabled = true;
-
-Q_SIGNALS:
-    void ResizedWindowGrid(QTableWidgetItem* item);
-
-protected:
-    void resizeEvent(QResizeEvent* event) override;
-
-public:
-    explicit GameListGrid(const QSize& icon_size, QColor icon_color, const qreal& margin_factor,
-                          const qreal& text_factor, const bool& showText);
-
-    void enableText(const bool& enabled);
-    void setIconSize(const QSize& size) const;
-    GameListItem* addItem(const game_info& app, const QString& name, const int& row,
-                          const int& col);
-
-    [[nodiscard]] qreal getMarginFactor() const;
-
-    game_info GetGameInfoFromItem(const QTableWidgetItem* item) {
-        if (!item) {
-            return nullptr;
-        }
-
-        const QVariant var = item->data(gui::game_role);
-        if (!var.canConvert<game_info>()) {
-            return nullptr;
-        }
-
-        return var.value<game_info>();
-    }
-
-private:
-    void SetGridBackgroundImage(QTableWidgetItem* item);
-    void RefreshBackgroundImage();
-
-    GameListGridDelegate* grid_item_delegate;
-    GameListUtils m_game_list_utils;
-
-    // Background Image
-    QImage backgroundImage;
-};

src/qt_gui/game_list_grid_delegate.cpp

@@ -1,67 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "game_list_grid_delegate.h"
-
-GameListGridDelegate::GameListGridDelegate(const QSize& size, const qreal& margin_factor,
-                                           const qreal& text_factor, QObject* parent)
-    : QStyledItemDelegate(parent), m_size(size), m_margin_factor(margin_factor),
-      m_text_factor(text_factor) {}
-
-void GameListGridDelegate::initStyleOption(QStyleOptionViewItem* option,
-                                           const QModelIndex& index) const {
-    Q_UNUSED(index)
-
-    // Remove the focus frame around selected items
-    option->state &= ~QStyle::State_HasFocus;
-
-    // Call initStyleOption without a model index, since we want to paint the relevant data
-    // ourselves
-    QStyledItemDelegate::initStyleOption(option, QModelIndex());
-}
-
-void GameListGridDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option,
-                                 const QModelIndex& index) const {
-    const QRect r = option.rect;
-
-    painter->setRenderHints(QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform);
-    painter->eraseRect(r);
-
-    // Get title and image
-    const QPixmap image = qvariant_cast<QPixmap>(index.data(Qt::DecorationRole));
-    const QString title = index.data(Qt::DisplayRole).toString();
-
-    // Paint from our stylesheet
-    QStyledItemDelegate::paint(painter, option, index);
-
-    // image
-    if (image.isNull() == false) {
-        painter->drawPixmap(option.rect, image);
-    }
-
-    const int h = r.height() / (1 + m_margin_factor + m_margin_factor * m_text_factor);
-    const int height = r.height() - h - h * m_margin_factor;
-    const int top = r.bottom() - height;
-
-    // title
-    if (option.state & QStyle::State_Selected) {
-        painter->setPen(QPen(option.palette.color(QPalette::HighlightedText), 1, Qt::SolidLine));
-    } else {
-        painter->setPen(QPen(option.palette.color(QPalette::WindowText), 1, Qt::SolidLine));
-    }
-
-    painter->setFont(option.font);
-    painter->drawText(QRect(r.left(), top, r.width(), height), +Qt::TextWordWrap | +Qt::AlignCenter,
-                      title);
-}
-
-QSize GameListGridDelegate::sizeHint(const QStyleOptionViewItem& option,
-                                     const QModelIndex& index) const {
-    Q_UNUSED(option)
-    Q_UNUSED(index)
-    return m_size;
-}
-
-void GameListGridDelegate::setItemSize(const QSize& size) {
-    m_size = size;
-}

src/qt_gui/game_list_grid_delegate.h

@@ -1,24 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <QPainter>
-#include <QStyledItemDelegate>
-
-class GameListGridDelegate : public QStyledItemDelegate {
-public:
-    GameListGridDelegate(const QSize& imageSize, const qreal& margin_factor,
-                         const qreal& margin_ratio, QObject* parent = nullptr);
-
-    void initStyleOption(QStyleOptionViewItem* option, const QModelIndex& index) const override;
-    void paint(QPainter* painter, const QStyleOptionViewItem& option,
-               const QModelIndex& index) const override;
-    QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const override;
-    void setItemSize(const QSize& size);
-
-private:
-    QSize m_size;
-    qreal m_margin_factor;
-    qreal m_text_factor;
-};

src/qt_gui/game_list_item.h

@@ -1,35 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <functional>
-
-#include <QObject>
-#include <QTableWidgetItem>
-
-using icon_callback_t = std::function<void(int)>;
-
-class GameListItem : public QTableWidgetItem {
-public:
-    GameListItem() : QTableWidgetItem() {}
-    GameListItem(const QString& text, int type = Type) : QTableWidgetItem(text, type) {}
-    GameListItem(const QIcon& icon, const QString& text, int type = Type)
-        : QTableWidgetItem(icon, text, type) {}
-
-    ~GameListItem() {}
-
-    void call_icon_func() const {
-        if (m_icon_callback) {
-            m_icon_callback(0);
-        }
-    }
-
-    void set_icon_func(const icon_callback_t& func) {
-        m_icon_callback = func;
-        call_icon_func();
-    }
-
-private:
-    icon_callback_t m_icon_callback = nullptr;
-};

src/qt_gui/game_list_table.cpp

@@ -1,18 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "game_list_table.h"
-
-void GameListTable::clear_list() {
-    clearSelection();
-    clearContents();
-}
-
-void GameListTable::mousePressEvent(QMouseEvent* event) {
-    if (QTableWidgetItem* item = itemAt(event->pos());
-        !item || !item->data(Qt::UserRole).isValid()) {
-        clearSelection();
-        setCurrentItem(nullptr); // Needed for currentItemChanged
-    }
-    QTableWidget::mousePressEvent(event);
-}

src/qt_gui/game_list_table.h

@@ -1,28 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <QMouseEvent>
-#include <QTableWidget>
-
-#include "game_info.h"
-#include "game_list_item.h"
-
-struct GuiGameInfo {
-    GameInfo info{};
-    QPixmap icon;
-    QPixmap pxmap;
-    GameListItem* item = nullptr;
-};
-
-typedef std::shared_ptr<GuiGameInfo> game_info;
-Q_DECLARE_METATYPE(game_info)
-
-class GameListTable : public QTableWidget {
-public:
-    void clear_list();
-
-protected:
-    void mousePressEvent(QMouseEvent* event) override;
-};

src/qt_gui/game_list_utils.h

@@ -14,12 +14,23 @@ public:
         static const QStringList suffixes = {"B", "KB", "MB", "GB", "TB"};
         int suffixIndex = 0;
 
-        while (size >= 1024 && suffixIndex < suffixes.size() - 1) {
+        double gameSize = static_cast<double>(size);
-            size /= 1024;
+        while (gameSize >= 1024 && suffixIndex < suffixes.size() - 1) {
+            gameSize /= 1024;
             ++suffixIndex;
         }
 
-        return QString("%1 %2").arg(size).arg(suffixes[suffixIndex]);
+        // Format the size with a specified precision
+        QString sizeString;
+        if (gameSize < 10.0) {
+            sizeString = QString::number(gameSize, 'f', 2);
+        } else if (gameSize < 100.0) {
+            sizeString = QString::number(gameSize, 'f', 1);
+        } else {
+            sizeString = QString::number(gameSize, 'f', 0);
+        }
+
+        return sizeString + " " + suffixes[suffixIndex];
     }
 
     static QString GetFolderSize(const QDir& dir) {
@@ -32,7 +43,7 @@ public:
             if (it.fileInfo().isFile()) {
                 total += it.fileInfo().size();
             }
-            it.next();
+            it.next(); // this is heavy.
         }
 
         // if there is a file left "at the end" get it's size

src/qt_gui/gui_context_menus.h

@@ -0,0 +1,145 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <QDesktopServices>
+#include <QHeaderView>
+#include <QMenu>
+#include <QTableWidget>
+#include <QTreeWidget>
+#include <QTreeWidgetItem>
+#include "game_info.h"
+
+class GuiContextMenus {
+public:
+    void RequestGameMenu(const QPoint& pos, QVector<GameInfo> m_games, QTableWidget* widget,
+                         bool isList) {
+        QPoint global_pos = widget->viewport()->mapToGlobal(pos);
+        int itemID = 0;
+        if (isList) {
+            itemID = widget->currentRow();
+        } else {
+            itemID = widget->currentRow() * widget->columnCount() + widget->currentColumn();
+        }
+
+        // Setup menu.
+        QMenu menu(widget);
+        QAction openFolder("Open Game Folder", widget);
+        QAction openSfoViewer("SFO Viewer", widget);
+
+        menu.addAction(&openFolder);
+        menu.addAction(&openSfoViewer);
+        // Show menu.
+        auto selected = menu.exec(global_pos);
+        if (!selected) {
+            return;
+        }
+
+        if (selected == &openFolder) {
+            QString folderPath = QString::fromStdString(m_games[itemID].path);
+            QDesktopServices::openUrl(QUrl::fromLocalFile(folderPath));
+        }
+
+        if (selected == &openSfoViewer) {
+            PSF psf;
+            if (psf.open(m_games[itemID].path + "/sce_sys/param.sfo")) {
+                int rows = psf.map_strings.size() + psf.map_integers.size();
+                QTableWidget* tableWidget = new QTableWidget(rows, 2);
+                tableWidget->verticalHeader()->setVisible(false); // Hide vertical header
+                int row = 0;
+
+                for (const auto& pair : psf.map_strings) {
+                    QTableWidgetItem* keyItem =
+                        new QTableWidgetItem(QString::fromStdString(pair.first));
+                    QTableWidgetItem* valueItem =
+                        new QTableWidgetItem(QString::fromStdString(pair.second));
+
+                    tableWidget->setItem(row, 0, keyItem);
+                    tableWidget->setItem(row, 1, valueItem);
+                    keyItem->setFlags(keyItem->flags() & ~Qt::ItemIsEditable);
+                    valueItem->setFlags(valueItem->flags() & ~Qt::ItemIsEditable);
+                    row++;
+                }
+                for (const auto& pair : psf.map_integers) {
+                    QTableWidgetItem* keyItem =
+                        new QTableWidgetItem(QString::fromStdString(pair.first));
+                    QTableWidgetItem* valueItem = new QTableWidgetItem(
+                        QString("0x").append(QString::number(pair.second, 16)));
+
+                    tableWidget->setItem(row, 0, keyItem);
+                    tableWidget->setItem(row, 1, valueItem);
+                    keyItem->setFlags(keyItem->flags() & ~Qt::ItemIsEditable);
+                    valueItem->setFlags(valueItem->flags() & ~Qt::ItemIsEditable);
+                    row++;
+                }
+                tableWidget->resizeColumnsToContents();
+                tableWidget->resizeRowsToContents();
+
+                int width = tableWidget->horizontalHeader()->sectionSize(0) +
+                            tableWidget->horizontalHeader()->sectionSize(1) + 2;
+                int height = (rows + 1) * (tableWidget->rowHeight(0));
+                tableWidget->setFixedSize(width, height);
+                tableWidget->sortItems(0, Qt::AscendingOrder);
+                tableWidget->horizontalHeader()->setVisible(false);
+
+                tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::Fixed);
+                tableWidget->setWindowTitle("SFO Viewer");
+                tableWidget->show();
+            }
+        }
+    }
+
+    int GetRowIndex(QTreeWidget* treeWidget, QTreeWidgetItem* item) {
+        int row = 0;
+        for (int i = 0; i < treeWidget->topLevelItemCount(); i++) { // check top level/parent items
+            QTreeWidgetItem* currentItem = treeWidget->topLevelItem(i);
+            if (currentItem == item) {
+                return row;
+            }
+            row++;
+
+            if (currentItem->childCount() > 0) { // check child items
+                for (int j = 0; j < currentItem->childCount(); j++) {
+                    QTreeWidgetItem* childItem = currentItem->child(j);
+                    if (childItem == item) {
+                        return row;
+                    }
+                    row++;
+                }
+            }
+        }
+        return -1;
+    }
+
+    void RequestGameMenuPKGViewer(const QPoint& pos, QStringList m_pkg_app_list,
+                                  QTreeWidget* treeWidget,
+                                  std::function<void(std::string, int, int)> InstallDragDropPkg) {
+        QPoint global_pos = treeWidget->viewport()->mapToGlobal(pos); // context menu position
+        QTreeWidgetItem* currentItem = treeWidget->currentItem();     // current clicked item
+        int itemIndex = GetRowIndex(treeWidget, currentItem);         // row
+
+        QMenu menu(treeWidget);
+        QAction installPackage("Install PKG", treeWidget);
+
+        menu.addAction(&installPackage);
+
+        auto selected = menu.exec(global_pos);
+        if (!selected) {
+            return;
+        }
+
+        if (selected == &installPackage) {
+            QStringList pkg_app_ = m_pkg_app_list[itemIndex].split(";");
+            std::string pkg_to_install = pkg_app_[9].toStdString();
+            InstallDragDropPkg(pkg_to_install, 1, 1);
+
+            QFile file("log.txt");
+            if (!file.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text))
+                return;
+
+            QTextStream stream(&file);
+            stream << QString::fromStdString(pkg_to_install) << Qt::endl;
+        }
+    }
+};

src/qt_gui/gui_settings.cpp

@@ -22,8 +22,3 @@ GuiSave GuiSettings::GetGuiSaveForColumn(int col) {
                        gui::get_game_list_column_name(static_cast<gui::game_list_columns>(col)),
                    true};
 }
-QSize GuiSettings::SizeFromSlider(int pos) {
-    return gui::game_list_icon_size_min +
-           (gui::game_list_icon_size_max - gui::game_list_icon_size_min) *
-               (1.f * pos / gui::game_list_max_slider_pos);
-}

src/qt_gui/gui_settings.h

@@ -49,45 +49,28 @@ inline QString get_game_list_column_name(game_list_columns col) {
     throw std::runtime_error("get_game_list_column_name: Invalid column");
 }
 
-const QSize game_list_icon_size_min = QSize(28, 28);
-const QSize game_list_icon_size_small = QSize(56, 56);
-const QSize game_list_icon_size_medium = QSize(128, 128);
-const QSize game_list_icon_size_max =
-    QSize(256, 256); // let's do 256, 512 is too big (that's what she said)
-
-const int game_list_max_slider_pos = 100;
-
-inline int get_Index(const QSize& current) {
-    const int size_delta = game_list_icon_size_max.width() - game_list_icon_size_min.width();
-    const int current_delta = current.width() - game_list_icon_size_min.width();
-    return game_list_max_slider_pos * current_delta / size_delta;
-}
-
 const QString main_window = "main_window";
 const QString game_list = "GameList";
 const QString settings = "Settings";
 const QString themes = "Themes";
 
-const QColor game_list_icon_color = QColor(240, 240, 240, 255);
-
 const GuiSave main_window_gamelist_visible = GuiSave(main_window, "gamelistVisible", true);
 const GuiSave main_window_geometry = GuiSave(main_window, "geometry", QByteArray());
 const GuiSave main_window_windowState = GuiSave(main_window, "windowState", QByteArray());
 const GuiSave main_window_mwState = GuiSave(main_window, "mwState", QByteArray());
 
-const GuiSave game_list_sortAsc = GuiSave(game_list, "sortAsc", true);
-const GuiSave game_list_sortCol = GuiSave(game_list, "sortCol", 1);
 const GuiSave game_list_state = GuiSave(game_list, "state", QByteArray());
-const GuiSave game_list_iconSize =
-    GuiSave(game_list, "iconSize", get_Index(game_list_icon_size_small));
-const GuiSave game_list_iconSizeGrid =
-    GuiSave(game_list, "iconSizeGrid", get_Index(game_list_icon_size_small));
-const GuiSave game_list_iconColor = GuiSave(game_list, "iconColor", game_list_icon_color);
 const GuiSave game_list_listMode = GuiSave(game_list, "listMode", true);
-const GuiSave game_list_textFactor = GuiSave(game_list, "textFactor", qreal{2.0});
-const GuiSave game_list_marginFactor = GuiSave(game_list, "marginFactor", qreal{0.09});
 const GuiSave settings_install_dir = GuiSave(settings, "installDirectory", "");
 const GuiSave mw_themes = GuiSave(themes, "Themes", 0);
+const GuiSave m_icon_size = GuiSave(game_list, "iconSize", 36);
+const GuiSave m_icon_size_grid = GuiSave(game_list, "iconSizeGrid", 69);
+const GuiSave m_slide_pos = GuiSave(game_list, "sliderPos", 0);
+const GuiSave m_slide_pos_grid = GuiSave(game_list, "sliderPosGrid", 0);
+const GuiSave m_table_mode = GuiSave(main_window, "tableMode", 0);
+const GuiSave m_window_size = GuiSave(main_window, "windowSize", QSize(1280, 720));
+const GuiSave m_pkg_viewer = GuiSave("pkg_viewer", "pkgDir", QStringList());
+const GuiSave m_pkg_viewer_pkg_list = GuiSave("pkg_viewer", "pkgList", QStringList());
 
 } // namespace gui
 
@@ -102,5 +85,4 @@ public:
 public Q_SLOTS:
     void SetGamelistColVisibility(int col, bool val) const;
     static GuiSave GetGuiSaveForColumn(int col);
-    static QSize SizeFromSlider(int pos);
 };

src/qt_gui/main_window.cpp

@@ -2,23 +2,22 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <QDir>
+#include <QDockWidget>
 #include <QFileDialog>
 #include <QMessageBox>
 #include <QProgressDialog>
-
+#include <QStatusBar>
+#include <QtConcurrent>
 #include "common/io_file.h"
 #include "core/file_format/pkg.h"
 #include "core/loader.h"
 #include "game_install_dialog.h"
-#include "game_list_frame.h"
 #include "gui_settings.h"
 #include "main_window.h"
 
 MainWindow::MainWindow(std::shared_ptr<GuiSettings> gui_settings, QWidget* parent)
     : QMainWindow(parent), ui(new Ui::MainWindow), m_gui_settings(std::move(gui_settings)) {
-
     ui->setupUi(this);
-
     setAttribute(Qt::WA_DeleteOnClose);
 }
 
@@ -27,23 +26,29 @@ MainWindow::~MainWindow() {
 }
 
 bool MainWindow::Init() {
+    auto start = std::chrono::steady_clock::now();
     AddUiWidgets();
     CreateActions();
     CreateDockWindows();
     CreateConnects();
     SetLastUsedTheme();
+    SetLastIconSizeBullet();
+    ConfigureGuiFromSettings();
+    LoadGameLists();
 
     setMinimumSize(350, minimumSizeHint().height());
     setWindowTitle(QString::fromStdString("ShadPS4 v0.0.3"));
-
-    ConfigureGuiFromSettings();
-
     show();
 
-    // Fix possible hidden game list columns. The game list has to be visible already. Use this
+    auto end = std::chrono::steady_clock::now();
-    // after show()
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
-    m_game_list_frame->FixNarrowColumns();
+    statusBar = new QStatusBar(this);
-
+    m_main_window->setStatusBar(statusBar);
+    // Update status bar
+    int numGames = m_game_info->m_games.size();
+    QString statusMessage = "Games: " + QString::number(numGames) + " (" +
+                            QString::number(duration.count()) + "ms). Ready.";
+    statusBar->showMessage(statusMessage);
     return true;
 }
 
@@ -73,7 +78,6 @@ void MainWindow::AddUiWidgets() {
     // add toolbar widgets
     QApplication::setStyle("Fusion");
     ui->toolBar->setObjectName("mw_toolbar");
-    ui->sizeSlider->setRange(0, gui::game_list_max_slider_pos);
     ui->toolBar->addWidget(ui->playButton);
     ui->toolBar->addWidget(ui->pauseButton);
     ui->toolBar->addWidget(ui->stopButton);
@@ -83,7 +87,6 @@ void MainWindow::AddUiWidgets() {
     line->setFrameShape(QFrame::StyledPanel);
     line->setFrameShadow(QFrame::Sunken);
     ui->toolBar->addWidget(line);
-    // ui->toolBar->addWidget(ui->emuRunWidget);
     ui->toolBar->addWidget(ui->sizeSliderContainer);
     ui->toolBar->addWidget(ui->mw_searchbar);
 }
@@ -92,89 +95,182 @@ void MainWindow::CreateDockWindows() {
     m_main_window = new QMainWindow();
     m_main_window->setContextMenuPolicy(Qt::PreventContextMenu);
 
-    m_game_list_frame = new GameListFrame(m_gui_settings, m_main_window);
+    // resize window to last W and H
+    QSize window_size = m_gui_settings->GetValue(gui::m_window_size).toSize();
+    m_main_window->resize(window_size.width(), window_size.height());
+
+    // Add the game table.
+    m_dock_widget = new QDockWidget("Game List", m_main_window);
+    m_game_list_frame = new GameListFrame(m_game_info, m_gui_settings, m_main_window);
     m_game_list_frame->setObjectName("gamelist");
+    m_game_grid_frame = new GameGridFrame(m_game_info, m_gui_settings, m_main_window);
+    m_game_grid_frame->setObjectName("gamegridlist");
 
-    m_main_window->addDockWidget(Qt::LeftDockWidgetArea, m_game_list_frame);
+    int table_mode = m_gui_settings->GetValue(gui::m_table_mode).toInt();
+    int slider_pos = 0;
+    if (table_mode == 0) { // List
+        m_game_grid_frame->hide();
+        m_dock_widget->setWidget(m_game_list_frame);
+        slider_pos = m_gui_settings->GetValue(gui::m_slide_pos).toInt();
+        ui->sizeSlider->setSliderPosition(slider_pos); // set slider pos at start;
+        isTableList = true;
+    } else { // Grid
+        m_game_list_frame->hide();
+        m_dock_widget->setWidget(m_game_grid_frame);
+        slider_pos = m_gui_settings->GetValue(gui::m_slide_pos_grid).toInt();
+        ui->sizeSlider->setSliderPosition(slider_pos); // set slider pos at start;
+        isTableList = false;
+    }
 
+    m_main_window->addDockWidget(Qt::LeftDockWidgetArea, m_dock_widget);
     m_main_window->setDockNestingEnabled(true);
 
     setCentralWidget(m_main_window);
+}
 
-    connect(m_game_list_frame, &GameListFrame::GameListFrameClosed, this, [this]() {
+void MainWindow::LoadGameLists() {
-        if (ui->showGameListAct->isChecked()) {
+    // Get game info from game folders.
-            ui->showGameListAct->setChecked(false);
+    m_game_info->GetGameInfo();
-            m_gui_settings->SetValue(gui::main_window_gamelist_visible, false);
+    if (isTableList) {
+        m_game_list_frame->PopulateGameList();
+    } else {
+        m_game_grid_frame->PopulateGameGrid(m_game_info->m_games, false);
     }
-    });
 }
+
 void MainWindow::CreateConnects() {
+    connect(this, &MainWindow::WindowResized, this, &MainWindow::HandleResize);
+
+    connect(ui->mw_searchbar, &QLineEdit::textChanged, this, &MainWindow::SearchGameTable);
+
     connect(ui->exitAct, &QAction::triggered, this, &QWidget::close);
 
-    connect(ui->showGameListAct, &QAction::triggered, this, [this](bool checked) {
+    connect(ui->sizeSlider, &QSlider::valueChanged, this, [this](int value) {
-        checked ? m_game_list_frame->show() : m_game_list_frame->hide();
+        if (isTableList) {
-        m_gui_settings->SetValue(gui::main_window_gamelist_visible, checked);
+            m_game_list_frame->icon_size =
-    });
+                36 + value; // 36 is the minimum icon size to use due to text disappearing.
-    connect(ui->refreshGameListAct, &QAction::triggered, this,
+            m_game_list_frame->ResizeIcons(36 + value);
-            [this] { m_game_list_frame->Refresh(false); });
+            m_gui_settings->SetValue(gui::m_icon_size, 36 + value);
-
+            m_gui_settings->SetValue(gui::m_slide_pos, value);
-    connect(m_icon_size_act_group, &QActionGroup::triggered, this, [this](QAction* act) {
+        } else {
-        static const int index_small = gui::get_Index(gui::game_list_icon_size_small);
+            m_game_grid_frame->icon_size = 69 + value;
-        static const int index_medium = gui::get_Index(gui::game_list_icon_size_medium);
+            m_game_grid_frame->PopulateGameGrid(m_game_info->m_games, false);
-
+            m_gui_settings->SetValue(gui::m_icon_size_grid, 69 + value);
-        int index;
+            m_gui_settings->SetValue(gui::m_slide_pos_grid, value);
-
-        if (act == ui->setIconSizeTinyAct)
-            index = 0;
-        else if (act == ui->setIconSizeSmallAct)
-            index = index_small;
-        else if (act == ui->setIconSizeMediumAct)
-            index = index_medium;
-        else
-            index = gui::game_list_max_slider_pos;
-
-        m_save_slider_pos = true;
-        ResizeIcons(index);
-    });
-    connect(m_game_list_frame, &GameListFrame::RequestIconSizeChange, this, [this](const int& val) {
-        const int idx = ui->sizeSlider->value() + val;
-        m_save_slider_pos = true;
-        ResizeIcons(idx);
-    });
-
-    connect(m_list_mode_act_group, &QActionGroup::triggered, this, [this](QAction* act) {
-        const bool is_list_act = act == ui->setlistModeListAct;
-        if (is_list_act == m_is_list_mode)
-            return;
-
-        const int slider_pos = ui->sizeSlider->sliderPosition();
-        ui->sizeSlider->setSliderPosition(m_other_slider_pos);
-        SetIconSizeActions(m_other_slider_pos);
-        m_other_slider_pos = slider_pos;
-
-        m_is_list_mode = is_list_act;
-        m_game_list_frame->SetListMode(m_is_list_mode);
-    });
-    connect(ui->sizeSlider, &QSlider::valueChanged, this, &MainWindow::ResizeIcons);
-    connect(ui->sizeSlider, &QSlider::sliderReleased, this, [this] {
-        const int index = ui->sizeSlider->value();
-        m_gui_settings->SetValue(
-            m_is_list_mode ? gui::game_list_iconSize : gui::game_list_iconSizeGrid, index);
-        SetIconSizeActions(index);
-    });
-    connect(ui->sizeSlider, &QSlider::actionTriggered, this, [this](int action) {
-        if (action != QAbstractSlider::SliderNoAction &&
-            action !=
-                QAbstractSlider::SliderMove) { // we only want to save on mouseclicks or slider
-                                               // release (the other connect handles this)
-            m_save_slider_pos = true; // actionTriggered happens before the value was changed
         }
     });
 
-    connect(ui->mw_searchbar, &QLineEdit::textChanged, m_game_list_frame,
+    connect(ui->setIconSizeTinyAct, &QAction::triggered, this, [this](int value) {
-            &GameListFrame::SetSearchText);
+        if (isTableList) {
+            m_game_list_frame->icon_size =
+                36; // 36 is the minimum icon size to use due to text disappearing.
+            m_gui_settings->SetValue(gui::m_icon_size, 36);
+            ui->sizeSlider->setValue(0); // icone_size - 36
+            m_gui_settings->SetValue(gui::m_slide_pos, 0);
+        } else {
+            m_gui_settings->SetValue(gui::m_icon_size_grid, 69); // nice :3
+            ui->sizeSlider->setValue(0);                         // icone_size - 36
+            m_gui_settings->SetValue(gui::m_slide_pos_grid, 0);
+        }
+    });
+
+    connect(ui->setIconSizeSmallAct, &QAction::triggered, this, [this](int value) {
+        if (isTableList) {
+            m_game_list_frame->icon_size = 64;
+            m_gui_settings->SetValue(gui::m_icon_size, 64);
+            ui->sizeSlider->setValue(28);
+            m_gui_settings->SetValue(gui::m_slide_pos, 28);
+        } else {
+            m_gui_settings->SetValue(gui::m_icon_size_grid, 97);
+            ui->sizeSlider->setValue(28);
+            m_gui_settings->SetValue(gui::m_slide_pos_grid, 28);
+        }
+    });
+
+    connect(ui->setIconSizeMediumAct, &QAction::triggered, this, [this](int value) {
+        if (isTableList) {
+            m_game_list_frame->icon_size = 128;
+            m_gui_settings->SetValue(gui::m_icon_size, 128);
+            ui->sizeSlider->setValue(92);
+            m_gui_settings->SetValue(gui::m_slide_pos, 92);
+        } else {
+            m_gui_settings->SetValue(gui::m_icon_size_grid, 160);
+            ui->sizeSlider->setValue(92);
+            m_gui_settings->SetValue(gui::m_slide_pos_grid, 92);
+        }
+    });
+
+    connect(ui->setIconSizeLargeAct, &QAction::triggered, this, [this](int value) {
+        if (isTableList) {
+            m_game_list_frame->icon_size = 256;
+            m_gui_settings->SetValue(gui::m_icon_size, 256);
+            ui->sizeSlider->setValue(220);
+            m_gui_settings->SetValue(gui::m_slide_pos, 220);
+        } else {
+            m_gui_settings->SetValue(gui::m_icon_size_grid, 256);
+            ui->sizeSlider->setValue(220);
+            m_gui_settings->SetValue(gui::m_slide_pos_grid, 220);
+        }
+    });
+
+    connect(ui->setlistModeListAct, &QAction::triggered, m_dock_widget, [this]() {
+        m_dock_widget->setWidget(m_game_list_frame);
+        m_game_list_frame->show();
+        m_game_grid_frame->hide();
+        m_game_list_frame->clearContents();
+        m_game_list_frame->PopulateGameList();
+        isTableList = true;
+        m_gui_settings->SetValue(gui::m_table_mode, 0); // save table mode
+        int slider_pos = m_gui_settings->GetValue(gui::m_slide_pos).toInt();
+        ui->sizeSlider->setSliderPosition(slider_pos);
+    });
+
+    connect(ui->setlistModeGridAct, &QAction::triggered, m_dock_widget, [this]() {
+        m_dock_widget->setWidget(m_game_grid_frame);
+        m_game_grid_frame->show();
+        m_game_list_frame->hide();
+        isTableList = false;
+        m_gui_settings->SetValue(gui::m_table_mode, 1); // save table mode
+        int slider_pos_grid = m_gui_settings->GetValue(gui::m_slide_pos_grid).toInt();
+        ui->sizeSlider->setSliderPosition(slider_pos_grid);
+    });
+
+    // Dump game list.
+    connect(ui->dumpGameListAct, &QAction::triggered, this, [this] {
+        QString filePath = qApp->applicationDirPath().append("/GameList.txt");
+        QFile file(filePath);
+        QTextStream out(&file);
+        if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+            qDebug() << "Failed to open file for writing:" << file.errorString();
+            return;
+        }
+        out << QString("%1 %2 %3 %4 %5\n")
+                   .arg("          NAME", -50)
+                   .arg("    ID", -10)
+                   .arg("FW", -4)
+                   .arg(" APP VERSION", -11)
+                   .arg("                Path");
+        for (const GameInfo& game : m_game_info->m_games) {
+            out << QString("%1 %2 %3     %4 %5\n")
+                       .arg(QString::fromStdString(game.name), -50)
+                       .arg(QString::fromStdString(game.serial), -10)
+                       .arg(QString::fromStdString(game.fw), -4)
+                       .arg(QString::fromStdString(game.version), -11)
+                       .arg(QString::fromStdString(game.path));
+        }
+    });
+
+    // Package install.
     connect(ui->bootInstallPkgAct, &QAction::triggered, this, [this] { InstallPkg(); });
     connect(ui->gameInstallPathAct, &QAction::triggered, this, [this] { InstallDirectory(); });
+    // Package Viewer.
+    connect(ui->pkgViewerAct, &QAction::triggered, this, [this]() {
+        PKGViewer* pkgViewer = new PKGViewer(m_game_info, m_gui_settings,
+                                             [this](std::string file, int pkgNum, int nPkg) {
+                                                 this->InstallDragDropPkg(file, pkgNum, nPkg);
+                                             });
+        pkgViewer->show();
+    });
 
     // Themes
     connect(ui->setThemeLight, &QAction::triggered, &m_window_themes, [this]() {
@@ -219,85 +315,64 @@ void MainWindow::CreateConnects() {
     });
 }
 
-void MainWindow::SetIconSizeActions(int idx) const {
+void MainWindow::SearchGameTable(const QString& text) {
-    static const int threshold_tiny =
+    if (isTableList) {
-        gui::get_Index((gui::game_list_icon_size_small + gui::game_list_icon_size_min) / 2);
+        for (int row = 0; row < m_game_list_frame->rowCount(); row++) {
-    static const int threshold_small =
+            QString game_name = QString::fromStdString(m_game_info->m_games[row].name);
-        gui::get_Index((gui::game_list_icon_size_medium + gui::game_list_icon_size_small) / 2);
+            bool match = (game_name.contains(text, Qt::CaseInsensitive)); // Check only in column 1
-    static const int threshold_medium =
+            m_game_list_frame->setRowHidden(row, !match);
-        gui::get_Index((gui::game_list_icon_size_max + gui::game_list_icon_size_medium) / 2);
+        }
-
+    } else {
-    if (idx < threshold_tiny)
+        QVector<GameInfo> filteredGames;
-        ui->setIconSizeTinyAct->setChecked(true);
+        for (const auto& gameInfo : m_game_info->m_games) {
-    else if (idx < threshold_small)
+            QString game_name = QString::fromStdString(gameInfo.name);
-        ui->setIconSizeSmallAct->setChecked(true);
+            if (game_name.contains(text, Qt::CaseInsensitive)) {
-    else if (idx < threshold_medium)
+                filteredGames.push_back(gameInfo);
-        ui->setIconSizeMediumAct->setChecked(true);
+            }
-    else
+        }
-        ui->setIconSizeLargeAct->setChecked(true);
+        std::sort(filteredGames.begin(), filteredGames.end(), m_game_info->CompareStrings);
+        m_game_grid_frame->PopulateGameGrid(filteredGames, true);
     }
-void MainWindow::ResizeIcons(int index) {
-    if (ui->sizeSlider->value() != index) {
-        ui->sizeSlider->setSliderPosition(index);
-        return; // ResizeIcons will be triggered again by setSliderPosition, so return here
 }
 
-    if (m_save_slider_pos) {
+void MainWindow::RefreshGameTable() {
-        m_save_slider_pos = false;
+    m_game_info->m_games.clear();
-        m_gui_settings->SetValue(
+    m_game_info->GetGameInfo();
-            m_is_list_mode ? gui::game_list_iconSize : gui::game_list_iconSizeGrid, index);
+    m_game_list_frame->clearContents();
-
+    m_game_list_frame->PopulateGameList();
-        // this will also fire when we used the actions, but i didn't want to add another boolean
+    m_game_grid_frame->clearContents();
-        // member
+    m_game_grid_frame->PopulateGameGrid(m_game_info->m_games, false);
-        SetIconSizeActions(index);
+    statusBar->clearMessage();
+    int numGames = m_game_info->m_games.size();
+    QString statusMessage = "Games: " + QString::number(numGames) + ". Ready.";
+    statusBar->showMessage(statusMessage);
 }
 
-    m_game_list_frame->ResizeIcons(index);
-}
 void MainWindow::ConfigureGuiFromSettings() {
     // Restore GUI state if needed. We need to if they exist.
     if (!restoreGeometry(m_gui_settings->GetValue(gui::main_window_geometry).toByteArray())) {
         resize(QGuiApplication::primaryScreen()->availableSize() * 0.7);
     }
 
-    restoreState(m_gui_settings->GetValue(gui::main_window_windowState).toByteArray());
     m_main_window->restoreState(m_gui_settings->GetValue(gui::main_window_mwState).toByteArray());
 
     ui->showGameListAct->setChecked(
         m_gui_settings->GetValue(gui::main_window_gamelist_visible).toBool());
 
-    m_game_list_frame->setVisible(ui->showGameListAct->isChecked());
+    if (isTableList) {
-
-    // handle icon size options
-    m_is_list_mode = m_gui_settings->GetValue(gui::game_list_listMode).toBool();
-    if (m_is_list_mode)
         ui->setlistModeListAct->setChecked(true);
-    else
+    } else {
         ui->setlistModeGridAct->setChecked(true);
-
+    }
-    const int icon_size_index =
-        m_gui_settings
-            ->GetValue(m_is_list_mode ? gui::game_list_iconSize : gui::game_list_iconSizeGrid)
-            .toInt();
-    m_other_slider_pos =
-        m_gui_settings
-            ->GetValue(!m_is_list_mode ? gui::game_list_iconSize : gui::game_list_iconSizeGrid)
-            .toInt();
-    ui->sizeSlider->setSliderPosition(icon_size_index);
-    SetIconSizeActions(icon_size_index);
-
-    // Gamelist
-    m_game_list_frame->LoadSettings();
 }
 
 void MainWindow::SaveWindowState() const {
     // Save gui settings
     m_gui_settings->SetValue(gui::main_window_geometry, saveGeometry());
     m_gui_settings->SetValue(gui::main_window_windowState, saveState());
+    m_gui_settings->SetValue(gui::m_window_size,
+                             QSize(m_main_window->width(), m_main_window->height()));
     m_gui_settings->SetValue(gui::main_window_mwState, m_main_window->saveState());
-
-    // Save column settings
-    m_game_list_frame->SaveSettings();
 }
 
 void MainWindow::InstallPkg() {
@@ -312,7 +387,6 @@ void MainWindow::InstallPkg() {
 }
 
 void MainWindow::InstallDragDropPkg(std::string file, int pkgNum, int nPkg) {
-
     if (Loader::DetectFileType(file) == Loader::FileTypes::Pkg) {
         PKG pkg;
         pkg.Open(file);
@@ -323,7 +397,7 @@ void MainWindow::InstallDragDropPkg(std::string file, int pkgNum, int nPkg) {
             pkg.GetTitleID();
         if (!pkg.Extract(file, extract_path, failreason)) {
             QMessageBox::critical(this, "PKG ERROR", QString::fromStdString(failreason),
-                                  QMessageBox::Ok, 0);
+                                  QMessageBox::Ok);
         } else {
             int nfiles = pkg.GetNumberOfFiles();
 
@@ -356,14 +430,14 @@ void MainWindow::InstallDragDropPkg(std::string file, int pkgNum, int nPkg) {
             auto path = m_gui_settings->GetValue(gui::settings_install_dir).toString();
             if (pkgNum == nPkg) {
                 QMessageBox::information(this, "Extraction Finished",
-                                         "Game successfully installed at " + path, QMessageBox::Ok,
+                                         "Game successfully installed at " + path, QMessageBox::Ok);
-                                         0);
+                // Refresh game table after extraction.
-                m_game_list_frame->Refresh(true);
+                RefreshGameTable();
             }
         }
     } else {
         QMessageBox::critical(this, "PKG ERROR", "File doesn't appear to be a valid PKG file",
-                              QMessageBox::Ok, 0);
+                              QMessageBox::Ok);
     }
 }
 
@@ -373,7 +447,6 @@ void MainWindow::InstallDirectory() {
 }
 
 void MainWindow::SetLastUsedTheme() {
-
     Theme lastTheme = static_cast<Theme>(m_gui_settings->GetValue(gui::mw_themes).toInt());
     m_window_themes.SetWindowTheme(lastTheme, ui->mw_searchbar);
 
@@ -405,7 +478,26 @@ void MainWindow::SetLastUsedTheme() {
     }
 }
 
-QIcon MainWindow::recolorIcon(const QIcon& icon, bool isWhite) {
+void MainWindow::SetLastIconSizeBullet() {
+    // set QAction bullet point if applicable
+    int lastSize = m_gui_settings->GetValue(gui::m_icon_size).toInt();
+    switch (lastSize) {
+    case 36:
+        ui->setIconSizeTinyAct->setChecked(true);
+        break;
+    case 64:
+        ui->setIconSizeSmallAct->setChecked(true);
+        break;
+    case 128:
+        ui->setIconSizeMediumAct->setChecked(true);
+        break;
+    case 256:
+        ui->setIconSizeLargeAct->setChecked(true);
+        break;
+    }
+}
+
+QIcon MainWindow::RecolorIcon(const QIcon& icon, bool isWhite) {
     QPixmap pixmap(icon.pixmap(icon.actualSize(QSize(120, 120)), QIcon::Normal));
     QColor clr(isWhite ? Qt::white : Qt::black);
     QBitmap mask = pixmap.createMaskFromColor(clr, Qt::MaskOutColor);
@@ -417,32 +509,49 @@ QIcon MainWindow::recolorIcon(const QIcon& icon, bool isWhite) {
 
 void MainWindow::SetUiIcons(bool isWhite) {
     QIcon icon;
-    icon = recolorIcon(ui->bootInstallPkgAct->icon(), isWhite);
+    icon = RecolorIcon(ui->bootInstallPkgAct->icon(), isWhite);
     ui->bootInstallPkgAct->setIcon(icon);
-    icon = recolorIcon(ui->exitAct->icon(), isWhite);
+    icon = RecolorIcon(ui->exitAct->icon(), isWhite);
     ui->exitAct->setIcon(icon);
-    icon = recolorIcon(ui->setlistModeListAct->icon(), isWhite);
+    icon = RecolorIcon(ui->setlistModeListAct->icon(), isWhite);
     ui->setlistModeListAct->setIcon(icon);
-    icon = recolorIcon(ui->setlistModeGridAct->icon(), isWhite);
+    icon = RecolorIcon(ui->setlistModeGridAct->icon(), isWhite);
     ui->setlistModeGridAct->setIcon(icon);
-    icon = recolorIcon(ui->gameInstallPathAct->icon(), isWhite);
+    icon = RecolorIcon(ui->gameInstallPathAct->icon(), isWhite);
     ui->gameInstallPathAct->setIcon(icon);
-    icon = recolorIcon(ui->menuThemes->icon(), isWhite);
+    icon = RecolorIcon(ui->menuThemes->icon(), isWhite);
     ui->menuThemes->setIcon(icon);
-    icon = recolorIcon(ui->menuGame_List_Icons->icon(), isWhite);
+    icon = RecolorIcon(ui->menuGame_List_Icons->icon(), isWhite);
     ui->menuGame_List_Icons->setIcon(icon);
-    icon = recolorIcon(ui->playButton->icon(), isWhite);
+    icon = RecolorIcon(ui->playButton->icon(), isWhite);
     ui->playButton->setIcon(icon);
-    icon = recolorIcon(ui->pauseButton->icon(), isWhite);
+    icon = RecolorIcon(ui->pauseButton->icon(), isWhite);
     ui->pauseButton->setIcon(icon);
-    icon = recolorIcon(ui->stopButton->icon(), isWhite);
+    icon = RecolorIcon(ui->stopButton->icon(), isWhite);
     ui->stopButton->setIcon(icon);
-    icon = recolorIcon(ui->settingsButton->icon(), isWhite);
+    icon = RecolorIcon(ui->settingsButton->icon(), isWhite);
     ui->settingsButton->setIcon(icon);
-    icon = recolorIcon(ui->controllerButton->icon(), isWhite);
+    icon = RecolorIcon(ui->controllerButton->icon(), isWhite);
     ui->controllerButton->setIcon(icon);
-    icon = recolorIcon(ui->refreshGameListAct->icon(), isWhite);
+    icon = RecolorIcon(ui->refreshGameListAct->icon(), isWhite);
     ui->refreshGameListAct->setIcon(icon);
-    icon = recolorIcon(ui->menuGame_List_Mode->icon(), isWhite);
+    icon = RecolorIcon(ui->menuGame_List_Mode->icon(), isWhite);
     ui->menuGame_List_Mode->setIcon(icon);
+    icon = RecolorIcon(ui->pkgViewerAct->icon(), isWhite);
+    ui->pkgViewerAct->setIcon(icon);
+}
+
+void MainWindow::resizeEvent(QResizeEvent* event) {
+    emit WindowResized(event);
+    QMainWindow::resizeEvent(event);
+}
+
+void MainWindow::HandleResize(QResizeEvent* event) {
+    if (isTableList) {
+        m_game_list_frame->RefreshListBackgroundImage();
+    } else {
+        m_game_grid_frame->windowWidth = this->width();
+        m_game_grid_frame->PopulateGameGrid(m_game_info->m_games, false);
+        m_game_grid_frame->RefreshGridBackgroundImage();
+    }
 }

src/qt_gui/main_window.h

@@ -7,8 +7,13 @@
 #include <QDragEnterEvent>
 #include <QMainWindow>
 #include <QMimeData>
+#include "game_grid_frame.h"
+#include "game_info.h"
+#include "game_list_frame.h"
+#include "game_list_utils.h"
 #include "main_window_themes.h"
 #include "main_window_ui.h"
+#include "pkg_viewer.h"
 
 class GuiSettings;
 class GameListFrame;
@@ -21,6 +26,8 @@ class MainWindow : public QMainWindow {
     bool m_is_list_mode = true;
     bool m_save_slider_pos = false;
     int m_other_slider_pos = 0;
+signals:
+    void WindowResized(QResizeEvent* event);
 
 public:
     explicit MainWindow(std::shared_ptr<GuiSettings> gui_settings, QWidget* parent = nullptr);
@@ -32,20 +39,24 @@ public:
 
 private Q_SLOTS:
     void ConfigureGuiFromSettings();
-    void SetIconSizeActions(int idx) const;
-    void ResizeIcons(int index);
     void SaveWindowState() const;
+    void SearchGameTable(const QString& text);
+    void RefreshGameTable();
+    void HandleResize(QResizeEvent* event);
 
 private:
     void AddUiWidgets();
     void CreateActions();
     void CreateDockWindows();
+    void LoadGameLists();
     void CreateConnects();
     void SetLastUsedTheme();
+    void SetLastIconSizeBullet();
     void SetUiIcons(bool isWhite);
-    QIcon recolorIcon(const QIcon& icon, bool isWhite);
+    QIcon RecolorIcon(const QIcon& icon, bool isWhite);
 
     bool isIconBlack = false;
+    bool isTableList = true;
 
     QActionGroup* m_icon_size_act_group = nullptr;
     QActionGroup* m_list_mode_act_group = nullptr;
@@ -53,9 +64,18 @@ private:
 
     // Dockable widget frames
     QMainWindow* m_main_window = nullptr;
-    GameListFrame* m_game_list_frame = nullptr;
     WindowThemes m_window_themes;
+    GameListUtils m_game_list_utils;
+    QDockWidget* m_dock_widget = nullptr;
+    // Game Lists
+    GameListFrame* m_game_list_frame = nullptr;
+    GameGridFrame* m_game_grid_frame = nullptr;
+    // Packge Viewer
+    PKGViewer* m_pkg_viewer = nullptr;
+    // Status Bar.
+    QStatusBar* statusBar = nullptr;
 
+    std::shared_ptr<GameInfoClass> m_game_info = std::make_shared<GameInfoClass>();
     std::shared_ptr<GuiSettings> m_gui_settings;
 
 protected:
@@ -77,4 +97,6 @@ protected:
             }
         }
     }
+
+    void resizeEvent(QResizeEvent* event) override;
 };

src/qt_gui/main_window_ui.h

@@ -40,6 +40,8 @@ public:
     QAction* setlistModeListAct;
     QAction* setlistModeGridAct;
     QAction* gameInstallPathAct;
+    QAction* dumpGameListAct;
+    QAction* pkgViewerAct;
     QAction* setThemeLight;
     QAction* setThemeDark;
     QAction* setThemeGreen;
@@ -64,13 +66,14 @@ public:
     QMenu* menuGame_List_Icons;
     QMenu* menuGame_List_Mode;
     QMenu* menuSettings;
+    QMenu* menuUtils;
     QMenu* menuThemes;
     QToolBar* toolBar;
 
     void setupUi(QMainWindow* MainWindow) {
         if (MainWindow->objectName().isEmpty())
             MainWindow->setObjectName("MainWindow");
-        MainWindow->resize(1058, 580);
+        // MainWindow->resize(1280, 720);
         QIcon icon;
         icon.addFile(QString::fromUtf8(":/images/shadps4.ico"), QSize(), QIcon::Normal, QIcon::Off);
         MainWindow->setWindowIcon(icon);
@@ -103,7 +106,6 @@ public:
         setIconSizeSmallAct = new QAction(MainWindow);
         setIconSizeSmallAct->setObjectName("setIconSizeSmallAct");
         setIconSizeSmallAct->setCheckable(true);
-        setIconSizeSmallAct->setChecked(true);
         setIconSizeMediumAct = new QAction(MainWindow);
         setIconSizeMediumAct->setObjectName("setIconSizeMediumAct");
         setIconSizeMediumAct->setCheckable(true);
@@ -122,6 +124,12 @@ public:
         gameInstallPathAct = new QAction(MainWindow);
         gameInstallPathAct->setObjectName("gameInstallPathAct");
         gameInstallPathAct->setIcon(QIcon(":images/folder_icon.png"));
+        dumpGameListAct = new QAction(MainWindow);
+        dumpGameListAct->setObjectName("dumpGameList");
+        pkgViewerAct = new QAction(MainWindow);
+        pkgViewerAct->setObjectName("pkgViewer");
+        pkgViewerAct->setObjectName("pkgViewer");
+        pkgViewerAct->setIcon(QIcon(":images/file_icon.png"));
         setThemeLight = new QAction(MainWindow);
         setThemeLight->setObjectName("setThemeLight");
         setThemeLight->setCheckable(true);
@@ -199,6 +207,8 @@ public:
         sizeSlider->setAutoFillBackground(false);
         sizeSlider->setOrientation(Qt::Horizontal);
         sizeSlider->setTickPosition(QSlider::NoTicks);
+        sizeSlider->setMinimum(0);
+        sizeSlider->setMaximum(220);
 
         sizeSliderContainer_layout->addWidget(sizeSlider);
 
@@ -219,6 +229,8 @@ public:
         menuGame_List_Mode->setIcon(QIcon(":images/list_mode_icon.png"));
         menuSettings = new QMenu(menuBar);
         menuSettings->setObjectName("menuSettings");
+        menuUtils = new QMenu(menuSettings);
+        menuUtils->setObjectName("menuUtils");
         menuThemes = new QMenu(menuView);
         menuThemes->setObjectName("menuThemes");
         menuThemes->setIcon(QIcon(":images/themes_icon.png"));
@@ -251,6 +263,9 @@ public:
         menuGame_List_Mode->addAction(setlistModeListAct);
         menuGame_List_Mode->addAction(setlistModeGridAct);
         menuSettings->addAction(gameInstallPathAct);
+        menuSettings->addAction(menuUtils->menuAction());
+        menuUtils->addAction(dumpGameListAct);
+        menuUtils->addAction(pkgViewerAct);
 
         retranslateUi(MainWindow);
 
@@ -287,6 +302,9 @@ public:
             QCoreApplication::translate("MainWindow", "Grid View", nullptr));
         gameInstallPathAct->setText(
             QCoreApplication::translate("MainWindow", "Game Install Directory", nullptr));
+        dumpGameListAct->setText(
+            QCoreApplication::translate("MainWindow", "Dump Game List", nullptr));
+        pkgViewerAct->setText(QCoreApplication::translate("MainWindow", "PKG Viewer", nullptr));
         mw_searchbar->setPlaceholderText(
             QCoreApplication::translate("MainWindow", "Search...", nullptr));
         // darkModeSwitch->setText(
@@ -298,6 +316,7 @@ public:
         menuGame_List_Mode->setTitle(
             QCoreApplication::translate("MainWindow", "Game List Mode", nullptr));
         menuSettings->setTitle(QCoreApplication::translate("MainWindow", "Settings", nullptr));
+        menuUtils->setTitle(QCoreApplication::translate("MainWindow", "Utils", nullptr));
         menuThemes->setTitle(QCoreApplication::translate("MainWindow", "Themes", nullptr));
         setThemeLight->setText(QCoreApplication::translate("MainWindow", "Light", nullptr));
         setThemeDark->setText(QCoreApplication::translate("MainWindow", "Dark", nullptr));

src/qt_gui/pkg_viewer.cpp

@@ -0,0 +1,249 @@
+#include <QHeaderView>
+#include <QWidget>
+#include "pkg_viewer.h"
+
+PKGViewer::PKGViewer(std::shared_ptr<GameInfoClass> game_info_get,
+                     std::shared_ptr<GuiSettings> m_gui_settings,
+                     std::function<void(std::string, int, int)> InstallDragDropPkg)
+    : QMainWindow() {
+    this->resize(1280, 720);
+    m_gui_settings_ = m_gui_settings;
+    m_game_info = game_info_get;
+    dir_list = m_gui_settings->GetValue(gui::m_pkg_viewer).toStringList();
+
+    treeWidget = new QTreeWidget(this);
+    treeWidget->setColumnCount(9);
+    QStringList headers;
+    headers << "Name"
+            << "Serial"
+            << "Size"
+            << "Installed"
+            << "Category"
+            << "Type"
+            << "App Ver"
+            << "FW"
+            << "Region"
+            << "Flags"
+            << "Path";
+    treeWidget->setHeaderLabels(headers);
+    treeWidget->header()->setDefaultAlignment(Qt::AlignCenter);
+    treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
+    treeWidget->setColumnWidth(8, 170);
+    this->setCentralWidget(treeWidget);
+    QMenuBar* menuBar = new QMenuBar(this);
+    menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
+    QMenu* fileMenu = menuBar->addMenu(tr("&File"));
+    QAction* openFolderAct = new QAction(tr("Open Folder"), this);
+    fileMenu->addAction(openFolderAct);
+    this->setMenuBar(menuBar);
+    CheckPKGFolders(); // Check for new PKG files in existing folders.
+    if (!m_pkg_list.isEmpty())
+        ProcessPKGInfo();
+
+    for (int column = 0; column < treeWidget->columnCount() - 2; ++column) {
+        // Resize the column to fit its contents
+        treeWidget->resizeColumnToContents(column);
+    }
+
+    connect(openFolderAct, &QAction::triggered, this, &PKGViewer::OpenPKGFolder);
+
+    connect(treeWidget, &QTreeWidget::customContextMenuRequested, this,
+            [=, this](const QPoint& pos) {
+                m_gui_context_menus.RequestGameMenuPKGViewer(pos, m_full_pkg_list, treeWidget,
+                                                             InstallDragDropPkg);
+            });
+}
+
+PKGViewer::~PKGViewer() {}
+
+void PKGViewer::OpenPKGFolder() {
+    QString folderPath =
+        QFileDialog::getExistingDirectory(this, tr("Open Folder"), QDir::homePath());
+    if (!dir_list.contains(folderPath)) {
+
+        dir_list.append(folderPath);
+        if (!folderPath.isEmpty()) {
+            QDir directory(folderPath);
+            for (const auto& dir : std::filesystem::directory_iterator(folderPath.toStdString())) {
+                if (std::filesystem::is_regular_file(dir.path())) {
+                    m_pkg_list.append(QString::fromStdString(dir.path().string()));
+                }
+            }
+            std::sort(m_pkg_list.begin(), m_pkg_list.end());
+            ProcessPKGInfo();
+            m_gui_settings_->SetValue(gui::m_pkg_viewer, dir_list);
+            m_gui_settings_->SetValue(gui::m_pkg_viewer_pkg_list, m_pkg_list);
+        }
+    } else {
+        // qDebug() << "Folder selection canceled.";
+    }
+}
+
+void PKGViewer::CheckPKGFolders() { // Check for new PKG file additions.
+    m_pkg_list.clear();
+    for (const QString& paths : dir_list) {
+        for (const auto& dir : std::filesystem::directory_iterator(paths.toStdString())) {
+            if (std::filesystem::is_regular_file(dir.path())) {
+                m_pkg_list.append(QString::fromStdString(dir.path().string()));
+            }
+        }
+    }
+    std::sort(m_pkg_list.begin(), m_pkg_list.end());
+}
+
+void PKGViewer::ProcessPKGInfo() {
+    treeWidget->clear();
+    map_strings.clear();
+    for (int i = 0; i < m_pkg_list.size(); i++) {
+        Common::FS::IOFile file(m_pkg_list[i].toStdString(), Common::FS::FileAccessMode::Read);
+        if (!file.IsOpen()) {
+            // return false;
+        }
+
+        file.ReadRaw<u8>(&pkgheader, sizeof(PKGHeader));
+        file.Seek(0);
+        pkgSize = file.GetSize();
+        pkg.resize(pkgheader.pkg_promote_size);
+        file.Read(pkg);
+
+        u32 offset = pkgheader.pkg_table_entry_offset;
+        u32 n_files = pkgheader.pkg_table_entry_count;
+
+        for (int i = 0; i < n_files; i++) {
+            std::memcpy(&entry, &pkg[offset + i * 0x20], sizeof(entry));
+            const auto name = GetEntryNameByType(entry.id);
+            if (name == "param.sfo") {
+                psf.resize(entry.size);
+                int seek = entry.offset;
+                file.Seek(seek);
+                file.Read(psf);
+                std::memcpy(&header, psf.data(), sizeof(header));
+                auto future = std::async(std::launch::async, [&]() {
+                    for (u32 i = 0; i < header.index_table_entries; i++) {
+                        PSFEntry psfentry;
+                        std::memcpy(&psfentry, &psf[sizeof(PSFHeader) + i * sizeof(PSFEntry)],
+                                    sizeof(psfentry));
+                        const std::string key =
+                            (char*)&psf[header.key_table_offset + psfentry.key_offset];
+                        if (psfentry.param_fmt == PSFEntry::Fmt::TextRaw ||
+                            psfentry.param_fmt == PSFEntry::Fmt::TextNormal) {
+                            map_strings[key] =
+                                (char*)&psf[header.data_table_offset + psfentry.data_offset];
+                        }
+                        if (psfentry.param_fmt == PSFEntry::Fmt::Integer) {
+                            u32 value;
+                            std::memcpy(&value,
+                                        &psf[header.data_table_offset + psfentry.data_offset],
+                                        sizeof(value));
+                            map_integers[key] = value;
+                        }
+                    }
+                });
+                future.wait();
+            }
+        }
+        QString title_name = GetString("TITLE");
+        QString title_id = GetString("TITLE_ID");
+        QString app_type = GetAppType(GetInteger("APP_TYPE"));
+        QString app_version = GetString("APP_VER");
+        QString title_category = GetString("CATEGORY");
+        QString pkg_size = game_list_util.FormatSize(pkgheader.pkg_size);
+        pkg_content_flag = pkgheader.pkg_content_flags;
+        QString flagss = "";
+        for (const auto& flag : flagNames) {
+            if (isFlagSet(pkg_content_flag, flag.first)) {
+                if (!flagss.isEmpty())
+                    flagss.append(", ");
+                flagss.append(flag.second);
+            }
+        }
+
+        u32 fw_int = GetInteger("SYSTEM_VER");
+        QString fw = QString::number(fw_int, 16);
+        QString fw_ = fw.length() > 7 ? QString::number(fw_int, 16).left(3).insert(2, '.')
+                                      : fw.left(3).insert(1, '.');
+        fw_ = (fw_int == 0) ? "0.00" : fw_;
+        char region = pkgheader.pkg_content_id[0];
+        QString pkg_info = "";
+        if (title_category == "gd") {
+            title_category = "App";
+            pkg_info = title_name + ";" + title_id + ";" + pkg_size + ";" + title_category + ";" +
+                       app_type + ";" + app_version + ";" + fw_ + ";" + GetRegion(region) + ";" +
+                       flagss + ";" + m_pkg_list[i];
+            m_pkg_app_list.append(pkg_info);
+        } else {
+            title_category = "Patch";
+            pkg_info = title_name + ";" + title_id + ";" + pkg_size + ";" + title_category + ";" +
+                       app_type + ";" + app_version + ";" + fw_ + ";" + GetRegion(region) + ";" +
+                       flagss + ";" + m_pkg_list[i];
+            m_pkg_patch_list.append(pkg_info);
+        }
+    }
+    std::sort(m_pkg_app_list.begin(), m_pkg_app_list.end());
+    for (int i = 0; i < m_pkg_app_list.size(); i++) {
+        QTreeWidgetItem* treeItem = new QTreeWidgetItem(treeWidget);
+        QStringList pkg_app_ = m_pkg_app_list[i].split(";");
+        m_full_pkg_list.append(m_pkg_app_list[i]);
+        treeItem->setExpanded(true);
+        treeItem->setText(0, pkg_app_[0]);
+        treeItem->setText(1, pkg_app_[1]);
+        treeItem->setText(3, pkg_app_[2]);
+        treeItem->setTextAlignment(3, Qt::AlignCenter);
+        treeItem->setText(4, pkg_app_[3]);
+        treeItem->setTextAlignment(4, Qt::AlignCenter);
+        treeItem->setText(5, pkg_app_[4]);
+        treeItem->setTextAlignment(5, Qt::AlignCenter);
+        treeItem->setText(6, pkg_app_[5]);
+        treeItem->setTextAlignment(6, Qt::AlignCenter);
+        treeItem->setText(7, pkg_app_[6]);
+        treeItem->setTextAlignment(7, Qt::AlignCenter);
+        treeItem->setText(8, pkg_app_[7]);
+        treeItem->setTextAlignment(8, Qt::AlignCenter);
+        treeItem->setText(9, pkg_app_[8]);
+        treeItem->setText(10, pkg_app_[9]);
+        for (const GameInfo& info : m_game_info->m_games) { // Check if game is installed.
+            if (info.name == pkg_app_[0].toStdString()) {
+                treeItem->setText(2, QChar(0x2713));
+                treeItem->setTextAlignment(2, Qt::AlignCenter);
+            }
+        }
+        for (const QString& item : m_pkg_patch_list) {
+            QStringList pkg_patch_ = item.split(";");
+            if (pkg_patch_[0] == pkg_app_[0]) { // check patches.
+                m_full_pkg_list.append(item);
+                QTreeWidgetItem* childItem = new QTreeWidgetItem(treeItem);
+                childItem->setText(0, pkg_patch_[0]);
+                childItem->setText(1, pkg_patch_[1]);
+                childItem->setText(3, pkg_patch_[2]);
+                childItem->setTextAlignment(3, Qt::AlignCenter);
+                childItem->setText(4, pkg_patch_[3]);
+                childItem->setTextAlignment(4, Qt::AlignCenter);
+                childItem->setText(5, pkg_patch_[4]);
+                childItem->setTextAlignment(5, Qt::AlignCenter);
+                childItem->setText(6, pkg_patch_[5]);
+                childItem->setTextAlignment(6, Qt::AlignCenter);
+                childItem->setText(7, pkg_patch_[6]);
+                childItem->setTextAlignment(7, Qt::AlignCenter);
+                childItem->setText(8, pkg_patch_[7]);
+                childItem->setTextAlignment(8, Qt::AlignCenter);
+                childItem->setText(9, pkg_patch_[8]);
+                childItem->setText(10, pkg_patch_[9]);
+            }
+        }
+    }
+    std::sort(m_full_pkg_list.begin(), m_full_pkg_list.end());
+}
+
+QString PKGViewer::GetString(const std::string& key) {
+    if (map_strings.find(key) != map_strings.end()) {
+        return QString::fromStdString(map_strings.at(key));
+    }
+    return "";
+}
+
+u32 PKGViewer::GetInteger(const std::string& key) {
+    if (map_integers.find(key) != map_integers.end()) {
+        return map_integers.at(key);
+    }
+    return 0;
+}

src/qt_gui/pkg_viewer.h

@@ -0,0 +1,117 @@
+#pragma once
+
+#include <filesystem>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <QFileDialog>
+#include <QMainWindow>
+#include <QMenu>
+#include <QMenuBar>
+#include <QTreeWidget>
+#include <QTreeWidgetItem>
+#include <QtConcurrent/QtConcurrent>
+#include "common/io_file.h"
+#include "core/file_format/pkg.h"
+#include "core/file_format/pkg_type.h"
+#include "core/file_format/psf.h"
+#include "game_info.h"
+#include "game_list_utils.h"
+#include "gui_context_menus.h"
+#include "gui_settings.h"
+
+class PKGViewer : public QMainWindow {
+    Q_OBJECT
+public:
+    explicit PKGViewer(std::shared_ptr<GameInfoClass> game_info_get,
+                       std::shared_ptr<GuiSettings> m_gui_settings,
+                       std::function<void(std::string, int, int)> InstallDragDropPkg = nullptr);
+    ~PKGViewer();
+    void OpenPKGFolder();
+    void CheckPKGFolders();
+    void ProcessPKGInfo();
+    QString GetString(const std::string& key);
+    u32 GetInteger(const std::string& key);
+
+private:
+    GuiContextMenus m_gui_context_menus;
+    PSF psf_;
+    PKGHeader pkgheader;
+    PKGEntry entry;
+    PSFHeader header;
+    PSFEntry psfentry;
+    char pkgTitleID[9];
+    std::vector<u8> pkg;
+    std::vector<u8> psf;
+    u64 pkgSize = 0;
+    std::shared_ptr<GuiSettings> m_gui_settings_;
+    std::unordered_map<std::string, std::string> map_strings;
+    std::unordered_map<std::string, u32> map_integers;
+
+    u32_be pkg_content_flag;
+    std::shared_ptr<GameInfoClass> m_game_info;
+    GameListUtils game_list_util;
+
+    std::vector<std::pair<PKGContentFlag, std::string>> flagNames = {
+        {PKGContentFlag::FIRST_PATCH, "FIRST_PATCH"},
+        {PKGContentFlag::PATCHGO, "PATCHGO"},
+        {PKGContentFlag::REMASTER, "REMASTER"},
+        {PKGContentFlag::PS_CLOUD, "PS_CLOUD"},
+        {PKGContentFlag::GD_AC, "GD_AC"},
+        {PKGContentFlag::NON_GAME, "NON_GAME"},
+        {PKGContentFlag::UNKNOWN_0x8000000, "UNKNOWN_0x8000000"},
+        {PKGContentFlag::SUBSEQUENT_PATCH, "SUBSEQUENT_PATCH"},
+        {PKGContentFlag::DELTA_PATCH, "DELTA_PATCH"},
+        {PKGContentFlag::CUMULATIVE_PATCH, "CUMULATIVE_PATCH"}};
+
+    std::vector<std::pair<int, QString>> appTypes = {
+        {0, "FULL APP"},
+        {1, "UPGRADABLE"},
+        {2, "DEMO"},
+        {3, "FREEMIUM"},
+    };
+
+    bool isFlagSet(u32_be variable, PKGContentFlag flag) {
+        return (variable) & static_cast<u32>(flag);
+    }
+
+    QString GetRegion(char region) {
+        switch (region) {
+        case 'U':
+            return "USA";
+        case 'E':
+            return "Europe";
+        case 'J':
+            return "Japan";
+        case 'H':
+            return "Asia";
+        case 'I':
+            return "World";
+        default:
+            return "Unknown";
+        }
+    }
+
+    QString GetAppType(int region) {
+        switch (region) {
+        case 0:
+            return "Not Specified";
+        case 1:
+            return "FULL APP";
+        case 2:
+            return "UPGRADABLE";
+        case 3:
+            return "DEMO";
+        case 4:
+            return "FREEMIUM";
+        default:
+            return "Unknown";
+        }
+    }
+    QStringList m_full_pkg_list;
+    QStringList m_pkg_app_list;
+    QStringList m_pkg_patch_list;
+    QStringList m_pkg_list;
+    QStringList dir_list;
+    QTreeWidget* treeWidget = nullptr;
+};

src/qt_gui/qt_utils.h

@@ -1,20 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <QFutureWatcher>
-
-namespace gui {
-namespace utils {
-template <typename T>
-void stop_future_watcher(QFutureWatcher<T>& watcher, bool cancel) {
-    if (watcher.isStarted() || watcher.isRunning()) {
-        if (cancel) {
-            watcher.cancel();
-        }
-        watcher.waitForFinished();
-    }
-}
-} // namespace utils
-} // namespace gui