2015-09-01 10:05:33 +05:30
// Copyright 2015 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
# pragma once
# include <atomic>
2018-04-16 04:12:58 +05:30
# include <map>
# include <unordered_map>
2018-08-24 20:44:09 +05:30
# include <utility>
2018-04-19 01:31:45 +05:30
# include <QCoreApplication>
2018-04-20 06:26:24 +05:30
# include <QFileInfo>
2016-04-14 02:34:05 +05:30
# include <QImage>
2018-04-16 04:12:58 +05:30
# include <QObject>
2015-09-01 10:05:33 +05:30
# include <QRunnable>
# include <QStandardItem>
# include <QString>
2018-07-23 16:13:34 +05:30
# include <QWidget>
2018-04-20 06:26:24 +05:30
# include "citra_qt/ui_settings.h"
2015-09-01 10:05:33 +05:30
# include "citra_qt/util/util.h"
2018-05-19 14:51:26 +05:30
# include "common/file_util.h"
2018-04-16 04:12:58 +05:30
# include "common/logging/log.h"
2016-09-18 06:08:01 +05:30
# include "common/string_util.h"
2016-05-18 05:12:45 +05:30
# include "core/loader/smdh.h"
2016-04-14 02:34:05 +05:30
2018-04-20 06:26:24 +05:30
enum class GameListItemType {
Game = QStandardItem : : UserType + 1 ,
CustomDir = QStandardItem : : UserType + 2 ,
InstalledDir = QStandardItem : : UserType + 3 ,
SystemDir = QStandardItem : : UserType + 4 ,
AddDir = QStandardItem : : UserType + 5
} ;
Q_DECLARE_METATYPE ( GameListItemType ) ;
2016-04-14 02:34:05 +05:30
/**
2017-02-27 07:28:51 +05:30
* Gets the game icon from SMDH data .
* @ param smdh SMDH data
2016-04-14 02:34:05 +05:30
* @ param large If true , returns large icon ( 48 x48 ) , otherwise returns small icon ( 24 x24 )
* @ return QPixmap game icon
*/
2016-05-18 05:12:45 +05:30
static QPixmap GetQPixmapFromSMDH ( const Loader : : SMDH & smdh , bool large ) {
std : : vector < u16 > icon_data = smdh . GetIcon ( large ) ;
const uchar * data = reinterpret_cast < const uchar * > ( icon_data . data ( ) ) ;
int size = large ? 48 : 24 ;
QImage icon ( data , size , size , QImage : : Format : : Format_RGB16 ) ;
2016-04-14 02:34:05 +05:30
return QPixmap : : fromImage ( icon ) ;
}
/**
* Gets the default icon ( for games without valid SMDH )
* @ param large If true , returns large icon ( 48 x48 ) , otherwise returns small icon ( 24 x24 )
* @ return QPixmap default icon
*/
static QPixmap GetDefaultIcon ( bool large ) {
int size = large ? 48 : 24 ;
QPixmap icon ( size , size ) ;
icon . fill ( Qt : : transparent ) ;
return icon ;
}
2018-09-01 05:12:07 +05:30
static auto FindMatchingCompatibilityEntry (
const std : : unordered_map < std : : string , std : : pair < QString , QString > > & compatibility_list ,
u64 program_id ) {
return std : : find_if (
compatibility_list . begin ( ) , compatibility_list . end ( ) ,
[ program_id ] ( const std : : pair < std : : string , std : : pair < QString , QString > > & element ) {
std : : string pid = fmt : : format ( " {:016X} " , program_id ) ;
return element . first = = pid ;
} ) ;
2018-04-16 04:12:58 +05:30
}
2016-04-14 02:34:05 +05:30
/**
2017-02-27 07:28:51 +05:30
* Gets the short game title from SMDH data .
* @ param smdh SMDH data
2016-04-14 02:34:05 +05:30
* @ param language title language
* @ return QString short title
*/
2016-09-18 06:08:01 +05:30
static QString GetQStringShortTitleFromSMDH ( const Loader : : SMDH & smdh ,
Loader : : SMDH : : TitleLanguage language ) {
2016-05-18 05:12:45 +05:30
return QString : : fromUtf16 ( smdh . GetShortTitle ( language ) . data ( ) ) ;
2016-04-14 02:34:05 +05:30
}
2015-09-01 10:05:33 +05:30
2018-05-01 23:27:01 +05:30
/**
* Gets the game region from SMDH data .
* @ param smdh SMDH data
* @ return QString region
*/
static QString GetRegionFromSMDH ( const Loader : : SMDH & smdh ) {
const Loader : : SMDH : : GameRegion region = smdh . GetRegion ( ) ;
switch ( region ) {
case Loader : : SMDH : : GameRegion : : Invalid :
return QObject : : tr ( " Invalid region " ) ;
case Loader : : SMDH : : GameRegion : : Japan :
return QObject : : tr ( " Japan " ) ;
case Loader : : SMDH : : GameRegion : : NorthAmerica :
return QObject : : tr ( " North America " ) ;
case Loader : : SMDH : : GameRegion : : Europe :
return QObject : : tr ( " Europe " ) ;
case Loader : : SMDH : : GameRegion : : Australia :
return QObject : : tr ( " Australia " ) ;
case Loader : : SMDH : : GameRegion : : China :
return QObject : : tr ( " China " ) ;
case Loader : : SMDH : : GameRegion : : Korea :
return QObject : : tr ( " Korea " ) ;
case Loader : : SMDH : : GameRegion : : Taiwan :
return QObject : : tr ( " Taiwan " ) ;
case Loader : : SMDH : : GameRegion : : RegionFree :
return QObject : : tr ( " Region free " ) ;
default :
return QObject : : tr ( " Invalid Region " ) ;
}
}
2018-04-16 04:12:58 +05:30
class GameListItem : public QStandardItem {
2015-09-01 10:05:33 +05:30
public :
2018-04-20 06:26:24 +05:30
// used to access type from item index
static const int TypeRole = Qt : : UserRole + 1 ;
static const int SortRole = Qt : : UserRole + 2 ;
2018-08-24 20:44:09 +05:30
GameListItem ( ) = default ;
explicit GameListItem ( const QString & string ) : QStandardItem ( string ) {
2018-04-20 06:26:24 +05:30
setData ( string , SortRole ) ;
}
2015-09-01 10:05:33 +05:30
} ;
/**
* A specialization of GameListItem for path values .
* This class ensures that for every full path value it holds , a correct string representation
* of just the filename ( with no extension ) will be displayed to the user .
2016-10-20 19:56:59 +05:30
* If this class receives valid SMDH data , it will also display game icons and titles .
2015-09-01 10:05:33 +05:30
*/
class GameListItemPath : public GameListItem {
public :
2018-04-20 06:26:24 +05:30
static const int TitleRole = SortRole ;
static const int FullPathRole = SortRole + 1 ;
static const int ProgramIdRole = SortRole + 2 ;
2018-09-16 10:18:39 +05:30
static const int ExtdataIdRole = SortRole + 3 ;
2015-09-01 10:05:33 +05:30
2018-08-24 20:44:09 +05:30
GameListItemPath ( ) = default ;
2018-09-16 10:18:39 +05:30
GameListItemPath ( const QString & game_path , const std : : vector < u8 > & smdh_data , u64 program_id ,
u64 extdata_id ) {
2018-04-20 06:26:24 +05:30
setData ( type ( ) , TypeRole ) ;
2015-09-01 10:05:33 +05:30
setData ( game_path , FullPathRole ) ;
2016-12-15 15:25:03 +05:30
setData ( qulonglong ( program_id ) , ProgramIdRole ) ;
2018-09-16 10:18:39 +05:30
setData ( qulonglong ( extdata_id ) , ExtdataIdRole ) ;
2016-04-14 02:34:05 +05:30
2018-09-23 08:52:44 +05:30
if ( ! UISettings : : values . game_list_icon_size ) {
// Do not display icons
setData ( QPixmap ( ) , Qt : : DecorationRole ) ;
}
bool large = UISettings : : values . game_list_icon_size = = 2 ;
2018-01-24 09:02:27 +05:30
if ( ! Loader : : IsValidSMDH ( smdh_data ) ) {
2016-04-14 02:34:05 +05:30
// SMDH is not valid, set a default icon
2018-09-23 08:52:44 +05:30
if ( UISettings : : values . game_list_icon_size )
setData ( GetDefaultIcon ( large ) , Qt : : DecorationRole ) ;
2016-04-14 02:34:05 +05:30
return ;
}
2018-01-24 21:47:04 +05:30
2018-01-24 21:46:40 +05:30
Loader : : SMDH smdh ;
2018-01-24 09:02:27 +05:30
memcpy ( & smdh , smdh_data . data ( ) , sizeof ( Loader : : SMDH ) ) ;
2016-04-14 02:34:05 +05:30
// Get icon from SMDH
2018-09-23 08:52:44 +05:30
if ( UISettings : : values . game_list_icon_size )
setData ( GetQPixmapFromSMDH ( smdh , large ) , Qt : : DecorationRole ) ;
2016-04-14 02:34:05 +05:30
2018-01-20 23:03:14 +05:30
// Get title from SMDH
2016-09-18 06:08:01 +05:30
setData ( GetQStringShortTitleFromSMDH ( smdh , Loader : : SMDH : : TitleLanguage : : English ) ,
TitleRole ) ;
2015-09-01 10:05:33 +05:30
}
2018-04-20 06:26:24 +05:30
int type ( ) const override {
return static_cast < int > ( GameListItemType : : Game ) ;
}
2016-04-14 02:34:05 +05:30
QVariant data ( int role ) const override {
if ( role = = Qt : : DisplayRole ) {
2018-05-19 14:51:26 +05:30
std : : string path , filename , extension ;
Common : : SplitPath ( data ( FullPathRole ) . toString ( ) . toStdString ( ) , & path , & filename ,
& extension ) ;
2018-09-23 08:52:44 +05:30
const std : : array < QString , 4 > display_texts { {
QString : : fromStdString ( filename + extension ) , // file name
data ( FullPathRole ) . toString ( ) , // full path
data ( TitleRole ) . toString ( ) , // title name
2018-05-19 14:51:26 +05:30
QString : : fromStdString (
2018-09-23 08:52:44 +05:30
fmt : : format ( " {:016X} " , data ( ProgramIdRole ) . toULongLong ( ) ) ) , // title id
} } ;
const QString & row1 = display_texts . at ( UISettings : : values . game_list_row_1 ) ;
QString row2 ;
int row_2_id = UISettings : : values . game_list_row_2 ;
if ( row_2_id ! = - 1 ) {
row2 = ( row1 . isEmpty ( ) ? " " : " \n " ) + display_texts . at ( row_2_id ) ;
2018-05-19 14:51:26 +05:30
}
2018-09-23 08:52:44 +05:30
return row1 + row2 ;
2015-09-01 10:05:33 +05:30
} else {
2016-04-14 02:34:05 +05:30
return GameListItem : : data ( role ) ;
2015-09-01 10:05:33 +05:30
}
}
} ;
2018-04-16 04:12:58 +05:30
class GameListItemCompat : public GameListItem {
2018-09-01 05:12:07 +05:30
Q_DECLARE_TR_FUNCTIONS ( GameListItemCompat )
2018-04-16 04:12:58 +05:30
public :
2018-04-20 06:26:24 +05:30
static const int CompatNumberRole = SortRole ;
2018-04-16 04:12:58 +05:30
GameListItemCompat ( ) = default ;
2018-09-01 05:12:07 +05:30
explicit GameListItemCompat ( const QString & compatiblity ) {
2018-04-20 06:26:24 +05:30
setData ( type ( ) , TypeRole ) ;
2018-09-01 05:12:07 +05:30
struct CompatStatus {
QString color ;
const char * text ;
const char * tooltip ;
} ;
// clang-format off
static const std : : map < QString , CompatStatus > status_data = {
{ " 0 " , { " #5c93ed " , QT_TR_NOOP ( " Perfect " ) , QT_TR_NOOP ( " Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without \n any workarounds needed. " ) } } ,
{ " 1 " , { " #47d35c " , QT_TR_NOOP ( " Great " ) , QT_TR_NOOP ( " Game functions with minor graphical or audio glitches and is playable from start to finish. May require some \n workarounds. " ) } } ,
{ " 2 " , { " #94b242 " , QT_TR_NOOP ( " Okay " ) , QT_TR_NOOP ( " Game functions with major graphical or audio glitches, but game is playable from start to finish with \n workarounds. " ) } } ,
{ " 3 " , { " #f2d624 " , QT_TR_NOOP ( " Bad " ) , QT_TR_NOOP ( " Game functions, but with major graphical or audio glitches. Unable to progress in specific areas due to glitches \n even with workarounds. " ) } } ,
{ " 4 " , { " #ff0000 " , QT_TR_NOOP ( " Intro/Menu " ) , QT_TR_NOOP ( " Game is completely unplayable due to major graphical or audio glitches. Unable to progress past the Start \n Screen. " ) } } ,
{ " 5 " , { " #828282 " , QT_TR_NOOP ( " Won't Boot " ) , QT_TR_NOOP ( " The game crashes when attempting to startup. " ) } } ,
{ " 99 " , { " #000000 " , QT_TR_NOOP ( " Not Tested " ) , QT_TR_NOOP ( " The game has not yet been tested. " ) } } } ;
// clang-format on
2018-04-16 04:12:58 +05:30
auto iterator = status_data . find ( compatiblity ) ;
if ( iterator = = status_data . end ( ) ) {
2018-06-29 16:48:07 +05:30
LOG_WARNING ( Frontend , " Invalid compatibility number {} " , compatiblity . toStdString ( ) ) ;
2018-04-16 04:12:58 +05:30
return ;
}
CompatStatus status = iterator - > second ;
setData ( compatiblity , CompatNumberRole ) ;
2018-09-01 05:12:07 +05:30
setText ( QObject : : tr ( status . text ) ) ;
setToolTip ( QObject : : tr ( status . tooltip ) ) ;
2018-04-16 04:12:58 +05:30
setData ( CreateCirclePixmapFromColor ( status . color ) , Qt : : DecorationRole ) ;
}
2018-04-20 06:26:24 +05:30
int type ( ) const override {
return static_cast < int > ( GameListItemType : : Game ) ;
}
2018-04-16 04:12:58 +05:30
bool operator < ( const QStandardItem & other ) const override {
return data ( CompatNumberRole ) < other . data ( CompatNumberRole ) ;
}
} ;
2018-05-01 23:27:01 +05:30
class GameListItemRegion : public GameListItem {
public :
GameListItemRegion ( ) = default ;
explicit GameListItemRegion ( const std : : vector < u8 > & smdh_data ) {
2018-04-20 06:26:24 +05:30
setData ( type ( ) , TypeRole ) ;
2018-05-01 23:27:01 +05:30
if ( ! Loader : : IsValidSMDH ( smdh_data ) ) {
setText ( QObject : : tr ( " Invalid region " ) ) ;
return ;
}
Loader : : SMDH smdh ;
memcpy ( & smdh , smdh_data . data ( ) , sizeof ( Loader : : SMDH ) ) ;
setText ( GetRegionFromSMDH ( smdh ) ) ;
2018-04-20 06:26:24 +05:30
setData ( GetRegionFromSMDH ( smdh ) , SortRole ) ;
}
int type ( ) const override {
return static_cast < int > ( GameListItemType : : Game ) ;
2018-05-01 23:27:01 +05:30
}
} ;
2015-09-01 10:05:33 +05:30
/**
* A specialization of GameListItem for size values .
* This class ensures that for every numerical size value it holds ( in bytes ) , a correct
* human - readable string representation will be displayed to the user .
*/
class GameListItemSize : public GameListItem {
public :
2018-04-20 06:26:24 +05:30
static const int SizeRole = SortRole ;
2015-09-01 10:05:33 +05:30
2018-08-24 20:44:09 +05:30
GameListItemSize ( ) = default ;
explicit GameListItemSize ( const qulonglong size_bytes ) {
2018-04-20 06:26:24 +05:30
setData ( type ( ) , TypeRole ) ;
2015-09-01 10:05:33 +05:30
setData ( size_bytes , SizeRole ) ;
}
2016-09-18 06:08:01 +05:30
void setData ( const QVariant & value , int role ) override {
2015-09-01 10:05:33 +05:30
// By specializing setData for SizeRole, we can ensure that the numerical and string
// representations of the data are always accurate and in the correct format.
if ( role = = SizeRole ) {
qulonglong size_bytes = value . toULongLong ( ) ;
GameListItem : : setData ( ReadableByteSize ( size_bytes ) , Qt : : DisplayRole ) ;
GameListItem : : setData ( value , SizeRole ) ;
} else {
GameListItem : : setData ( value , role ) ;
}
}
2018-04-20 06:26:24 +05:30
int type ( ) const override {
return static_cast < int > ( GameListItemType : : Game ) ;
}
2015-09-01 10:05:33 +05:30
/**
* This operator is , in practice , only used by the TreeView sorting systems .
2016-09-18 06:08:01 +05:30
* Override it so that it will correctly sort by numerical value instead of by string
* representation .
2015-09-01 10:05:33 +05:30
*/
2016-09-18 06:08:01 +05:30
bool operator < ( const QStandardItem & other ) const override {
2015-09-01 10:05:33 +05:30
return data ( SizeRole ) . toULongLong ( ) < other . data ( SizeRole ) . toULongLong ( ) ;
}
} ;
2018-04-20 06:26:24 +05:30
class GameListDir : public GameListItem {
public :
static const int GameDirRole = Qt : : UserRole + 2 ;
explicit GameListDir ( UISettings : : GameDir & directory ,
GameListItemType dir_type = GameListItemType : : CustomDir )
: dir_type { dir_type } {
setData ( type ( ) , TypeRole ) ;
UISettings : : GameDir * game_dir = & directory ;
setData ( QVariant : : fromValue ( game_dir ) , GameDirRole ) ;
2018-09-23 08:52:44 +05:30
constexpr std : : array < int , 3 > icon_sizes { { 0 , 24 , 48 } } ;
int icon_size = icon_sizes [ UISettings : : values . game_list_icon_size ] ;
2018-04-20 06:26:24 +05:30
switch ( dir_type ) {
case GameListItemType : : InstalledDir :
2018-09-23 08:52:44 +05:30
setData ( QIcon : : fromTheme ( " sd_card " ) . pixmap ( icon_size ) , Qt : : DecorationRole ) ;
2018-04-20 06:26:24 +05:30
setData ( " Installed Titles " , Qt : : DisplayRole ) ;
break ;
case GameListItemType : : SystemDir :
2018-09-23 08:52:44 +05:30
setData ( QIcon : : fromTheme ( " chip " ) . pixmap ( icon_size ) , Qt : : DecorationRole ) ;
2018-04-20 06:26:24 +05:30
setData ( " System Titles " , Qt : : DisplayRole ) ;
break ;
case GameListItemType : : CustomDir :
QString icon_name = QFileInfo : : exists ( game_dir - > path ) ? " folder " : " bad_folder " ;
2018-09-23 08:52:44 +05:30
setData ( QIcon : : fromTheme ( icon_name ) . pixmap ( icon_size ) , Qt : : DecorationRole ) ;
2018-04-20 06:26:24 +05:30
setData ( game_dir - > path , Qt : : DisplayRole ) ;
break ;
} ;
} ;
int type ( ) const override {
return static_cast < int > ( dir_type ) ;
}
private :
GameListItemType dir_type ;
} ;
class GameListAddDir : public GameListItem {
public :
explicit GameListAddDir ( ) {
setData ( type ( ) , TypeRole ) ;
2018-09-23 08:52:44 +05:30
constexpr std : : array < int , 3 > icon_sizes { { 0 , 24 , 48 } } ;
int icon_size = icon_sizes [ UISettings : : values . game_list_icon_size ] ;
setData ( QIcon : : fromTheme ( " plus " ) . pixmap ( icon_size ) , Qt : : DecorationRole ) ;
2018-04-20 06:26:24 +05:30
setData ( " Add New Game Directory " , Qt : : DisplayRole ) ;
}
int type ( ) const override {
return static_cast < int > ( GameListItemType : : AddDir ) ;
}
} ;
2015-09-01 10:05:33 +05:30
/**
* Asynchronous worker object for populating the game list .
* Communicates with other threads through Qt ' s signal / slot system .
*/
class GameListWorker : public QObject , public QRunnable {
Q_OBJECT
public :
2018-04-20 06:26:24 +05:30
explicit GameListWorker (
QList < UISettings : : GameDir > & game_dirs ,
2018-05-10 07:27:57 +05:30
const std : : unordered_map < std : : string , std : : pair < QString , QString > > & compatibility_list )
2018-08-24 20:44:09 +05:30
: game_dirs ( game_dirs ) , compatibility_list ( compatibility_list ) { }
2015-09-01 10:05:33 +05:30
public slots :
/// Starts the processing of directory tree information.
void run ( ) override ;
/// Tells the worker that it should no longer continue processing. Thread-safe.
void Cancel ( ) ;
signals :
/**
* The ` EntryReady ` signal is emitted once an entry has been prepared and is ready
* to be added to the game list .
2018-04-20 06:26:24 +05:30
* @ param entry_items a list with ` QStandardItem ` s that make up the columns of the new
* entry .
2015-09-01 10:05:33 +05:30
*/
2018-04-20 06:26:24 +05:30
void DirEntryReady ( GameListDir * entry_items ) ;
void EntryReady ( QList < QStandardItem * > entry_items , GameListDir * parent_dir ) ;
2017-04-18 08:23:40 +05:30
/**
2018-04-20 06:26:24 +05:30
* After the worker has traversed the game directory looking for entries , this signal is
* emitted with a list of folders that should be watched for changes as well .
2017-04-18 08:23:40 +05:30
*/
void Finished ( QStringList watch_list ) ;
2015-09-01 10:05:33 +05:30
private :
2017-04-18 08:23:40 +05:30
QStringList watch_list ;
2018-05-10 07:27:57 +05:30
const std : : unordered_map < std : : string , std : : pair < QString , QString > > & compatibility_list ;
2018-04-20 06:26:24 +05:30
QList < UISettings : : GameDir > & game_dirs ;
2015-09-01 10:05:33 +05:30
std : : atomic_bool stop_processing ;
2018-04-20 06:26:24 +05:30
void AddFstEntriesToGameList ( const std : : string & dir_path , unsigned int recursion ,
GameListDir * parent_dir ) ;
2015-09-01 10:05:33 +05:30
} ;
2018-07-23 16:13:34 +05:30
class GameList ;
class QHBoxLayout ;
class QTreeView ;
class QLabel ;
class QLineEdit ;
class QToolButton ;
class GameListSearchField : public QWidget {
Q_OBJECT
public :
explicit GameListSearchField ( GameList * parent = nullptr ) ;
void setFilterResult ( int visible , int total ) ;
void clear ( ) ;
void setFocus ( ) ;
int visible ;
int total ;
private :
class KeyReleaseEater : public QObject {
public :
explicit KeyReleaseEater ( GameList * gamelist ) ;
private :
GameList * gamelist = nullptr ;
QString edit_filter_text_old ;
protected :
// EventFilter in order to process systemkeys while editing the searchfield
bool eventFilter ( QObject * obj , QEvent * event ) override ;
} ;
QHBoxLayout * layout_filter = nullptr ;
QTreeView * tree_view = nullptr ;
QLabel * label_filter = nullptr ;
QLineEdit * edit_filter = nullptr ;
QLabel * label_filter_result = nullptr ;
QToolButton * button_filter_close = nullptr ;
} ;