Ticket #1810: gamePatch4.patch

mythgame/gamehandler.cpp

@@ -3 +3 @@
 #include "rom_metadata.h"
 
 #include <qobject.h>
+#include <qapplication.h>
+#include <qtimer.h>
+#include <qprocess.h>
 #include <qptrlist.h>
 #include <qstringlist.h>
 #include <iostream>
@@ -14 +17 @@
 #include <mythtv/mythdialogs.h>
 #include <mythtv/util.h>
 
+QProcess *process;
+QString screencmd;
+
 using namespace std;
 
 static QPtrList<GameHandler> *handlers = 0;
@@ -64 +70 @@
 void GameHandler::updateSettings(GameHandler *handler)
 {
     MSqlQuery query(MSqlQuery::InitCon());
-    query.exec("SELECT rompath, workingpath, commandline, screenshots, gameplayerid, gametype, extensions, spandisks  FROM gameplayers WHERE playername = \"" + handler->SystemName() + "\";");
+    query.exec("SELECT rompath, workingpath, commandline, screenshots, gameplayerid, gametype, extensions, spandisks, screenshotenabled, screenshotcmd FROM gameplayers WHERE playername = \"" + handler->SystemName() + "\";");
 
     query.next();
     handler->rompath = query.value(0).toString();
@@ -75 +81 @@
     handler->gametype = query.value(5).toString();
     handler->validextensions = QStringList::split(",", query.value(6).toString().stripWhiteSpace().remove(" "));
     handler->spandisks = query.value(7).toInt();
+    handler->screenshotenabled = query.value(8).toInt();
+    handler->screenshotcmd = query.value(9).toInt();
 
 }
 
@@ -131 +139 @@
         cerr << "No romDB data read from database. Not imported?" << endl;
     else
         cerr << "Loaded " << romDB.count() << " items from romDB Database" << endl;
-
 }
 
 void GameHandler::GetMetadata(GameHandler *handler, QString rom, QString* Genre, QString* Year,
@@ -227 +234 @@
 
 }
 
+
 void updateDisplayRom(QString romname, int display, QString Systemname)
 {
     MSqlQuery query(MSqlQuery::InitCon());
@@ -731 +739 @@
     else if (!(handler = GetHandler(romdata)))
     {
         // Couldn't get handler so abort.
-        return;
+        return ;
     }
     QString exec = handler->SystemCmdLine();
 
@@ -824 +832 @@
     handlers->append(handler);
 }
 
+bool GameHandler::promptShouldOverwrite()
+{
+        QStringList buttonText;
+    buttonText += QObject::tr("No");
+    buttonText += QObject::tr("Yes");
+
+
+    int result = MythPopupBox::showButtonPopup(gContext->GetMainWindow(), 
+                               QObject::tr("Overwrite existing screenshots?"),
+                               QString(QObject::tr("Would you like to overwrite any existing screenshots?")),
+                                                    buttonText, 0 );
+    switch (result)
+    {
+        case 0:
+            return false;
+        case 1:
+            return true;
+    };
+        
+        return false;
+}
+
+void GameHandler::generateScreenshots(void)
+{
+    checkHandlers();
+
+    GameHandler *handler = handlers->first();
+
+    MSqlQuery query(MSqlQuery::InitCon());
+   // MSqlQuery squery(MSqlQuery::InitCon());   
+
+        
+    while(handler)
+    {
+        updateSettings(handler);
+        
+        if (handler->ScreenShotEnabled())
+        {
+        
+                
+        
+                QString thequery;       
+                thequery = QString("SELECT romname, rompath, gamename, diskcount "
+                                                        "FROM gamemetadata WHERE system = '%1';")
+                           .arg(handler->SystemName());
+                           
+        query.exec(thequery);
+
+                // display a dialog box to show the number of roms left to process as it flashes by.
+                MythProgressDialog screenshotDlg(QString("Generating %1(%2) screenshots")
+                                   .arg(handler->SystemName())
+                                   .arg(handler->GameType()),
+                                   query.numRowsAffected());
+        
+                //QString screenquery;
+                //screenquery = QString("SELECT screenshots FROM gameplayers WHERE playername  = '%1';").arg(handler->PlayerName());
+                //squery.exec(screenquery);
+                
+                //QString screenpath = query.value(0).toString();
+
+                // boolean value to skip existing screenshots from being generated again.
+                bool should_overwrite = promptShouldOverwrite();
+                
+        
+                if (should_overwrite) 
+                        cout << "Screenshot generation started. Overwriting existing screenshots." << endl;
+                else 
+                        cout << "Screenshot generation started. NOT Overwriting existing screenshots." << endl;
+                
+                // start at -1 so we can pre-increment the screenshot counter as the 
+                // first step in the loop - thus letting us break out of the loop
+                // and go to the next iteration without having to worry about the
+                // progress bar
+                int counter = -1;
+                
+                
+                if (query.isActive() && query.size() >0)
+                {
+                        
+                        while (query.next())
+                        {
+                        
+                                screenshotDlg.setProgress(++counter);
+                                
+                                QString romname = query.value(0).toString();
+                                QString rompath = query.value(1).toString();
+                                int diskcount   = query.value(3).toInt();
+                                //Get the Extension via the RomInfo Class
+                                RomInfo temp;
+                                temp.setRomname(romname);
+                                QString extension = temp.getExtension();
+                                
+                                QString basename = romname.left(romname.length() - (extension.length() + 1));
+                                
+                                QString exec = handler->SystemCmdLine();
+                                
+                                
+                                                                
+                                if (handler->GameType() != "PC")
+                                {
+                                        QString arg = "\"" + rompath + "/" + romname + "\"";
+                                        
+                                        // only bother checking if a screenshot exists if the user specified they care to keep them
+                                        // - doing this saves time at execution.
+                                        if (!should_overwrite) {
+                                                QString ImageCheck(romname);
+                                                cout << "Searching for existing screenshot for rom: " << ImageCheck <<  " at " << handler->SystemScreenShots() << "/" << romname << endl;
+                                                
+                                                if (RomInfo::FindImage(handler->SystemScreenShots() + "/" + romname, &ImageCheck)) {
+                                                        cout << "\tFound at: " << ImageCheck << endl;
+                                                        continue; 
+                                                }
+                                                
+                                        }
+                                        
+                                        // If they specified a %s in the commandline place the romname
+                                        // in that location, otherwise tack it on to the end of
+                                        // the command.
+                                        if (exec.contains("%s") || handler->SpanDisks())
+                                        {
+                                                exec = exec.replace(QRegExp("%s"),arg);
+                                                
+                                                if (handler->SpanDisks())
+                                                {
+                                                        QRegExp rxp = QRegExp( "%d[0-4]", TRUE, FALSE );
+                                                        
+                                                        if (exec.contains(rxp)) 
+                                                        {
+                                                                if (diskcount > 1) 
+                                                                {
+                                                                        // Chop off the extension, .  and last character of the name which we are assuming is the disk #
+                                                                        QString rom;
+                                                                        QString diskid[] = { "%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6" };
+                                                                        
+                                                                        for (int disk = 1; disk <= diskcount; disk++)
+                                                                        {
+                                                                                rom = QString("\"%1/%2%3.%4\"")
+                                                                                .arg(rompath)
+                                                                                .arg(basename)
+                                                                                .arg(disk)
+                                                                                .arg(extension);
+                                                                                exec = exec.replace(QRegExp(diskid[disk]),rom);
+                                                                        }
+                                                                } 
+                                                                
+                                                                else
+                                                                {   // If there is only one disk make sure we replace %d1 just like %s
+                                                                        exec = exec.replace(QRegExp("%d1"),arg);
+                                                                }
+                                                        }
+                                                }
+                                        }
+                                        else
+                                        {
+                                                exec = exec + " \"" + 
+                            rompath + "/" +
+                            romname + "\"";
+                                        }
+                                }
+                                
+                                QString savedir = QDir::currentDirPath ();
+                                QDir d;
+                                if (handler->SystemWorkingPath()) {
+                                        if (!d.cd(handler->SystemWorkingPath()))
+                                        {
+                                                cout << "Failed to change to specified Working Directory : " << handler->SystemWorkingPath() << endl;
+                                        }
+                                }
+                                
+                                if (handler->ScreenShotCmd().length() < 2)
+                                        screencmd = gContext->GetSetting("GameScreenshotCmd");
+                                else
+                                        screencmd = handler->ScreenShotCmd();
+                                
+                                if (screencmd.contains("%p"))
+                                {
+                                        QString reptxt = handler->SystemScreenShots() + "/" + basename;
+                                        screencmd = screencmd.replace(QRegExp("%p"),reptxt);
+                                }
+                                
+                                if (screencmd.contains("%s"))
+                                {
+                                        QString reptxt = rompath + "/" + romname;
+                                        screencmd = screencmd.replace(QRegExp("%s"),reptxt);        
+                                }
+                                
+                                process = new QProcess();
+                                
+                                // We need to pass separate args to QProcess. Rather than split 
+                                // "exec" up, (which would require parsing the user-supplied 
+                                // command), get sh to do it
+                                QStringList shellCmd;
+                                
+                                shellCmd.append("sh");
+                                shellCmd.append("-c");
+                                shellCmd.append(exec);
+                                
+                                process->setArguments(shellCmd);
+                                
+                                QString ShotTime = gContext->GetSetting("GameScreenshotTime");
+                                int myShotTime = ShotTime.toInt() * 1000;
+                                
+                                m_TimerDone = false;
+                                
+                                QTimer::singleShot( myShotTime, this, SLOT( screenshotTimeout() ) );
+                                
+                                if (!process->start())
+                                        cout << "Error running Process:" << exec << endl;
+                                
+                                // some emulators such as xmame or sdlmess will 
+                                // quit prematurely if it is fed a bad ROM file. The m_TimerDone
+                                // variable is set to true when the timer kills the process.
+                                // if this is not done, the program can trip over itself because 
+                                // it would iterate throuh the next step in the loop, and then then 
+                                // when the timer is run out - it would kill whatever process happened
+                                // to be pointing to.
+                                while (process->isRunning() | !m_TimerDone){ 
+                                        qApp->processEvents(); 
+                                }
+                                
+                                delete process;
+                        }
+                }
+                
+                screenshotDlg.Close();
+        }
+                
+        handler = handlers->next();
+        
+    }
+}
+void GameHandler::screenshotTimeout(void)
+{
+        // there is a chance the process already killed itself... 
+        // in which case we don't need to take a screenshot of the MythTV Gui 
+        if (process->isRunning()) {
+                myth_system(screencmd);
+                process->kill();
+        }
+        m_TimerDone = true;
+}

mythgame/game_settings.xml

@@ -24 +24 @@
       <text>Game Players</text>
       <text lang="IT">Impostazioni generali</text>
       <text lang="ES">Opciones Reproductores</text>
-      <text lang="CA">Opcions Generals</text>
-      <text lang="DE">Grundeinstellungen</text>
+      <text lang="CA"></text>
+      <text lang="DE">Spielestarter</text>
       <text lang="DK">Spil Systemer</text>
       <text lang="NL">Algemeen</text>
       <text lang="PT">Jogadores</text>
@@ -59 +59 @@
       <text>Clear Game Data</text>
       <text lang="IT">Impostazioni generali</text>
       <text lang="ES">Borrar Datos</text>
-      <text lang="CA">Opcions Generals</text>
-      <text lang="DE">Grundeinstellungen</text>
+      <text lang="CA"></text>
+      <text lang="DE">Loesche Spieleliste</text>
       <text lang="DK">Slet spil data</text>
-      <text lang="NL">Algemeen</text>
+      <text lang="NL"></text>
       <text lang="PT">Apagar Dados de Jogos</text>
       <text lang="SV">Generella instÀllningar</text>
       <text lang="SI">Splošne nastavitve</text>
@@ -73 +73 @@
       <action>CLEAR_GAME_DATA</action>
    </button>
 
+   <button>
+      <type>GAME_SETTINGS_GENERAL</type>
+      <text>Generate Screenshots</text>
+      <text lang="IT"></text>
+      <text lang="ES"></text>
+      <text lang="CA"></text>
+      <text lang="DE">Screenshots erzeugen</text>
+      <text lang="DK"></text>
+      <text lang="NL"></text>
+      <text lang="PT"></text>
+      <text lang="SV"></text>
+      <text lang="SI"></text>
+      <text lang="FI"></text>
+      <action>GENERATE_SCREENSHOTS</action>
+   </button>
 
 </mythmenu>

mythgame/gamehandler.h

@@ -53 +53 @@
 
 typedef QMap <QString, GameScan> GameScanMap;
 
-class GameHandler
-{
+class GameHandler : public QObject
+{  
+  
+  Q_OBJECT
+  
   public:
     GameHandler()
     {
         m_RemoveAll = false;
         m_KeepAll = false;
+                m_TimerDone = false;
         rebuild = false;
     }
 
@@ -74 +78 @@
                              QString* Publisher, QString* Version);
 
     void promptForRemoval(QString filename, QString RomPath );
-    void UpdateGameDB(GameHandler *handler);
+        void UpdateGameDB(GameHandler *handler);
     void VerifyGameDB(GameHandler *handler);
 
     static void clearAllGameData(void); 
+    void generateScreenshots(void); 
 
     static int buildFileCount(QString directory, GameHandler *handler);
     void buildFileList(QString directory, GameHandler *handler, 
@@ -96 +101 @@
 
     static RomInfo* create_rominfo(RomInfo* parent);
     int SpanDisks() const { return spandisks; }
+        
+    int ScreenShotEnabled() const { return screenshotenabled; }
+        bool promptShouldOverwrite();
+        
     QString SystemName() const { return systemname; }
     QString SystemCmdLine() const { return commandline; }
     QString SystemRomPath() const { return rompath; }
@@ -103 +112 @@
     QString SystemScreenShots() const { return screenshots; }
     uint GamePlayerID() const { return gameplayerid; }
     QString GameType() const { return gametype; }
+    QString ScreenShotCmd() const { return screenshotcmd; }
+    
+  public slots:
+    void screenshotTimeout(void);
 
   protected:
     static GameHandler* GetHandler(RomInfo *rominfo);
@@ -110 +123 @@
 
     bool rebuild;
     int spandisks;
+    int screenshotenabled;
     QString systemname;
     QString rompath;
     QString commandline;
@@ -117 +131 @@
     QString screenshots;
     uint gameplayerid;
     QString gametype;
+    QString screenshotcmd;
     QStringList validextensions;
 
     RomDBMap romDB;
@@ -124 +139 @@
 
     bool m_RemoveAll;
     bool m_KeepAll;
-
+        bool m_TimerDone;
+        
   private:
     static GameHandler* newInstance;
 

mythgame/rominfo.h

@@ -52 +52 @@
 
     virtual ~RomInfo() {}
 
-    bool FindImage(QString BaseFileName, QString *result);
+    static bool FindImage(QString BaseFileName, QString *result);
 
     QString Rompath() const { return rompath; }
     void setRompath(const QString &lrompath) { rompath = lrompath; }

mythgame/dbcheck.cpp

@@ -10 +10 @@
 
 #include "gamesettings.h"
 
-const QString currentDatabaseVersion = "1012";
+const QString currentDatabaseVersion = "1013";
 
 static bool UpdateDBVersionNumber(const QString &newnumber)
 {
@@ -320 +320 @@
     }
 
 
+    if (dbver == "1012")
+    {
+        const QString updates[] = {
+"ALTER TABLE gameplayers ADD COLUMN screenshotcmd text NOT NULL default ''; ",
+"ALTER TABLE gameplayers ADD COLUMN screenshotenabled tinyint(1) NOT NULL default '0'; ",
+""
+};
 
+        if (!performActualUpdate(updates, "1013", dbver))
+            return false;
+    }
 
 
+
+
+
     return true;
 }

mythgame/main.cpp

@@ -34 +34 @@
         settings.exec();
     }
 
-    if (sel == "game_players")
+    else if (sel == "game_players")
     {
         MythGamePlayerEditor mgpe;
         mgpe.exec();
@@ -43 +43 @@
     {
         GameHandler::processAllGames();
     }
-    if (sel == "clear_game_data")
+    
+    else if (sel == "clear_game_data")
     {
         GameHandler::clearAllGameData();
     }
 
+    else if (sel == "generate_screenshots")
+    {
+        GameHandler myHandler;
+        myHandler.generateScreenshots();
+    }
+
 }
 
 void runMenu(QString which_menu)

mythgame/gamesettings.cpp

@@ -75 +75 @@
     gc->setHelpText(QObject::tr("Enabling this causes the filenames to be displayed in the game tree rather than the trimmed/looked up gamename"));
     return gc;
 }   
+static HostLineEdit *GameScreenshotCmd()
+{
+    HostLineEdit *gc = new HostLineEdit("GameScreenshotCmd");
+    gc->setLabel(QObject::tr("Screenshot Command"));
+    gc->setValue("/usr/bin/scrot --quality 1 \"%p.png\"");
+    gc->setHelpText(QObject::tr("Program which generates Screenshots "
+                    "when the Rom is started in Background "
+                    "use %s for romname and %p for the imagename without extension."));
+    return gc;
+}
 
+static HostLineEdit *GameScreenshotTime()
+{
+    HostLineEdit *gc = new HostLineEdit("GameScreenshotTime");
+    gc->setLabel(QObject::tr("Screenshot Timeout:"));
+    gc->setValue("10");
+    gc->setHelpText(QObject::tr("Enter Time (in seconds) after which a Screenshot is taken"));
+    return gc;
+}
+
 static HostCheckBox *GameTreeView()
 {
     HostCheckBox *gc = new HostCheckBox("GameTreeView");
@@ -95 +114 @@
     general->addChild(GameRemovalPrompt());
     general->addChild(GameShowFileNames());
     general->addChild(GameTreeView());
+    VerticalConfigurationGroup *screenshot = new VerticalConfigurationGroup(false);
+    screenshot->setLabel(QObject::tr("MythGame Settings -- Screenshots"));
+    screenshot->addChild(GameScreenshotCmd());
+    screenshot->addChild(GameScreenshotTime());
+
     addChild(general);
+    addChild(screenshot);
 }
 
 // Player Settings
@@ -190 +215 @@
     };
 };
 
+class GenerateScreenshots: virtual public MGSetting, virtual public CheckBoxSetting {
+public:
+    GenerateScreenshots(const MythGamePlayerSettings& parent):
+        MGSetting(parent, "screenshotenabled") {
+        setLabel(QObject::tr("Generate screenshots"));
+        setHelpText(QObject::tr("This setting means that this Gameplayer is included in the generation of screenshots."));
+    };
+};
+
+class GenerateScreenshotsCmd: virtual public MGSetting, virtual public LineEditSetting {
+public:
+    GenerateScreenshotsCmd(const MythGamePlayerSettings& parent):
+        MGSetting(parent, "screenshotcmd") {
+        setLabel(QObject::tr("Screenshot Command"));
+        setHelpText(QObject::tr("If you want another Command then the global to Generate Screenshots, Enter it here!"));
+    };
+};
+
 MythGamePlayerSettings::MythGamePlayerSettings()
 {
     // must be first
@@ -205 +248 @@
     group->addChild(new WorkingDirPath(*this));
     group->addChild(new Extensions(*this));
     group->addChild(new AllowMultipleRoms(*this));
+    group->addChild(new GenerateScreenshots(*this));
+    group->addChild(new GenerateScreenshotsCmd(*this));
     addChild(group);
 };