void GameUI::showMenu()
{
MythGenericTree *node = m_gameUITree->GetCurrentNode();
MythScreenStack *popupStack = GetMythMainWindow()->
GetStack("popup stack");
MythDialogBox *showMenuPopup =
new MythDialogBox(node->GetText(), popupStack, "showMenuPopup");
if (showMenuPopup->Create())
{
showMenuPopup->SetReturnEvent(this, "showMenuPopup");
showMenuPopup->AddButton(tr("Scan For Changes"));
if (isLeaf(node))
{
RomInfo *romInfo = qVariantValue<RomInfo *>(node->GetData());
if (romInfo)
{
showMenuPopup->AddButton(tr("Show Information"));
if (romInfo->Favorite())
showMenuPopup->AddButton(tr("Remove Favorite"));
else
showMenuPopup->AddButton(tr("Make Favorite"));
showMenuPopup->AddButton(tr("Retrieve Details"));
showMenuPopup->AddButton(tr("Edit Details"));
}
}
popupStack->AddScreen(showMenuPopup);
}
else
delete showMenuPopup;
}
void GameScannerThread::removeOrphan(const int id)
{
RomInfo *info = RomInfo::GetRomInfoById(id);
if (info)
{
info->DeleteFromDatabase();
delete info;
info = NULL;
}
}
void GameUI::toggleFavorite(void)
{
MythGenericTree *node = m_gameUITree->GetCurrentNode();
if (isLeaf(node))
{
RomInfo *romInfo = qVariantValue<RomInfo *>(node->GetData());
romInfo->setFavorite(true);
updateChangedNode(node, romInfo);
}
}
void GameUI::StartGameImageSet(MythGenericTree *node, QStringList coverart,
QStringList fanart, QStringList screenshot)
{
if (!node)
return;
RomInfo *metadata = qVariantValue<RomInfo *>(node->GetData());
if (!metadata)
return;
ArtworkMap map;
QString inetref = metadata->Inetref();
QString system = metadata->System();
QString title = metadata->Gamename();
if (metadata->Boxart().isEmpty() && coverart.size())
{
ArtworkInfo info;
info.url = coverart.takeAt(0).trimmed();
map.insert(kArtworkCoverart, info);
}
if (metadata->Fanart().isEmpty() && fanart.size())
{
ArtworkInfo info;
info.url = fanart.takeAt(0).trimmed();
map.insert(kArtworkFanart, info);
}
if (metadata->Screenshot().isEmpty() && screenshot.size())
{
ArtworkInfo info;
info.url = screenshot.takeAt(0).trimmed();
map.insert(kArtworkScreenshot, info);
}
MetadataLookup *lookup = new MetadataLookup();
lookup->SetTitle(metadata->Gamename());
lookup->SetSystem(metadata->System());
lookup->SetInetref(metadata->Inetref());
lookup->SetType(kMetadataGame);
lookup->SetDownloads(map);
lookup->SetData(qVariantFromValue(node));
m_imageDownload->addDownloads(lookup);
}
void GameScannerThread::verifyFiles()
{
int counter = 0;
if (m_HasGUI)
SendProgressEvent(counter, (uint)m_dbgames.count(),
GameScanner::tr("Verifying game files..."));
// For every file we know about, check to see if it still exists.
for (QList<RomInfo*>::iterator p = m_dbgames.begin();
p != m_dbgames.end(); ++p)
{
RomInfo *info = *p;
QString romfile = info->Romname();
QString system = info->System();
QString gametype = info->GameType();
if (!romfile.isEmpty())
{
bool found = false;
for (QList<RomFileInfo>::iterator p = m_files.begin();
p != m_files.end(); ++p)
{
if ((*p).romfile == romfile &&
(*p).gametype == gametype)
{
// We're done here, this file matches one in the DB
(*p).indb = true;
found = true;
continue;
}
}
if (!found)
{
m_remove.append(info->Id());
}
}
if (m_HasGUI)
SendProgressEvent(++counter);
delete info;
info = NULL;
}
}
void GameUI::itemClicked(MythUIButtonListItem*)
{
MythGenericTree *node = m_gameUITree->GetCurrentNode();
if (isLeaf(node))
{
RomInfo *romInfo = qVariantValue<RomInfo *>(node->GetData());
if (!romInfo)
return;
if (romInfo->RomCount() == 1)
{
GameHandler::Launchgame(romInfo, NULL);
}
else
{
//: %1 is the game name
QString msg = QString(tr("Choose System for:\n%1"))
.arg(node->getString());
MythScreenStack *popupStack = GetMythMainWindow()->
GetStack("popup stack");
MythDialogBox *chooseSystemPopup = new MythDialogBox(
msg, popupStack, "chooseSystemPopup");
if (chooseSystemPopup->Create())
{
chooseSystemPopup->SetReturnEvent(this, "chooseSystemPopup");
QString all_systems = romInfo->AllSystems();
QStringList players = all_systems.split(",");
for (QStringList::Iterator it = players.begin();
it != players.end(); ++it)
{
chooseSystemPopup->AddButton(*it);
}
chooseSystemPopup->AddButton(tr("Cancel"));
popupStack->AddScreen(chooseSystemPopup);
}
else
delete chooseSystemPopup;
}
}
}
void GameUI::gameSearch(MythGenericTree *node,
bool automode)
{
if (!node)
node = m_gameUITree->GetCurrentNode();
if (!node)
return;
RomInfo *metadata = qVariantValue<RomInfo *>(node->GetData());
if (!metadata)
return;
MetadataLookup *lookup = new MetadataLookup();
lookup->SetStep(kLookupSearch);
lookup->SetType(kMetadataGame);
lookup->SetData(qVariantFromValue(node));
if (automode)
{
lookup->SetAutomatic(true);
}
lookup->SetTitle(metadata->Gamename());
lookup->SetInetref(metadata->Inetref());
if (m_query->isRunning())
m_query->prependLookup(lookup);
else
m_query->addLookup(lookup);
if (!automode)
{
//: %1 is the game name
QString msg = tr("Fetching details for %1")
.arg(metadata->Gamename());
createBusyDialog(msg);
}
}
void GameUI::handleDownloadedImages(MetadataLookup *lookup)
{
if (!lookup)
return;
MythGenericTree *node = qVariantValue<MythGenericTree *>(lookup->GetData());
if (!node)
return;
RomInfo *metadata = qVariantValue<RomInfo *>(node->GetData());
if (!metadata)
return;
DownloadMap downloads = lookup->GetDownloads();
if (downloads.isEmpty())
return;
for (DownloadMap::iterator i = downloads.begin();
i != downloads.end(); ++i)
{
VideoArtworkType type = i.key();
ArtworkInfo info = i.value();
QString filename = info.url;
if (type == kArtworkCoverart)
metadata->setBoxart(filename);
else if (type == kArtworkFanart)
metadata->setFanart(filename);
else if (type == kArtworkScreenshot)
metadata->setScreenshot(filename);
}
metadata->SaveToDatabase();
updateChangedNode(node, metadata);
}
void GameUI::OnGameSearchDone(MetadataLookup *lookup)
{
if (m_busyPopup)
{
m_busyPopup->Close();
m_busyPopup = NULL;
}
if (!lookup)
return;
MythGenericTree *node = qVariantValue<MythGenericTree *>(lookup->GetData());
if (!node)
return;
RomInfo *metadata = qVariantValue<RomInfo *>(node->GetData());
if (!metadata)
return;
metadata->setGamename(lookup->GetTitle());
metadata->setYear(QString::number(lookup->GetYear()));
metadata->setPlot(lookup->GetDescription());
metadata->setSystem(lookup->GetSystem());
QStringList coverart, fanart, screenshot;
// Imagery
ArtworkList coverartlist = lookup->GetArtwork(kArtworkCoverart);
for (ArtworkList::const_iterator p = coverartlist.begin();
p != coverartlist.end(); ++p)
{
coverart.prepend((*p).url);
}
ArtworkList fanartlist = lookup->GetArtwork(kArtworkFanart);
for (ArtworkList::const_iterator p = fanartlist.begin();
p != fanartlist.end(); ++p)
{
fanart.prepend((*p).url);
}
ArtworkList screenshotlist = lookup->GetArtwork(kArtworkScreenshot);
for (ArtworkList::const_iterator p = screenshotlist.begin();
p != screenshotlist.end(); ++p)
{
screenshot.prepend((*p).url);
}
StartGameImageSet(node, coverart, fanart, screenshot);
metadata->SaveToDatabase();
updateChangedNode(node, metadata);
}
void GameUI::nodeChanged(MythGenericTree* node)
{
if (!node)
return;
if (!isLeaf(node))
{
if (node->childCount() == 0 || node == m_favouriteNode)
{
node->deleteAllChildren();
fillNode(node);
}
clearRomInfo();
}
else
{
RomInfo *romInfo = qVariantValue<RomInfo *>(node->GetData());
if (!romInfo)
return;
if (romInfo->Romname().isEmpty())
romInfo->fillData();
updateRomInfo(romInfo);
if (!romInfo->Screenshot().isEmpty() || !romInfo->Fanart().isEmpty() ||
!romInfo->Boxart().isEmpty())
showImages();
else
{
if (m_gameImage)
m_gameImage->Reset();
if (m_fanartImage)
m_fanartImage->Reset();
if (m_boxImage)
m_boxImage->Reset();
}
}
}
void GameUI::fillNode(MythGenericTree *node)
{
QString layername = node->GetText();
RomInfo *romInfo = qVariantValue<RomInfo *>(node->GetData());
MSqlQuery query(MSqlQuery::InitCon());
query.prepare(getFillSql(node));
if (romInfo)
{
if (!romInfo->System().isEmpty())
query.bindValue(":SYSTEM", romInfo->System());
if (!romInfo->Year().isEmpty())
query.bindValue(":YEAR", romInfo->Year());
if (!romInfo->Genre().isEmpty())
query.bindValue(":GENRE", romInfo->Genre());
if (!romInfo->Plot().isEmpty())
query.bindValue(":PLOT", romInfo->Plot());
if (!romInfo->Publisher().isEmpty())
query.bindValue(":PUBLISHER", romInfo->Publisher());
if (!romInfo->Gamename().isEmpty())
query.bindValue(":GAMENAME", romInfo->Gamename());
}
bool IsLeaf = node->getInt() == getLevelsOnThisBranch(node);
if (query.exec() && query.size() > 0)
{
while (query.next())
{
QString current = query.value(0).toString().trimmed();
MythGenericTree *new_node =
new MythGenericTree(current, node->getInt() + 1, false);
if (IsLeaf)
{
RomInfo *temp = new RomInfo();
temp->setSystem(query.value(1).toString().trimmed());
temp->setYear(query.value(2).toString());
temp->setGenre(query.value(3).toString().trimmed());
temp->setGamename(query.value(4).toString().trimmed());
new_node->SetData(qVariantFromValue(temp));
node->addNode(new_node);
}
else
{
RomInfo *newRomInfo;
if (node->getInt() > 1)
{
RomInfo *currentRomInfo;
currentRomInfo = qVariantValue<RomInfo *>(node->GetData());
newRomInfo = new RomInfo(*currentRomInfo);
}
else
{
newRomInfo = new RomInfo();
}
new_node->SetData(qVariantFromValue(newRomInfo));
node->addNode(new_node);
if (getChildLevelString(node) != "hash")
newRomInfo->setField(getChildLevelString(node), current);
}
}
}
}
QString GameUI::getFillSql(MythGenericTree *node) const
{
QString layer = node->GetText();
int childDepth = node->getInt() + 1;
QString childLevel = getChildLevelString(node);
QString filter = getFilter(node);
bool childIsLeaf = childDepth == getLevelsOnThisBranch(node) + 1;
RomInfo *romInfo = qVariantValue<RomInfo *>(node->GetData());
QString columns;
QString conj = "where ";
if (!filter.isEmpty())
{
filter = conj + filter;
conj = " and ";
}
if ((childLevel == "gamename") && (m_gameShowFileName))
{
columns = childIsLeaf
? "romname,system,year,genre,gamename"
: "romname";
if (m_showHashed)
filter += " and romname like '" + layer + "%'";
}
else if ((childLevel == "gamename") && (layer.length() == 1))
{
columns = childIsLeaf
? childLevel + ",system,year,genre,gamename"
: childLevel;
if (m_showHashed)
filter += " and gamename like '" + layer + "%'";
}
else if (childLevel == "hash")
{
columns = "left(gamename,1)";
}
else
{
columns = childIsLeaf
? childLevel + ",system,year,genre,gamename"
: childLevel;
}
// this whole section ought to be in rominfo.cpp really, but I've put it
// in here for now to minimise the number of files changed by this mod
if (romInfo)
{
if (!romInfo->System().isEmpty())
{
filter += conj + "trim(system)=:SYSTEM";
conj = " and ";
}
if (!romInfo->Year().isEmpty())
{
filter += conj + "year=:YEAR";
conj = " and ";
}
if (!romInfo->Genre().isEmpty())
{
filter += conj + "trim(genre)=:GENRE";
conj = " and ";
}
if (!romInfo->Plot().isEmpty())
{
filter += conj + "plot=:PLOT";
conj = " and ";
}
if (!romInfo->Publisher().isEmpty())
{
filter += conj + "publisher=:PUBLISHER";
conj = " and ";
}
if (!romInfo->Gamename().isEmpty())
{
filter += conj + "trim(gamename)=:GAMENAME";
}
}
filter += conj + " display = 1 ";
QString sql;
if ((childLevel == "gamename") && (m_gameShowFileName))
{
sql = "select distinct "
+ columns
+ " from gamemetadata "
+ filter
+ " order by romname"
+ ";";
}
else if (childLevel == "hash")
{
sql = "select distinct "
+ columns
+ " from gamemetadata "
+ filter
+ " order by gamename,romname"
+ ";";
}
else
{
sql = "select distinct "
+ columns
+ " from gamemetadata "
+ filter
+ " order by "
+ childLevel
+ ";";
}
return sql;
}
void GameUI::customEvent(QEvent *event)
{
if (event->type() == DialogCompletionEvent::kEventType)
{
DialogCompletionEvent *dce = (DialogCompletionEvent*)(event);
QString resultid = dce->GetId();
QString resulttext = dce->GetResultText();
if (resultid == "showMenuPopup")
{
if (resulttext == tr("Edit Details"))
{
edit();
}
if (resulttext == tr("Scan For Changes"))
{
doScan();
}
else if (resulttext == tr("Show Information"))
{
showInfo();
}
else if (resulttext == tr("Make Favorite") ||
resulttext == tr("Remove Favorite"))
{
toggleFavorite();
}
else if (resulttext == tr("Retrieve Details"))
{
gameSearch();
}
}
else if (resultid == "chooseSystemPopup")
{
if (!resulttext.isEmpty() && resulttext != tr("Cancel"))
{
MythGenericTree *node = m_gameUITree->GetCurrentNode();
RomInfo *romInfo = qVariantValue<RomInfo *>(node->GetData());
GameHandler::Launchgame(romInfo, resulttext);
}
}
else if (resultid == "editMetadata")
{
MythGenericTree *node = m_gameUITree->GetCurrentNode();
RomInfo *oldRomInfo = qVariantValue<RomInfo *>(node->GetData());
delete oldRomInfo;
RomInfo *romInfo = qVariantValue<RomInfo *>(dce->GetData());
node->SetData(qVariantFromValue(romInfo));
node->SetText(romInfo->Gamename());
romInfo->SaveToDatabase();
updateChangedNode(node, romInfo);
}
else if (resultid == "detailsPopup")
{
// Play button pushed
itemClicked(0);
}
}
if (event->type() == MetadataLookupEvent::kEventType)
{
MetadataLookupEvent *lue = (MetadataLookupEvent *)event;
MetadataLookupList lul = lue->lookupList;
if (m_busyPopup)
{
m_busyPopup->Close();
m_busyPopup = NULL;
}
if (lul.isEmpty())
return;
if (lul.count() == 1)
{
OnGameSearchDone(lul.takeFirst());
}
else
{
MetadataResultsDialog *resultsdialog =
new MetadataResultsDialog(m_popupStack, lul);
connect(resultsdialog, SIGNAL(haveResult(MetadataLookup*)),
SLOT(OnGameSearchListSelection(MetadataLookup*)),
Qt::QueuedConnection);
if (resultsdialog->Create())
m_popupStack->AddScreen(resultsdialog);
}
}
else if (event->type() == MetadataLookupFailure::kEventType)
{
MetadataLookupFailure *luf = (MetadataLookupFailure *)event;
MetadataLookupList lul = luf->lookupList;
if (m_busyPopup)
{
m_busyPopup->Close();
m_busyPopup = NULL;
}
if (lul.size())
{
MetadataLookup *lookup = lul.takeFirst();
MythGenericTree *node = qVariantValue<MythGenericTree *>(lookup->GetData());
if (node)
{
RomInfo *metadata = qVariantValue<RomInfo *>(node->GetData());
if (metadata)
{
}
}
LOG(VB_GENERAL, LOG_ERR,
QString("No results found for %1").arg(lookup->GetTitle()));
}
}
else if (event->type() == ImageDLEvent::kEventType)
{
ImageDLEvent *ide = (ImageDLEvent *)event;
MetadataLookup *lookup = ide->item;
if (!lookup)
return;
handleDownloadedImages(lookup);
}
}
bool operator==(const RomInfo& a, const RomInfo& b)
{
return a.Romname() == b.Romname();
}
bool operator==(const RomInfo& a, const RomInfo& b)
{
if (a.Romname() == b.Romname())
return true;
return false;
}
