2015-09-01 05:35:33 +01:00
// 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-15 23:42:58 +01:00
# include <map>
# include <unordered_map>
2016-04-13 22:04:05 +01:00
# include <QImage>
2018-04-15 23:42:58 +01:00
# include <QObject>
# include <QPainter>
2015-09-01 05:35:33 +01:00
# include <QRunnable>
# include <QStandardItem>
# include <QString>
# include "citra_qt/util/util.h"
2018-04-15 23:42:58 +01:00
# include "common/logging/log.h"
2016-09-18 01:38:01 +01:00
# include "common/string_util.h"
2016-05-18 00:42:45 +01:00
# include "core/loader/smdh.h"
2016-04-13 22:04:05 +01:00
/**
2017-02-27 01:58:51 +00:00
* Gets the game icon from SMDH data .
* @ param smdh SMDH data
2016-04-13 22:04:05 +01:00
* @ param large If true , returns large icon ( 48 x48 ) , otherwise returns small icon ( 24 x24 )
* @ return QPixmap game icon
*/
2016-05-18 00:42:45 +01:00
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-13 22:04:05 +01:00
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-04-15 23:42:58 +01:00
/**
* Creates a circle pixmap from a specified color
* @ param color The color the pixmap shall have
* @ return QPixmap circle pixmap
*/
static QPixmap CreateCirclePixmapFromColor ( const QColor & color ) {
QPixmap circle_pixmap ( 16 , 16 ) ;
circle_pixmap . fill ( Qt : : transparent ) ;
QPainter painter ( & circle_pixmap ) ;
painter . setPen ( color ) ;
painter . setBrush ( color ) ;
painter . drawEllipse ( 0 , 0 , 15 , 15 ) ;
return circle_pixmap ;
}
2016-04-13 22:04:05 +01:00
/**
2017-02-27 01:58:51 +00:00
* Gets the short game title from SMDH data .
* @ param smdh SMDH data
2016-04-13 22:04:05 +01:00
* @ param language title language
* @ return QString short title
*/
2016-09-18 01:38:01 +01:00
static QString GetQStringShortTitleFromSMDH ( const Loader : : SMDH & smdh ,
Loader : : SMDH : : TitleLanguage language ) {
2016-05-18 00:42:45 +01:00
return QString : : fromUtf16 ( smdh . GetShortTitle ( language ) . data ( ) ) ;
2016-04-13 22:04:05 +01:00
}
2015-09-01 05:35:33 +01:00
2018-04-15 23:42:58 +01:00
struct CompatStatus {
QString color ;
QString text ;
QString tooltip ;
} ;
// When this is put in a class, MSVS builds crash when closing Citra
// clang-format off
const static inline std : : map < QString , CompatStatus > status_data = {
{ " 0 " , { " #5c93ed " , GameList : : tr ( " Perfect " ) , GameList : : tr ( " Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without \n any workarounds needed. " ) } } ,
{ " 1 " , { " #47d35c " , GameList : : tr ( " Great " ) , GameList : : tr ( " Game functions with minor graphical or audio glitches and is playable from start to finish. May require some \n workarounds. " ) } } ,
{ " 2 " , { " #94b242 " , GameList : : tr ( " Okay " ) , GameList : : tr ( " Game functions with major graphical or audio glitches, but game is playable from start to finish with \n workarounds. " ) } } ,
{ " 3 " , { " #f2d624 " , GameList : : tr ( " Bad " ) , GameList : : tr ( " Game functions, but with major graphical or audio glitches. Unable to progress in specific areas due to glitches \n even with workarounds. " ) } } ,
{ " 4 " , { " #FF0000 " , GameList : : tr ( " Intro/Menu " ) , GameList : : tr ( " Game is completely unplayable due to major graphical or audio glitches. Unable to progress past the Start \n Screen. " ) } } ,
{ " 5 " , { " #828282 " , GameList : : tr ( " Won't Boot " ) , GameList : : tr ( " The game crashes when attempting to startup. " ) } } ,
{ " 99 " , { " #000000 " , GameList : : tr ( " Not Tested " ) , GameList : : tr ( " The game has not yet been tested. " ) } } , } ;
// clang-format on
2015-09-01 05:35:33 +01:00
2018-04-15 23:42:58 +01:00
class GameListItem : public QStandardItem {
2015-09-01 05:35:33 +01:00
public :
2016-09-19 02:01:46 +01:00
GameListItem ( ) : QStandardItem ( ) { }
GameListItem ( const QString & string ) : QStandardItem ( string ) { }
virtual ~ GameListItem ( ) override { }
2015-09-01 05:35:33 +01:00
} ;
/**
* 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 15:26:59 +01:00
* If this class receives valid SMDH data , it will also display game icons and titles .
2015-09-01 05:35:33 +01:00
*/
class GameListItemPath : public GameListItem {
public :
static const int FullPathRole = Qt : : UserRole + 1 ;
2016-04-13 22:04:05 +01:00
static const int TitleRole = Qt : : UserRole + 2 ;
2016-12-15 09:55:03 +00:00
static const int ProgramIdRole = Qt : : UserRole + 3 ;
2015-09-01 05:35:33 +01:00
2016-09-19 02:01:46 +01:00
GameListItemPath ( ) : GameListItem ( ) { }
2018-01-24 03:32:27 +00:00
GameListItemPath ( const QString & game_path , const std : : vector < u8 > & smdh_data , u64 program_id )
2016-12-15 09:55:03 +00:00
: GameListItem ( ) {
2015-09-01 05:35:33 +01:00
setData ( game_path , FullPathRole ) ;
2016-12-15 09:55:03 +00:00
setData ( qulonglong ( program_id ) , ProgramIdRole ) ;
2016-04-13 22:04:05 +01:00
2018-01-24 03:32:27 +00:00
if ( ! Loader : : IsValidSMDH ( smdh_data ) ) {
2016-04-13 22:04:05 +01:00
// SMDH is not valid, set a default icon
setData ( GetDefaultIcon ( true ) , Qt : : DecorationRole ) ;
return ;
}
2018-01-24 16:17:04 +00:00
2018-01-24 16:16:40 +00:00
Loader : : SMDH smdh ;
2018-01-24 03:32:27 +00:00
memcpy ( & smdh , smdh_data . data ( ) , sizeof ( Loader : : SMDH ) ) ;
2016-04-13 22:04:05 +01:00
// Get icon from SMDH
2016-05-18 00:42:45 +01:00
setData ( GetQPixmapFromSMDH ( smdh , true ) , Qt : : DecorationRole ) ;
2016-04-13 22:04:05 +01:00
2018-01-20 17:33:14 +00:00
// Get title from SMDH
2016-09-18 01:38:01 +01:00
setData ( GetQStringShortTitleFromSMDH ( smdh , Loader : : SMDH : : TitleLanguage : : English ) ,
TitleRole ) ;
2015-09-01 05:35:33 +01:00
}
2016-04-13 22:04:05 +01:00
QVariant data ( int role ) const override {
if ( role = = Qt : : DisplayRole ) {
2015-09-01 05:35:33 +01:00
std : : string filename ;
2016-09-18 01:38:01 +01:00
Common : : SplitPath ( data ( FullPathRole ) . toString ( ) . toStdString ( ) , nullptr , & filename ,
nullptr ) ;
2016-04-13 22:04:05 +01:00
QString title = data ( TitleRole ) . toString ( ) ;
return QString : : fromStdString ( filename ) + ( title . isEmpty ( ) ? " " : " \n " + title ) ;
2015-09-01 05:35:33 +01:00
} else {
2016-04-13 22:04:05 +01:00
return GameListItem : : data ( role ) ;
2015-09-01 05:35:33 +01:00
}
}
} ;
2018-04-15 23:42:58 +01:00
class GameListItemCompat : public GameListItem {
public :
static const int CompatNumberRole = Qt : : UserRole + 1 ;
GameListItemCompat ( ) = default ;
explicit GameListItemCompat ( const QString compatiblity ) {
auto iterator = status_data . find ( compatiblity ) ;
if ( iterator = = status_data . end ( ) ) {
NGLOG_WARNING ( Frontend , " Invalid compatibility number {} " , compatiblity . toStdString ( ) ) ;
return ;
}
CompatStatus status = iterator - > second ;
setData ( compatiblity , CompatNumberRole ) ;
setText ( status . text ) ;
setToolTip ( status . tooltip ) ;
setData ( CreateCirclePixmapFromColor ( status . color ) , Qt : : DecorationRole ) ;
}
bool operator < ( const QStandardItem & other ) const override {
return data ( CompatNumberRole ) < other . data ( CompatNumberRole ) ;
}
} ;
2015-09-01 05:35:33 +01:00
/**
* 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 :
static const int SizeRole = Qt : : UserRole + 1 ;
2016-09-19 02:01:46 +01:00
GameListItemSize ( ) : GameListItem ( ) { }
2016-09-18 01:38:01 +01:00
GameListItemSize ( const qulonglong size_bytes ) : GameListItem ( ) {
2015-09-01 05:35:33 +01:00
setData ( size_bytes , SizeRole ) ;
}
2016-09-18 01:38:01 +01:00
void setData ( const QVariant & value , int role ) override {
2015-09-01 05:35:33 +01:00
// 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 ) ;
}
}
/**
* This operator is , in practice , only used by the TreeView sorting systems .
2016-09-18 01:38:01 +01:00
* Override it so that it will correctly sort by numerical value instead of by string
* representation .
2015-09-01 05:35:33 +01:00
*/
2016-09-18 01:38:01 +01:00
bool operator < ( const QStandardItem & other ) const override {
2015-09-01 05:35:33 +01:00
return data ( SizeRole ) . toULongLong ( ) < other . data ( SizeRole ) . toULongLong ( ) ;
}
} ;
/**
* 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-15 23:42:58 +01:00
GameListWorker ( QString dir_path , bool deep_scan ,
const std : : unordered_map < std : : string , QString > & compatibility_list )
: QObject ( ) , QRunnable ( ) , dir_path ( dir_path ) , deep_scan ( deep_scan ) ,
compatibility_list ( compatibility_list ) { }
2015-09-01 05:35:33 +01:00
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 .
* @ param entry_items a list with ` QStandardItem ` s that make up the columns of the new entry .
*/
void EntryReady ( QList < QStandardItem * > entry_items ) ;
2017-04-18 03:53:40 +01:00
/**
* After the worker has traversed the game directory looking for entries , this signal is emmited
* with a list of folders that should be watched for changes as well .
*/
void Finished ( QStringList watch_list ) ;
2015-09-01 05:35:33 +01:00
private :
2017-04-18 03:53:40 +01:00
QStringList watch_list ;
2015-09-01 05:35:33 +01:00
QString dir_path ;
bool deep_scan ;
2018-04-15 23:42:58 +01:00
const std : : unordered_map < std : : string , QString > & compatibility_list ;
2015-09-01 05:35:33 +01:00
std : : atomic_bool stop_processing ;
2015-09-06 07:59:04 +01:00
void AddFstEntriesToGameList ( const std : : string & dir_path , unsigned int recursion = 0 ) ;
2015-09-01 05:35:33 +01:00
} ;