funkey/RetroFE
1
0
Fork 0
mirror of https://github.com/FunKey-Project/RetroFE.git synced 2026-02-21 08:41:41 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Setting code formatting standard to allman.

Browse Source
This commit is contained in:
emb 2015-01-01 14:08:42 -06:00
parent 174ea4f4f9
commit 6410139f87
76 changed files with 5352 additions and 5314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
Source/Collection/CollectionInfo.cpp
View File

@ -1,20 +1,20 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#include "CollectionInfo.h"
#include "../Database/Configuration.h"
#include <sstream>
CollectionInfo::CollectionInfo(std::string name,
std::string listPath,
std::string extensions,
std::string metadataType,
CollectionInfo::CollectionInfo(std::string name,
std::string listPath,
std::string extensions,
std::string metadataType,
std::string metadataPath)
: Name(name)
, ListPath(listPath)
, Extensions(extensions)
, MetadataType(metadataType)
, MetadataPath(metadataPath)
: Name(name)
, ListPath(listPath)
, Extensions(extensions)
, MetadataType(metadataType)
, MetadataPath(metadataPath)
{
}
@ -24,43 +24,43 @@ CollectionInfo::~CollectionInfo()
std::string CollectionInfo::GetName() const
{
return Name;
return Name;
}
std::string CollectionInfo::GetSettingsPath() const
{
return Configuration::GetAbsolutePath() + "/Collections/" + GetName();
return Configuration::GetAbsolutePath() + "/Collections/" + GetName();
}
std::string CollectionInfo::GetListPath() const
{
return ListPath;
return ListPath;
}
std::string CollectionInfo::GetMetadataType() const
{
return MetadataType;
return MetadataType;
}
std::string CollectionInfo::GetMetadataPath() const
{
return MetadataPath;
return MetadataPath;
}
std::string CollectionInfo::GetExtensions() const
{
return Extensions;
return Extensions;
}
void CollectionInfo::GetExtensions(std::vector<std::string> &extensions)
{
std::istringstream ss(Extensions);
std::string token;
std::istringstream ss(Extensions);
std::string token;
while(std::getline(ss, token, ','))
{
extensions.push_back(token);
}
while(std::getline(ss, token, ','))
{
extensions.push_back(token);
}
}

32
Source/Collection/CollectionInfo.h
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#pragma once
@ -9,20 +9,20 @@
class CollectionInfo
{
public:
CollectionInfo(std::string name, std::string listPath, std::string extensions, std::string metadataType, std::string metadataPath);
virtual ~CollectionInfo();
std::string GetName() const;
std::string GetSettingsPath() const;
std::string GetListPath() const;
std::string GetMetadataType() const;
std::string GetMetadataPath() const;
std::string GetExtensions() const;
void GetExtensions(std::vector<std::string> &extensions);
CollectionInfo(std::string name, std::string listPath, std::string extensions, std::string metadataType, std::string metadataPath);
virtual ~CollectionInfo();
std::string GetName() const;
std::string GetSettingsPath() const;
std::string GetListPath() const;
std::string GetMetadataType() const;
std::string GetMetadataPath() const;
std::string GetExtensions() const;
void GetExtensions(std::vector<std::string> &extensions);
private:
std::string Name;
std::string ListPath;
std::string Extensions;
std::string MetadataType;
std::string MetadataPath;
std::string Name;
std::string ListPath;
std::string Extensions;
std::string MetadataType;
std::string MetadataPath;
};

166
Source/Collection/CollectionInfoBuilder.cpp
View File

@ -6,121 +6,121 @@
#include <vector>
CollectionInfoBuilder::CollectionInfoBuilder(Configuration *c)
: Conf(c)
: Conf(c)
{
}
CollectionInfoBuilder::~CollectionInfoBuilder()
{
std::map<std::string, CollectionInfo *>::iterator it = InfoMap.begin();
std::map<std::string, CollectionInfo *>::iterator it = InfoMap.begin();
for(it == InfoMap.begin(); it != InfoMap.end(); ++it)
{
delete it->second;
}
for(it == InfoMap.begin(); it != InfoMap.end(); ++it)
{
delete it->second;
}
InfoMap.clear();
InfoMap.clear();
}
bool CollectionInfoBuilder::LoadAllCollections()
{
std::vector<std::string> collections;
std::vector<std::string> collections;
Conf->GetChildKeyCrumbs("collections", collections);
Conf->GetChildKeyCrumbs("collections", collections);
if(collections.size() == 0)
{
Logger::Write(Logger::ZONE_ERROR, "Collections", "No collections were found. Please configure Settings.conf");
return false;
}
if(collections.size() == 0)
{
Logger::Write(Logger::ZONE_ERROR, "Collections", "No collections were found. Please configure Settings.conf");
return false;
}
bool retVal = true;
std::vector<std::string>::iterator it;
bool retVal = true;
std::vector<std::string>::iterator it;
for(it = collections.begin(); it != collections.end(); ++it)
{
// todo: There is nothing that should really stop us from creating a collection
// in the main folder. I just need to find some time to look at the impacts if
// I remove this conditional check.
if(*it != "Main")
{
if(ImportCollection(*it))
{
Logger::Write(Logger::ZONE_INFO, "Collections", "Adding collection " + *it);
}
else
{
// Continue processing the rest of the collections if an error occurs during import.
// ImportCollection() will print out an error to the log file.
retVal = false;
}
}
}
for(it = collections.begin(); it != collections.end(); ++it)
{
// todo: There is nothing that should really stop us from creating a collection
// in the main folder. I just need to find some time to look at the impacts if
// I remove this conditional check.
if(*it != "Main")
{
if(ImportCollection(*it))
{
Logger::Write(Logger::ZONE_INFO, "Collections", "Adding collection " + *it);
}
else
{
// Continue processing the rest of the collections if an error occurs during import.
// ImportCollection() will print out an error to the log file.
retVal = false;
}
}
}
return retVal;
return retVal;
}
void CollectionInfoBuilder::GetCollections(std::vector<CollectionInfo *> &collections)
{
std::map<std::string, CollectionInfo *>::iterator InfoMapIt;
std::map<std::string, CollectionInfo *>::iterator InfoMapIt;
for(InfoMapIt = InfoMap.begin(); InfoMapIt != InfoMap.end(); ++InfoMapIt)
{
collections.push_back(InfoMapIt->second);
}
for(InfoMapIt = InfoMap.begin(); InfoMapIt != InfoMap.end(); ++InfoMapIt)
{
collections.push_back(InfoMapIt->second);
}
}
bool CollectionInfoBuilder::ImportCollection(std::string name)
{
// create a new instance if one does not exist
if(InfoMap.find(name) != InfoMap.end())
{
return true;
}
std::string listItemsPathKey = "collections." + name + ".list.path";
std::string listFilterKey = "collections." + name + ".list.filter";
std::string extensionsKey = "collections." + name + ".list.extensions";
std::string launcherKey = "collections." + name + ".launcher";
// create a new instance if one does not exist
if(InfoMap.find(name) != InfoMap.end())
{
return true;
}
std::string listItemsPathKey = "collections." + name + ".list.path";
std::string listFilterKey = "collections." + name + ".list.filter";
std::string extensionsKey = "collections." + name + ".list.extensions";
std::string launcherKey = "collections." + name + ".launcher";
//todo: metadata is not fully not implemented
std::string metadataTypeKey = "collections." + name + ".metadata.type";
std::string metadataPathKey = "collections." + name + ".metadata.path";
//todo: metadata is not fully not implemented
std::string metadataTypeKey = "collections." + name + ".metadata.type";
std::string metadataPathKey = "collections." + name + ".metadata.path";
std::string listItemsPath;
std::string launcherName;
std::string extensions;
std::string metadataType;
std::string metadataPath;
std::string listItemsPath;
std::string launcherName;
std::string extensions;
std::string metadataType;
std::string metadataPath;
if(!Conf->GetPropertyAbsolutePath(listItemsPathKey, listItemsPath))
{
Logger::Write(Logger::ZONE_INFO, "Collections", "Property \"" + listItemsPathKey + "\" does not exist. Assuming \"" + name + "\" is a menu");
return false;
}
if(!Conf->GetPropertyAbsolutePath(listItemsPathKey, listItemsPath))
{
Logger::Write(Logger::ZONE_INFO, "Collections", "Property \"" + listItemsPathKey + "\" does not exist. Assuming \"" + name + "\" is a menu");
return false;
}
if(!Conf->GetProperty(extensionsKey, extensions))
{
Logger::Write(Logger::ZONE_INFO, "Collections", "Property \"" + extensionsKey + "\" does not exist. Assuming \"" + name + "\" is a menu");
return false;
}
if(!Conf->GetProperty(extensionsKey, extensions))
{
Logger::Write(Logger::ZONE_INFO, "Collections", "Property \"" + extensionsKey + "\" does not exist. Assuming \"" + name + "\" is a menu");
return false;
}
(void)Conf->GetProperty(metadataTypeKey, metadataType);
(void)Conf->GetProperty(metadataPathKey, metadataPath);
(void)Conf->GetProperty(metadataTypeKey, metadataType);
(void)Conf->GetProperty(metadataPathKey, metadataPath);
if(!Conf->GetProperty(launcherKey, launcherName))
{
std::stringstream ss;
ss << "Warning: launcher property \""
<< launcherKey
<< "\" points to a launcher that is not configured (launchers."
<< launcherName
<< "). Your collection will be viewable, however you will not be able to "
<< "launch any of the items in your collection.";
if(!Conf->GetProperty(launcherKey, launcherName))
{
std::stringstream ss;
ss << "Warning: launcher property \""
<< launcherKey
<< "\" points to a launcher that is not configured (launchers."
<< launcherName
<< "). Your collection will be viewable, however you will not be able to "
<< "launch any of the items in your collection.";
Logger::Write(Logger::ZONE_WARNING, "Collections", ss.str());
}
Logger::Write(Logger::ZONE_WARNING, "Collections", ss.str());
}
InfoMap[name] = new CollectionInfo(name, listItemsPath, extensions, metadataType, metadataPath);
InfoMap[name] = new CollectionInfo(name, listItemsPath, extensions, metadataType, metadataPath);
return (InfoMap[name] != NULL);
return (InfoMap[name] != NULL);
}

18
Source/Collection/CollectionInfoBuilder.h
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#pragma once
@ -13,13 +13,13 @@ class CollectionInfo;
class CollectionInfoBuilder
{
public:
CollectionInfoBuilder(Configuration *c);
virtual ~CollectionInfoBuilder();
bool LoadAllCollections();
void GetCollections(std::vector<CollectionInfo *> &keys);
CollectionInfoBuilder(Configuration *c);
virtual ~CollectionInfoBuilder();
bool LoadAllCollections();
void GetCollections(std::vector<CollectionInfo *> &keys);
private:
bool ImportCollection(std::string name);
std::map<std::string, CollectionInfo *> InfoMap;
Configuration *Conf;
bool ImportCollection(std::string name);
std::map<std::string, CollectionInfo *> InfoMap;
Configuration *Conf;
};

84
Source/Collection/Item.cpp
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#include "Item.h"
#include "../Utility/Utils.h"
@ -7,9 +7,9 @@
#include <algorithm>
Item::Item()
: NumberPlayers(0)
, NumberButtons(0)
, Leaf(true)
: NumberPlayers(0)
, NumberButtons(0)
, Leaf(true)
{
}
@ -19,142 +19,148 @@ Item::~Item()
const std::string Item::GetFileName() const
{
return Utils::GetFileName(FilePath);
return Utils::GetFileName(FilePath);
}
const std::string& Item::GetFilePath() const
{
return FilePath;
return FilePath;
}
void Item::SetFilePath(const std::string& filepath)
{
FilePath = filepath;
FilePath = filepath;
}
const std::string& Item::GetLauncher() const
{
return Launcher;
return Launcher;
}
void Item::SetLauncher(const std::string& launcher)
{
Launcher = launcher;
Launcher = launcher;
}
const std::string& Item::GetManufacturer() const
{
return Manufacturer;
return Manufacturer;
}
void Item::SetManufacturer(const std::string& manufacturer)
{
Manufacturer = manufacturer;
Manufacturer = manufacturer;
}
const std::string& Item::GetName() const
{
return Name;
return Name;
}
void Item::SetName(const std::string& name)
{
Name = name;
Name = name;
}
int Item::GetNumberButtons() const
{
return NumberButtons;
return NumberButtons;
}
std::string Item::GetNumberButtonsString()
{
std::stringstream ss;
ss << NumberButtons;
return ss.str();
std::stringstream ss;
ss << NumberButtons;
return ss.str();
}
void Item::SetNumberButtons(int numberbuttons)
{
NumberButtons = numberbuttons;
NumberButtons = numberbuttons;
}
int Item::GetNumberPlayers() const
{
return NumberPlayers;
return NumberPlayers;
}
std::string Item::GetNumberPlayersString()
{
std::stringstream ss;
ss << NumberButtons;
return ss.str();
std::stringstream ss;
ss << NumberButtons;
return ss.str();
}
void Item::SetNumberPlayers(int numberplayers)
{
NumberPlayers = numberplayers;
NumberPlayers = numberplayers;
}
const std::string& Item::GetTitle() const
{
return Title;
return Title;
}
const std::string& Item::GetLCTitle() const
{
return LCTitle;
return LCTitle;
}
void Item::SetTitle(const std::string& title)
{
Title = title;
LCTitle = Title;
std::transform(LCTitle.begin(), LCTitle.end(), LCTitle.begin(), ::tolower);
Title = title;
LCTitle = Title;
std::transform(LCTitle.begin(), LCTitle.end(), LCTitle.begin(), ::tolower);
}
const std::string& Item::GetYear() const
{
return Year;
return Year;
}
void Item::SetYear(const std::string& year)
{
Year = year;
Year = year;
}
bool Item::IsLeaf() const
{
return Leaf;
return Leaf;
}
void Item::SetIsLeaf(bool leaf)
{
Leaf = leaf;
Leaf = leaf;
}
const std::string& Item::GetFullTitle() const
{
return FullTitle;
return FullTitle;
}
void Item::SetFullTitle(const std::string& fulltitle)
{
FullTitle = fulltitle;
FullTitle = fulltitle;
}
const std::string& Item::GetCloneOf() const
{
return CloneOf;
return CloneOf;
}
void Item::SetCloneOf(const std::string& cloneOf)
{
CloneOf = cloneOf;
CloneOf = cloneOf;
}
bool Item::operator<(const Item &rhs) { return LCTitle < rhs.LCTitle; }
bool Item::operator>(const Item &rhs) { return LCTitle > rhs.LCTitle; }
bool Item::operator<(const Item &rhs)
{
return LCTitle < rhs.LCTitle;
}
bool Item::operator>(const Item &rhs)
{
return LCTitle > rhs.LCTitle;
}

88
Source/Collection/Item.h
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#pragma once
@ -8,49 +8,49 @@
class Item
{
public:
Item();
virtual ~Item();
const std::string GetFileName() const;
const std::string& GetFilePath() const;
void SetFilePath(const std::string& filepath);
const std::string& GetLauncher() const;
void SetLauncher(const std::string& launcher);
const std::string& GetManufacturer() const;
void SetManufacturer(const std::string& manufacturer);
const std::string& GetName() const;
void SetName(const std::string& name);
int GetNumberButtons() const;
std::string GetNumberButtonsString();
void SetNumberButtons(int numberbuttons);
void SetNumberPlayers(int numberplayers);
int GetNumberPlayers() const;
std::string GetNumberPlayersString();
const std::string& GetTitle() const;
const std::string& GetLCTitle() const;
void SetTitle(const std::string& title);
const std::string& GetYear() const;
void SetYear(const std::string& year);
bool IsLeaf() const;
void SetIsLeaf(bool leaf);
const std::string& GetFullTitle() const;
void SetFullTitle(const std::string& fulltitle);
const std::string& GetCloneOf() const;
void SetCloneOf(const std::string& cloneOf);
bool operator<(const Item& rhs);
bool operator>(const Item& rhs);
Item();
virtual ~Item();
const std::string GetFileName() const;
const std::string& GetFilePath() const;
void SetFilePath(const std::string& filepath);
const std::string& GetLauncher() const;
void SetLauncher(const std::string& launcher);
const std::string& GetManufacturer() const;
void SetManufacturer(const std::string& manufacturer);
const std::string& GetName() const;
void SetName(const std::string& name);
int GetNumberButtons() const;
std::string GetNumberButtonsString();
void SetNumberButtons(int numberbuttons);
void SetNumberPlayers(int numberplayers);
int GetNumberPlayers() const;
std::string GetNumberPlayersString();
const std::string& GetTitle() const;
const std::string& GetLCTitle() const;
void SetTitle(const std::string& title);
const std::string& GetYear() const;
void SetYear(const std::string& year);
bool IsLeaf() const;
void SetIsLeaf(bool leaf);
const std::string& GetFullTitle() const;
void SetFullTitle(const std::string& fulltitle);
const std::string& GetCloneOf() const;
void SetCloneOf(const std::string& cloneOf);
bool operator<(const Item& rhs);
bool operator>(const Item& rhs);
private:
std::string Launcher;
std::string FilePath;
std::string Name;
std::string Title;
std::string LCTitle;
std::string FullTitle;
std::string Year;
std::string Manufacturer;
std::string CloneOf;
int NumberPlayers;
int NumberButtons;
bool Leaf;
std::string Launcher;
std::string FilePath;
std::string Name;
std::string Title;
std::string LCTitle;
std::string FullTitle;
std::string Year;
std::string Manufacturer;
std::string CloneOf;
int NumberPlayers;
int NumberButtons;
bool Leaf;
};

134
Source/Collection/MenuParser.cpp
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#include "MenuParser.h"
#include "Item.h"
@ -14,7 +14,7 @@
bool VectorSort(const Item *d1, const Item *d2)
{
return d1->GetLCTitle() < d2->GetLCTitle();
return d1->GetLCTitle() < d2->GetLCTitle();
}
MenuParser::MenuParser()
@ -28,81 +28,81 @@ MenuParser::~MenuParser()
//todo: clean up this method, too much nesting
bool MenuParser::GetMenuItems(CollectionDatabase *cdb, std::string collectionName, std::vector<Item *> &items)
{
bool retVal = false;
//todo: magic string
std::string menuFilename = Configuration::GetAbsolutePath() + "/Collections/" + collectionName + "/Menu.xml";
rapidxml::xml_document<> doc;
rapidxml::xml_node<> * rootNode;
bool retVal = false;
//todo: magic string
std::string menuFilename = Configuration::GetAbsolutePath() + "/Collections/" + collectionName + "/Menu.xml";
rapidxml::xml_document<> doc;
rapidxml::xml_node<> * rootNode;
Logger::Write(Logger::ZONE_INFO, "Menu", "Checking if menu exists at \"" + menuFilename + "\"");
Logger::Write(Logger::ZONE_INFO, "Menu", "Checking if menu exists at \"" + menuFilename + "\"");
try
{
std::ifstream file(menuFilename.c_str());
try
{
std::ifstream file(menuFilename.c_str());
// gracefully exit if there is no menu file for the pa
if(file.good())
{
Logger::Write(Logger::ZONE_INFO, "Menu", "Found menu");
std::vector<char> buffer((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
// gracefully exit if there is no menu file for the pa
if(file.good())
{
Logger::Write(Logger::ZONE_INFO, "Menu", "Found menu");
std::vector<char> buffer((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
buffer.push_back('\0');
buffer.push_back('\0');
doc.parse<0>(&buffer[0]);
doc.parse<0>(&buffer[0]);
rootNode = doc.first_node("menu");
rootNode = doc.first_node("menu");
for (rapidxml::xml_node<> * itemNode = rootNode->first_node("item"); itemNode; itemNode = itemNode->next_sibling())
{
rapidxml::xml_attribute<> *collectionAttribute = itemNode->first_attribute("collection");
rapidxml::xml_attribute<> *importAttribute = itemNode->first_attribute("import");
if(!collectionAttribute)
for (rapidxml::xml_node<> * itemNode = rootNode->first_node("item"); itemNode; itemNode = itemNode->next_sibling())
{
retVal = false;
Logger::Write(Logger::ZONE_ERROR, "Menu", "Menu item tag is missing collection attribute");
break;
rapidxml::xml_attribute<> *collectionAttribute = itemNode->first_attribute("collection");
rapidxml::xml_attribute<> *importAttribute = itemNode->first_attribute("import");
if(!collectionAttribute)
{
retVal = false;
Logger::Write(Logger::ZONE_ERROR, "Menu", "Menu item tag is missing collection attribute");
break;
}
else
{
//todo: too much nesting! Ack!
std::string import;
if(importAttribute)
{
import = importAttribute->value();
}
if(import != "true")
{
//todo, check for empty string
std::string title = collectionAttribute->value();
Item *item = new Item();
item->SetTitle(title);
item->SetFullTitle(title);
item->SetName(collectionAttribute->value());
item->SetIsLeaf(false);
items.push_back(item);
}
else
{
std::string collectionName = collectionAttribute->value();
Logger::Write(Logger::ZONE_INFO, "Menu", "Loading collection into menu: " + collectionName);
cdb->GetCollection(collectionAttribute->value(), items);
}
}
}
else
{
//todo: too much nesting! Ack!
std::string import;
if(importAttribute)
{
import = importAttribute->value();
}
if(import != "true")
{
//todo, check for empty string
std::string title = collectionAttribute->value();
Item *item = new Item();
item->SetTitle(title);
item->SetFullTitle(title);
item->SetName(collectionAttribute->value());
item->SetIsLeaf(false);
items.push_back(item);
}
else
{
std::string collectionName = collectionAttribute->value();
Logger::Write(Logger::ZONE_INFO, "Menu", "Loading collection into menu: " + collectionName);
cdb->GetCollection(collectionAttribute->value(), items);
}
}
}
std::sort( items.begin(), items.end(), VectorSort);
std::sort( items.begin(), items.end(), VectorSort);
retVal = true;
}
}
catch(std::ifstream::failure &e)
{
std::stringstream ss;
ss << "Unable to open menu file \"" << menuFilename << "\": " << e.what();
Logger::Write(Logger::ZONE_ERROR, "Menu", ss.str());
}
retVal = true;
}
}
catch(std::ifstream::failure &e)
{
std::stringstream ss;
ss << "Unable to open menu file \"" << menuFilename << "\": " << e.what();
Logger::Write(Logger::ZONE_ERROR, "Menu", ss.str());
}
return retVal;
return retVal;
}

10
Source/Collection/MenuParser.h
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#pragma once
#include "Item.h"
@ -10,8 +10,8 @@ class CollectionDatabase;
class MenuParser
{
public:
MenuParser();
virtual ~MenuParser();
bool GetMenuItems(CollectionDatabase *cdb, std::string collectionName, std::vector<Item *> &items);
MenuParser();
virtual ~MenuParser();
bool GetMenuItems(CollectionDatabase *cdb, std::string collectionName, std::vector<Item *> &items);
};

84
Source/Control/UserInput.cpp
View File

@ -1,12 +1,12 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#include "UserInput.h"
#include "../Database/Configuration.h"
#include "../Utility/Log.h"
UserInput::UserInput(Configuration *c)
: Config(c)
: Config(c)
{
}
@ -16,63 +16,63 @@ UserInput::~UserInput()
bool UserInput::Initialize()
{
bool retVal = true;
bool retVal = true;
retVal = MapKey("nextItem", KeyCodeNextItem) && retVal;
retVal = MapKey("previousItem", KeyCodePreviousItem) && retVal;
retVal = MapKey("pageDown", KeyCodePageDown) && retVal;
retVal = MapKey("pageUp", KeyCodePageUp) && retVal;
retVal = MapKey("select", KeyCodeSelect) && retVal;
retVal = MapKey("back", KeyCodeBack) && retVal;
retVal = MapKey("quit", KeyCodeQuit) && retVal;
// these features will need to be implemented at a later time
retVal = MapKey("nextItem", KeyCodeNextItem) && retVal;
retVal = MapKey("previousItem", KeyCodePreviousItem) && retVal;
retVal = MapKey("pageDown", KeyCodePageDown) && retVal;
retVal = MapKey("pageUp", KeyCodePageUp) && retVal;
retVal = MapKey("select", KeyCodeSelect) && retVal;
retVal = MapKey("back", KeyCodeBack) && retVal;
retVal = MapKey("quit", KeyCodeQuit) && retVal;
// these features will need to be implemented at a later time
// retVal = MapKey("admin", KeyCodeAdminMode) && retVal;
// retVal = MapKey("remove", KeyCodeHideItem) && retVal;
return retVal;
return retVal;
}
SDL_Scancode UserInput::GetScancode(KeyCode_E key)
{
SDL_Scancode scancode = SDL_SCANCODE_UNKNOWN;
std::map<KeyCode_E, SDL_Scancode>::iterator it = KeyMap.find(key);
SDL_Scancode scancode = SDL_SCANCODE_UNKNOWN;
std::map<KeyCode_E, SDL_Scancode>::iterator it = KeyMap.find(key);
if(it != KeyMap.end())
{
scancode = it->second;
}
if(it != KeyMap.end())
{
scancode = it->second;
}
return scancode;
return scancode;
}
bool UserInput::MapKey(std::string keyDescription, KeyCode_E key)
{
bool retVal = false;
SDL_Scancode scanCode;
std::string description;
bool retVal = false;
SDL_Scancode scanCode;
std::string description;
std::string configKey = "controls." + keyDescription;
std::string configKey = "controls." + keyDescription;
if(!Config->GetProperty(configKey, description))
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Missing property " + configKey);
}
else
{
scanCode = SDL_GetScancodeFromName(description.c_str());
if(!Config->GetProperty(configKey, description))
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Missing property " + configKey);
}
else
{
scanCode = SDL_GetScancodeFromName(description.c_str());
if(scanCode == SDL_SCANCODE_UNKNOWN)
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Unsupported property value for " + configKey + "(" + description + "). See Documentation/Keycodes.txt for valid inputs");
}
else
{
KeyMap[key] = scanCode;
retVal = true;
}
}
if(scanCode == SDL_SCANCODE_UNKNOWN)
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Unsupported property value for " + configKey + "(" + description + "). See Documentation/Keycodes.txt for valid inputs");
}
else
{
KeyMap[key] = scanCode;
retVal = true;
}
}
return retVal;
return retVal;
}

42
Source/Control/UserInput.h
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#pragma once
#include <map>
@ -11,28 +11,28 @@ class Configuration;
class UserInput
{
public:
enum KeyCode_E
{
KeyCodeNextItem,
KeyCodePreviousItem,
KeyCodeSelect,
KeyCodeBack,
KeyCodePageDown,
KeyCodePageUp,
KeyCodeAdminMode,
KeyCodeHideItem,
KeyCodeQuit
};
enum KeyCode_E
{
KeyCodeNextItem,
KeyCodePreviousItem,
KeyCodeSelect,
KeyCodeBack,
KeyCodePageDown,
KeyCodePageUp,
KeyCodeAdminMode,
KeyCodeHideItem,
KeyCodeQuit
};
UserInput(Configuration *c);
virtual ~UserInput();
bool Initialize();
SDL_Scancode GetScancode(KeyCode_E key);
UserInput(Configuration *c);
virtual ~UserInput();
bool Initialize();
SDL_Scancode GetScancode(KeyCode_E key);
private:
bool MapKey(std::string keyDescription, KeyCode_E key);
std::map<KeyCode_E, SDL_Scancode> KeyMap;
bool MapKey(std::string keyDescription, KeyCode_E key);
std::map<KeyCode_E, SDL_Scancode> KeyMap;
Configuration *Config;
Configuration *Config;
};

1044
Source/Database/CollectionDatabase.cpp
View File

File diff suppressed because it is too large Load Diff

40
Source/Database/CollectionDatabase.h
View File

@ -15,30 +15,30 @@ class Item;
class CollectionDatabase
{
public:
CollectionDatabase(DB *db, Configuration *c);
virtual ~CollectionDatabase();
bool Initialize();
bool Import();
bool ResetDatabase();
CollectionDatabase(DB *db, Configuration *c);
virtual ~CollectionDatabase();
bool Initialize();
bool Import();
bool ResetDatabase();
bool GetCollection(std::string collectionName, std::vector<Item *> &list);
bool SetHidden(std::string collectionName, Item *item, bool hidden);
bool GetCollection(std::string collectionName, std::vector<Item *> &list);
bool SetHidden(std::string collectionName, Item *item, bool hidden);
private:
unsigned long CalculateCollectionCrc32(CollectionInfo *info);
bool CollectionChanged(CollectionInfo *info, unsigned long crc32);
unsigned long CrcFile(std::string file, unsigned long crc);
unsigned long CalculateCollectionCrc32(CollectionInfo *info);
bool CollectionChanged(CollectionInfo *info, unsigned long crc32);
unsigned long CrcFile(std::string file, unsigned long crc);
// bool ImportMetadata(CollectionInfo *info);
bool ImportDirectory(CollectionInfo *info, unsigned long crc32);
bool ImportBasicList(CollectionInfo *info,
std::string file,
std::map<std::string, Item *> &list);
bool ImportHyperList(CollectionInfo *info,
std::string file,
std::map<std::string, Item *> &list);
std::map<std::string, Item *> *ImportHyperList(CollectionInfo *info);
Configuration *Config;
DB *DBInstance;
bool ImportDirectory(CollectionInfo *info, unsigned long crc32);
bool ImportBasicList(CollectionInfo *info,
std::string file,
std::map<std::string, Item *> &list);
bool ImportHyperList(CollectionInfo *info,
std::string file,
std::map<std::string, Item *> &list);
std::map<std::string, Item *> *ImportHyperList(CollectionInfo *info);
Configuration *Config;
DB *DBInstance;
};

378
Source/Database/Configuration.cpp
View File

@ -19,7 +19,7 @@
std::string Configuration::AbsolutePath;
Configuration::Configuration()
: Verbose(false)
: Verbose(false)
{
}
@ -27,307 +27,307 @@ Configuration::~Configuration()
{
}
void Configuration::Initialize()
void Configuration::Initialize()
{
const char *environment = std::getenv("RETROFE_PATH");
std::string environmentStr;
if (environment != NULL)
{
environmentStr = environment;
Configuration::SetAbsolutePath(environment);
}
else
{
const char *environment = std::getenv("RETROFE_PATH");
std::string environmentStr;
if (environment != NULL)
{
environmentStr = environment;
Configuration::SetAbsolutePath(environment);
}
else
{
#ifdef WIN32
HMODULE hModule = GetModuleHandle(NULL);
CHAR exe[MAX_PATH];
GetModuleFileName(hModule, exe, MAX_PATH);
std::string sPath(exe);
sPath = Utils::GetDirectory(sPath);
sPath = Utils::GetParentDirectory(sPath);
HMODULE hModule = GetModuleHandle(NULL);
CHAR exe[MAX_PATH];
GetModuleFileName(hModule, exe, MAX_PATH);
std::string sPath(exe);
sPath = Utils::GetDirectory(sPath);
sPath = Utils::GetParentDirectory(sPath);
#else
char exepath[1024];
sprintf(exepath, "/proc/%d/exe", getpid());
readlink(exepath, exepath, sizeof(exepath));
std::string sPath(exepath);
sPath = Utils::GetDirectory(sPath);
char exepath[1024];
sprintf(exepath, "/proc/%d/exe", getpid());
readlink(exepath, exepath, sizeof(exepath));
std::string sPath(exepath);
sPath = Utils::GetDirectory(sPath);
#endif
Configuration::SetAbsolutePath(sPath);
}
Configuration::SetAbsolutePath(sPath);
}
}
bool Configuration::Import(std::string keyPrefix, std::string file)
{
bool retVal = true;
int lineCount = 0;
std::string line;
bool retVal = true;
int lineCount = 0;
std::string line;
Logger::Write(Logger::ZONE_INFO, "Configuration", "Importing " + file);
Logger::Write(Logger::ZONE_INFO, "Configuration", "Importing " + file);
std::ifstream ifs(file.c_str());
std::ifstream ifs(file.c_str());
if (!ifs.is_open())
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Could not open " + file);
if (!ifs.is_open())
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Could not open " + file);
return false;
}
return false;
}
while (std::getline (ifs, line))
{
lineCount++;
retVal = retVal && ParseLine(keyPrefix, line, lineCount);
}
while (std::getline (ifs, line))
{
lineCount++;
retVal = retVal && ParseLine(keyPrefix, line, lineCount);
}
ifs.close();
ifs.close();
return retVal;
return retVal;
}
bool Configuration::ParseLine(std::string keyPrefix, std::string line, int lineCount)
{
bool retVal = false;
std::string key;
std::string value;
size_t position;
std::string delimiter = "=";
bool retVal = false;
std::string key;
std::string value;
size_t position;
std::string delimiter = "=";
// strip out any comments
if((position = line.find("#")) != std::string::npos)
{
line = line.substr(0, position);
}
// unix only wants \n. Windows uses \r\n. Strip off the \r for unix.
line.erase( std::remove(line.begin(), line.end(), '\r'), line.end() );
if(line.empty() || (line.find_first_not_of(" \t\r") == std::string::npos))
{
retVal = true;
}
// all configuration fields must have an assignment operator
else if((position = line.find(delimiter)) != std::string::npos)
{
if(keyPrefix.size() != 0)
{
keyPrefix += ".";
}
// strip out any comments
if((position = line.find("#")) != std::string::npos)
{
line = line.substr(0, position);
}
// unix only wants \n. Windows uses \r\n. Strip off the \r for unix.
line.erase( std::remove(line.begin(), line.end(), '\r'), line.end() );
if(line.empty() || (line.find_first_not_of(" \t\r") == std::string::npos))
{
retVal = true;
}
// all configuration fields must have an assignment operator
else if((position = line.find(delimiter)) != std::string::npos)
{
if(keyPrefix.size() != 0)
{
keyPrefix += ".";
}
key = keyPrefix + line.substr(0, position);
key = keyPrefix + line.substr(0, position);
key = TrimEnds(key);
key = TrimEnds(key);
value = line.substr(position + delimiter.length(), line.length());
value = TrimEnds(value);
value = line.substr(position + delimiter.length(), line.length());
value = TrimEnds(value);
Properties.insert(PropertiesPair(key, value));
Properties.insert(PropertiesPair(key, value));
std::stringstream ss;
ss << "Dump: " << "\"" << key << "\" = \"" << value << "\"";
std::stringstream ss;
ss << "Dump: " << "\"" << key << "\" = \"" << value << "\"";
Logger::Write(Logger::ZONE_INFO, "Configuration", ss.str());
retVal = true;
}
else
{
std::stringstream ss;
ss << "Missing an assignment operator (=) on line " << lineCount;
Logger::Write(Logger::ZONE_ERROR, "Configuration", ss.str());
}
Logger::Write(Logger::ZONE_INFO, "Configuration", ss.str());
retVal = true;
}
else
{
std::stringstream ss;
ss << "Missing an assignment operator (=) on line " << lineCount;
Logger::Write(Logger::ZONE_ERROR, "Configuration", ss.str());
}
return retVal;
return retVal;
}
std::string Configuration::TrimEnds(std::string str)
{
// strip off any initial tabs or spaces
size_t trimStart = str.find_first_not_of(" \t");
// strip off any initial tabs or spaces
size_t trimStart = str.find_first_not_of(" \t");
if(trimStart != std::string::npos)
{
size_t trimEnd = str.find_last_not_of(" \t");
if(trimStart != std::string::npos)
{
size_t trimEnd = str.find_last_not_of(" \t");
str = str.substr(trimStart, trimEnd - trimStart + 1);
}
str = str.substr(trimStart, trimEnd - trimStart + 1);
}
return str;
return str;
}
bool Configuration::GetProperty(std::string key, std::string &value)
{
bool retVal = false;
if(Properties.find(key) != Properties.end())
{
value = Properties[key];
bool retVal = false;
if(Properties.find(key) != Properties.end())
{
value = Properties[key];
retVal = true;
}
else if(Verbose)
{
Logger::Write(Logger::ZONE_DEBUG, "Configuration", "Missing property " + key);
}
retVal = true;
}
else if(Verbose)
{
Logger::Write(Logger::ZONE_DEBUG, "Configuration", "Missing property " + key);
}
return retVal;
return retVal;
}
bool Configuration::GetProperty(std::string key, int &value)
{
std::string strValue;
std::string strValue;
bool retVal = GetProperty(key, strValue);
bool retVal = GetProperty(key, strValue);
if(retVal)
{
std::stringstream ss;
ss << strValue;
ss >> value;
}
if(retVal)
{
std::stringstream ss;
ss << strValue;
ss >> value;
}
return retVal;
return retVal;
}
bool Configuration::GetProperty(std::string key, bool &value)
{
std::string strValue;
std::string strValue;
bool retVal = GetProperty(key, strValue);
bool retVal = GetProperty(key, strValue);
if(retVal)
{
std::stringstream ss;
ss << strValue;
if(retVal)
{
std::stringstream ss;
ss << strValue;
for(unsigned int i=0; i < strValue.length(); ++i)
{
std::locale loc;
strValue[i] = std::tolower(strValue[i], loc);
}
for(unsigned int i=0; i < strValue.length(); ++i)
{
std::locale loc;
strValue[i] = std::tolower(strValue[i], loc);
}
if(!strValue.compare("yes") || !strValue.compare("true"))
{
value = true;
}
else
{
value = false;
}
}
if(!strValue.compare("yes") || !strValue.compare("true"))
{
value = true;
}
else
{
value = false;
}
}
return retVal;
return retVal;
}
void Configuration::SetProperty(std::string key, std::string value)
{
Properties[key] = value;
Properties[key] = value;
}
bool Configuration::PropertyExists(std::string key)
{
return (Properties.find(key) != Properties.end());
return (Properties.find(key) != Properties.end());
}
bool Configuration::PropertyPrefixExists(std::string key)
{
PropertiesType::iterator it;
PropertiesType::iterator it;
for(it = Properties.begin(); it != Properties.end(); ++it)
{
std::string search = key + ".";
if(it->first.compare(0, search.length(), search) == 0)
{
return true;
}
}
for(it = Properties.begin(); it != Properties.end(); ++it)
{
std::string search = key + ".";
if(it->first.compare(0, search.length(), search) == 0)
{
return true;
}
}
return false;
return false;
}
void Configuration::GetChildKeyCrumbs(std::string parent, std::vector<std::string> &children)
{
PropertiesType::iterator it;
PropertiesType::iterator it;
for(it = Properties.begin(); it != Properties.end(); ++it)
{
std::string search = parent + ".";
if(it->first.compare(0, search.length(), search) == 0)
{
std::string crumb = Utils::Replace(it->first, search, "");
for(it = Properties.begin(); it != Properties.end(); ++it)
{
std::string search = parent + ".";
if(it->first.compare(0, search.length(), search) == 0)
{
std::string crumb = Utils::Replace(it->first, search, "");
std::size_t end = crumb.find_first_of(".");
std::size_t end = crumb.find_first_of(".");
if(end != std::string::npos)
{
crumb = crumb.substr(0, end);
}
if(end != std::string::npos)
{
crumb = crumb.substr(0, end);
}
if(std::find(children.begin(), children.end(), crumb) == children.end())
{
children.push_back(crumb);
}
}
}
if(std::find(children.begin(), children.end(), crumb) == children.end())
{
children.push_back(crumb);
}
}
}
}
std::string Configuration::ConvertToAbsolutePath(std::string prefix, std::string path)
{
char first = ' ';
char second = ' ';
char first = ' ';
char second = ' ';
if(path.length() >= 0)
{
first = path.c_str()[0];
}
if(path.length() >= 1)
{
second = path.c_str()[1];
}
if(path.length() >= 0)
{
first = path.c_str()[0];
}
if(path.length() >= 1)
{
second = path.c_str()[1];
}
// check to see if it is already an absolute path
if((first != '/') &&
(first != '\\') &&
//(first != '.') &&
(second != ':'))
{
path = prefix + "/" + path;
}
// check to see if it is already an absolute path
if((first != '/') &&
(first != '\\') &&
//(first != '.') &&
(second != ':'))
{
path = prefix + "/" + path;
}
return path;
return path;
}
bool Configuration::GetPropertyAbsolutePath(std::string key, std::string &value)
{
bool retVal = GetProperty(key, value);
bool retVal = GetProperty(key, value);
if(retVal)
{
value = ConvertToAbsolutePath(GetAbsolutePath(), value);
}
if(retVal)
{
value = ConvertToAbsolutePath(GetAbsolutePath(), value);
}
return retVal;
return retVal;
}
void Configuration::SetAbsolutePath(std::string absolutePath)
{
AbsolutePath = absolutePath;
AbsolutePath = absolutePath;
}
std::string Configuration::GetAbsolutePath()
{
return AbsolutePath;
return AbsolutePath;
}
bool Configuration::IsVerbose() const
{
return Verbose;
return Verbose;
}
void Configuration::SetVerbose(bool verbose)
{
this->Verbose = verbose;
this->Verbose = verbose;
}

52
Source/Database/Configuration.h
View File

@ -10,35 +10,35 @@
class Configuration
{
public:
Configuration();
virtual ~Configuration();
static void Initialize();
static void SetAbsolutePath(std::string absolutePath);
static std::string GetAbsolutePath();
static std::string ConvertToAbsolutePath(std::string prefix, std::string path);
Configuration();
virtual ~Configuration();
static void Initialize();
static void SetAbsolutePath(std::string absolutePath);
static std::string GetAbsolutePath();
static std::string ConvertToAbsolutePath(std::string prefix, std::string path);
// gets the global configuration
bool Import(std::string keyPrefix, std::string file);
// gets the global configuration
bool Import(std::string keyPrefix, std::string file);
bool GetProperty(std::string key, std::string &value);
bool GetProperty(std::string key, int &value);
bool GetProperty(std::string key, bool &value);
void GetChildKeyCrumbs(std::string parent, std::vector<std::string> &children);
void SetProperty(std::string key, std::string value);
bool PropertyExists(std::string key);
bool PropertyPrefixExists(std::string key);
bool GetPropertyAbsolutePath(std::string key, std::string &value);
bool IsVerbose() const;
void SetVerbose(bool verbose);
bool IsRequiredPropertiesSet();
bool GetProperty(std::string key, std::string &value);
bool GetProperty(std::string key, int &value);
bool GetProperty(std::string key, bool &value);
void GetChildKeyCrumbs(std::string parent, std::vector<std::string> &children);
void SetProperty(std::string key, std::string value);
bool PropertyExists(std::string key);
bool PropertyPrefixExists(std::string key);
bool GetPropertyAbsolutePath(std::string key, std::string &value);
bool IsVerbose() const;
void SetVerbose(bool verbose);
bool IsRequiredPropertiesSet();
private:
bool ParseLine(std::string keyPrefix, std::string line, int lineCount);
std::string TrimEnds(std::string str);
typedef std::map<std::string, std::string> PropertiesType;
typedef std::pair<std::string, std::string> PropertiesPair;
bool Verbose;
bool ParseLine(std::string keyPrefix, std::string line, int lineCount);
std::string TrimEnds(std::string str);
typedef std::map<std::string, std::string> PropertiesType;
typedef std::pair<std::string, std::string> PropertiesPair;
bool Verbose;
static std::string AbsolutePath;
PropertiesType Properties;
static std::string AbsolutePath;
PropertiesType Properties;
};

46
Source/Database/DB.cpp
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#include "DB.h"
#include "../Utility/Log.h"
@ -8,42 +8,42 @@
#include <fstream>
DB::DB(std::string dbFile)
: Path(dbFile)
, Handle(NULL)
: Path(dbFile)
, Handle(NULL)
{
}
DB::~DB()
{
DeInitialize();
DeInitialize();
}
bool DB::Initialize()
{
bool retVal = false;
bool retVal = false;
if(sqlite3_open(Path.c_str(), &Handle) != 0)
{
std::stringstream ss;
ss << "Cannot open database: \"" << Path << "\"" << sqlite3_errmsg(Handle);
Logger::Write(Logger::ZONE_ERROR, "Database", ss.str());
}
else
{
Logger::Write(Logger::ZONE_INFO, "Database", "Opened database \"" + Path + "\"");
retVal = true;
}
if(sqlite3_open(Path.c_str(), &Handle) != 0)
{
std::stringstream ss;
ss << "Cannot open database: \"" << Path << "\"" << sqlite3_errmsg(Handle);
Logger::Write(Logger::ZONE_ERROR, "Database", ss.str());
}
else
{
Logger::Write(Logger::ZONE_INFO, "Database", "Opened database \"" + Path + "\"");
retVal = true;
}
return retVal;
return retVal;
}
void DB::DeInitialize()
{
if(Handle != NULL)
{
sqlite3_close(Handle);
Handle = NULL;
}
if(Handle != NULL)
{
sqlite3_close(Handle);
Handle = NULL;
}
}

21
Source/Database/DB.h
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#pragma once
@ -8,14 +8,17 @@
class DB
{
public:
DB(std::string dbFile);
bool Initialize();
void DeInitialize();
virtual ~DB();
sqlite3 *GetHandle() { return Handle; }
DB(std::string dbFile);
bool Initialize();
void DeInitialize();
virtual ~DB();
sqlite3 *GetHandle()
{
return Handle;
}
private:
sqlite3 *Handle;
std::string Path;
sqlite3 *Handle;
std::string Path;
};

146
Source/Database/MamelistMetadata.cpp
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#include "MamelistMetadata.h"
#include "DB.h"
@ -13,7 +13,7 @@
MamelistMetadata::MamelistMetadata(DB *dbInstance)
: DBInstance(dbInstance)
: DBInstance(dbInstance)
{
}
@ -23,97 +23,97 @@ MamelistMetadata::~MamelistMetadata()
bool MamelistMetadata::Import(std::string filename, std::string collection)
{
bool retVal = true;
rapidxml::xml_document<> doc;
rapidxml::xml_node<> * rootNode;
char *error = NULL;
sqlite3 *handle = DBInstance->GetHandle();
bool retVal = true;
rapidxml::xml_document<> doc;
rapidxml::xml_node<> * rootNode;
char *error = NULL;
sqlite3 *handle = DBInstance->GetHandle();
std::ifstream f(filename.c_str());
std::ifstream f(filename.c_str());
if (!f.good())
{
Logger::Write(Logger::ZONE_ERROR, "Mamelist", "Could not find mamelist metadata file at \"" + filename + "\"");
if (!f.good())
{
Logger::Write(Logger::ZONE_ERROR, "Mamelist", "Could not find mamelist metadata file at \"" + filename + "\"");
retVal = false;
}
retVal = false;
}
f.close();
f.close();
if(retVal)
{
Logger::Write(Logger::ZONE_INFO, "Mamelist", "Importing mamelist file \"" + filename + "\"");
std::ifstream file(filename.c_str());
std::vector<char> buffer((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
if(retVal)
{
Logger::Write(Logger::ZONE_INFO, "Mamelist", "Importing mamelist file \"" + filename + "\"");
std::ifstream file(filename.c_str());
std::vector<char> buffer((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
buffer.push_back('\0');
buffer.push_back('\0');
doc.parse<0>(&buffer[0]);
doc.parse<0>(&buffer[0]);
rootNode = doc.first_node("mame");
rootNode = doc.first_node("mame");
sqlite3_exec(handle, "BEGIN IMMEDIATE TRANSACTION;", NULL, NULL, &error);
for (rapidxml::xml_node<> * game = rootNode->first_node("game"); game; game = game->next_sibling())
{
rapidxml::xml_attribute<> *nameNode = game->first_attribute("name");
rapidxml::xml_attribute<> *cloneOfXml = game->first_attribute("cloneof");
sqlite3_exec(handle, "BEGIN IMMEDIATE TRANSACTION;", NULL, NULL, &error);
for (rapidxml::xml_node<> * game = rootNode->first_node("game"); game; game = game->next_sibling())
{
rapidxml::xml_attribute<> *nameNode = game->first_attribute("name");
rapidxml::xml_attribute<> *cloneOfXml = game->first_attribute("cloneof");
if(nameNode != NULL)
{
std::string name = nameNode->value();
rapidxml::xml_node<> *descriptionNode = game->first_node("description");
rapidxml::xml_node<> *yearNode = game->first_node("year");
rapidxml::xml_node<> *manufacturerNode = game->first_node("manufacturer");
rapidxml::xml_node<> *inputNode = game->first_node("input");
if(nameNode != NULL)
{
std::string name = nameNode->value();
rapidxml::xml_node<> *descriptionNode = game->first_node("description");
rapidxml::xml_node<> *yearNode = game->first_node("year");
rapidxml::xml_node<> *manufacturerNode = game->first_node("manufacturer");
rapidxml::xml_node<> *inputNode = game->first_node("input");
std::string description = (descriptionNode == NULL) ? nameNode->value() : descriptionNode->value();
std::string year = (yearNode == NULL) ? "" : yearNode->value();
std::string manufacturer = (manufacturerNode == NULL) ? "" : manufacturerNode->value();
std::string cloneOf = (cloneOfXml == NULL) ? "" : cloneOfXml->value();
std::string players;
std::string buttons;
std::string description = (descriptionNode == NULL) ? nameNode->value() : descriptionNode->value();
std::string year = (yearNode == NULL) ? "" : yearNode->value();
std::string manufacturer = (manufacturerNode == NULL) ? "" : manufacturerNode->value();
std::string cloneOf = (cloneOfXml == NULL) ? "" : cloneOfXml->value();
std::string players;
std::string buttons;
if(inputNode != NULL)
{
rapidxml::xml_attribute<> *playersAttribute = inputNode->first_attribute("players");
rapidxml::xml_attribute<> *buttonsAttribute = inputNode->first_attribute("buttons");
if(inputNode != NULL)
{
rapidxml::xml_attribute<> *playersAttribute = inputNode->first_attribute("players");
rapidxml::xml_attribute<> *buttonsAttribute = inputNode->first_attribute("buttons");
if(playersAttribute)
{
players = playersAttribute->value();
}
if(playersAttribute)
{
players = playersAttribute->value();
}
if(buttonsAttribute)
{
buttons = buttonsAttribute->value();
}
if(buttonsAttribute)
{
buttons = buttonsAttribute->value();
}
}
}
sqlite3_stmt *stmt;
sqlite3_prepare_v2(handle,
"UPDATE OR REPLACE Meta SET title=?, year=?, manufacturer=?, players=?, buttons=?, cloneOf=? WHERE name=? AND collectionName=?;",
-1, &stmt, 0);
sqlite3_stmt *stmt;
sqlite3_prepare_v2(handle,
"UPDATE OR REPLACE Meta SET title=?, year=?, manufacturer=?, players=?, buttons=?, cloneOf=? WHERE name=? AND collectionName=?;",
-1, &stmt, 0);
sqlite3_bind_text(stmt, 1, description.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 2, year.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 3, manufacturer.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 4, players.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 5, buttons.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 6, cloneOf.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 7, name.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 8, collection.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 1, description.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 2, year.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 3, manufacturer.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 4, players.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 5, buttons.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 6, cloneOf.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 7, name.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 8, collection.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
}
}
sqlite3_exec(handle, "COMMIT TRANSACTION;", NULL, NULL, &error);
}
}
sqlite3_exec(handle, "COMMIT TRANSACTION;", NULL, NULL, &error);
}
}
return retVal;
return retVal;
}

12
Source/Database/MamelistMetadata.h
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#pragma once
@ -10,9 +10,9 @@ class DB;
class MamelistMetadata : Metadata
{
public:
MamelistMetadata(DB *dbInstance);
virtual ~MamelistMetadata();
bool Import(std::string file, std::string collectionName);
MamelistMetadata(DB *dbInstance);
virtual ~MamelistMetadata();
bool Import(std::string file, std::string collectionName);
private:
DB *DBInstance;
DB *DBInstance;
};

4
Source/Database/Metadata.h
View File

@ -5,6 +5,6 @@
class Metadata
{
public:
virtual ~Metadata() {}
virtual bool Import(std::string file, std::string collectionName) = 0;
virtual ~Metadata() {}
virtual bool Import(std::string file, std::string collectionName) = 0;
};

424
Source/Execute/Launcher.cpp
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#include "Launcher.h"
#include "../Collection/Item.h"
@ -18,309 +18,309 @@
#endif
Launcher::Launcher(RetroFE *p)
: Config(p->GetConfiguration())
, RetroFEInst(p)
: Config(p->GetConfiguration())
, RetroFEInst(p)
{
}
bool Launcher::Run(std::string collection, Item *collectionItem)
{
std::string launcherName = collectionItem->GetLauncher();
std::string executablePath;
std::string selectedItemsDirectory;
std::string selectedItemsPath;
std::string currentDirectory;
std::string extensions;
std::string matchedExtension;
std::string args;
std::string launcherName = collectionItem->GetLauncher();
std::string executablePath;
std::string selectedItemsDirectory;
std::string selectedItemsPath;
std::string currentDirectory;
std::string extensions;
std::string matchedExtension;
std::string args;
if(!GetLauncherExecutable(executablePath, currentDirectory, launcherName))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "Failed to find launcher executable (launcher: " + launcherName + " executable: " + executablePath + ")");
return false;
}
if(!GetExtensions(extensions, collection))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "No file extensions configured for collection \"" + collection + "\"");
return false;
}
if(!GetCollectionDirectory(selectedItemsDirectory, collection))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "Could not find files in directory \"" + selectedItemsDirectory + "\" for collection \"" + collection + "\"");
return false;
}
if(!GetLauncherArgs(args, launcherName))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "No launcher arguments specified for launcher " + launcherName);
return false;
}
if(!FindFile(selectedItemsPath, matchedExtension, selectedItemsDirectory, collectionItem->GetName(), extensions))
{
// FindFile() prints out diagnostic messages for us, no need to print anything here
return false;
}
args = ReplaceVariables(args,
selectedItemsPath,
collectionItem->GetName(),
collectionItem->GetFileName(),
selectedItemsDirectory,
collection);
if(!GetLauncherExecutable(executablePath, currentDirectory, launcherName))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "Failed to find launcher executable (launcher: " + launcherName + " executable: " + executablePath + ")");
return false;
}
if(!GetExtensions(extensions, collection))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "No file extensions configured for collection \"" + collection + "\"");
return false;
}
if(!GetCollectionDirectory(selectedItemsDirectory, collection))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "Could not find files in directory \"" + selectedItemsDirectory + "\" for collection \"" + collection + "\"");
return false;
}
if(!GetLauncherArgs(args, launcherName))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "No launcher arguments specified for launcher " + launcherName);
return false;
}
if(!FindFile(selectedItemsPath, matchedExtension, selectedItemsDirectory, collectionItem->GetName(), extensions))
{
// FindFile() prints out diagnostic messages for us, no need to print anything here
return false;
}
args = ReplaceVariables(args,
selectedItemsPath,
collectionItem->GetName(),
collectionItem->GetFileName(),
selectedItemsDirectory,
collection);
executablePath = ReplaceVariables(executablePath,
selectedItemsPath,
collectionItem->GetName(),
collectionItem->GetFileName(),
selectedItemsDirectory,
collection);
executablePath = ReplaceVariables(executablePath,
selectedItemsPath,
collectionItem->GetName(),
collectionItem->GetFileName(),
selectedItemsDirectory,
collection);
currentDirectory = ReplaceVariables(currentDirectory,
selectedItemsPath,
collectionItem->GetName(),
collectionItem->GetFileName(),
selectedItemsDirectory,
collection);
currentDirectory = ReplaceVariables(currentDirectory,
selectedItemsPath,
collectionItem->GetName(),
collectionItem->GetFileName(),
selectedItemsDirectory,
collection);
if(!ExecuteCommand(executablePath, args, currentDirectory))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "Failed to launch.");
return false;
}
if(!ExecuteCommand(executablePath, args, currentDirectory))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "Failed to launch.");
return false;
}
return true;
return true;
}
std::string Launcher::ReplaceVariables(std::string str,
std::string itemFilePath,
std::string itemName,
std::string itemFilename,
std::string itemDirectory,
std::string itemCollectionName)
std::string itemFilePath,
std::string itemName,
std::string itemFilename,
std::string itemDirectory,
std::string itemCollectionName)
{
str = Utils::Replace(str, "%ITEM_FILEPATH%", itemFilePath);
str = Utils::Replace(str, "%ITEM_NAME%", itemName);
str = Utils::Replace(str, "%ITEM_FILENAME%", itemFilename);
str = Utils::Replace(str, "%ITEM_DIRECTORY%", itemDirectory);
str = Utils::Replace(str, "%ITEM_COLLECTION_NAME%", itemCollectionName);
str = Utils::Replace(str, "%RETROFE_PATH%", Configuration::GetAbsolutePath());
str = Utils::Replace(str, "%ITEM_FILEPATH%", itemFilePath);
str = Utils::Replace(str, "%ITEM_NAME%", itemName);
str = Utils::Replace(str, "%ITEM_FILENAME%", itemFilename);
str = Utils::Replace(str, "%ITEM_DIRECTORY%", itemDirectory);
str = Utils::Replace(str, "%ITEM_COLLECTION_NAME%", itemCollectionName);
str = Utils::Replace(str, "%RETROFE_PATH%", Configuration::GetAbsolutePath());
#ifdef WIN32
str = Utils::Replace(str, "%RETROFE_EXEC_PATH%", Configuration::GetAbsolutePath() + "/RetroFE.exe");
str = Utils::Replace(str, "%RETROFE_EXEC_PATH%", Configuration::GetAbsolutePath() + "/RetroFE.exe");
#else
str = Utils::Replace(str, "%RETROFE_EXEC_PATH%", Configuration::GetAbsolutePath() + "/RetroFE");
str = Utils::Replace(str, "%RETROFE_EXEC_PATH%", Configuration::GetAbsolutePath() + "/RetroFE");
#endif
return str;
return str;
}
bool Launcher::ExecuteCommand(std::string executable, std::string args, std::string currentDirectory)
{
bool retVal = false;
std::string executionString = "\"" + executable + "\" " + args;
bool retVal = false;
std::string executionString = "\"" + executable + "\" " + args;
Logger::Write(Logger::ZONE_INFO, "Launcher", "Attempting to launch: " + executionString);
Logger::Write(Logger::ZONE_INFO, "Launcher", " from within folder: " + currentDirectory);
Logger::Write(Logger::ZONE_INFO, "Launcher", "Attempting to launch: " + executionString);
Logger::Write(Logger::ZONE_INFO, "Launcher", " from within folder: " + currentDirectory);
//todo: use delegation instead of depending on knowing the RetroFE class (tie to an interface)
RetroFEInst->LaunchEnter();
//todo: use delegation instead of depending on knowing the RetroFE class (tie to an interface)
RetroFEInst->LaunchEnter();
#ifdef WIN32
STARTUPINFO startupInfo;
PROCESS_INFORMATION processInfo;
char applicationName[256];
char currDir[256];
memset(&applicationName, 0, sizeof(applicationName));
memset(&startupInfo, 0, sizeof(startupInfo));
memset(&processInfo, 0, sizeof(processInfo));
strncpy(applicationName, executionString.c_str(), sizeof(applicationName));
strncpy(currDir, currentDirectory.c_str(), sizeof(currDir));
startupInfo.dwFlags = STARTF_USESTDHANDLES;
startupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
startupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
startupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
startupInfo.wShowWindow = SW_SHOWDEFAULT;
STARTUPINFO startupInfo;
PROCESS_INFORMATION processInfo;
char applicationName[256];
char currDir[256];
memset(&applicationName, 0, sizeof(applicationName));
memset(&startupInfo, 0, sizeof(startupInfo));
memset(&processInfo, 0, sizeof(processInfo));
strncpy(applicationName, executionString.c_str(), sizeof(applicationName));
strncpy(currDir, currentDirectory.c_str(), sizeof(currDir));
startupInfo.dwFlags = STARTF_USESTDHANDLES;
startupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
startupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
startupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
startupInfo.wShowWindow = SW_SHOWDEFAULT;
if(!CreateProcess(NULL, applicationName, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &startupInfo, &processInfo))
if(!CreateProcess(NULL, applicationName, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &startupInfo, &processInfo))
#else
if(system(executionString.c_str()) != 0)
if(system(executionString.c_str()) != 0)
#endif
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "Failed to run: " + executable);
}
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "Failed to run: " + executable);
}
else
{
else
{
#ifdef WIN32
while(WAIT_OBJECT_0 != MsgWaitForMultipleObjects(1, &processInfo.hProcess, FALSE, INFINITE, QS_ALLINPUT))
{
MSG msg;
while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
DispatchMessage(&msg);
}
}
while(WAIT_OBJECT_0 != MsgWaitForMultipleObjects(1, &processInfo.hProcess, FALSE, INFINITE, QS_ALLINPUT))
{
MSG msg;
while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
DispatchMessage(&msg);
}
}
// result = GetExitCodeProcess(processInfo.hProcess, &exitCode);
CloseHandle(processInfo.hProcess);
// result = GetExitCodeProcess(processInfo.hProcess, &exitCode);
CloseHandle(processInfo.hProcess);
#endif
retVal = true;
}
retVal = true;
}
Logger::Write(Logger::ZONE_INFO, "Launcher", "Completed");
RetroFEInst->LaunchExit();
Logger::Write(Logger::ZONE_INFO, "Launcher", "Completed");
RetroFEInst->LaunchExit();
return retVal;
return retVal;
}
bool Launcher::GetLauncherName(std::string &launcherName, std::string collection)
{
std::string launcherKey = "collections." + collection + ".launcher";
std::string launcherKey = "collections." + collection + ".launcher";
// find the launcher for the particular item
if(!Config->GetProperty(launcherKey, launcherName))
{
std::stringstream ss;
// find the launcher for the particular item
if(!Config->GetProperty(launcherKey, launcherName))
{
std::stringstream ss;
ss << "Launch failed. Could not find a configured launcher for collection \""
<< collection
<< "\" (could not find a property for \""
<< launcherKey
<< "\")";
ss << "Launch failed. Could not find a configured launcher for collection \""
<< collection
<< "\" (could not find a property for \""
<< launcherKey
<< "\")";
Logger::Write(Logger::ZONE_ERROR, "Launcher", ss.str());
Logger::Write(Logger::ZONE_ERROR, "Launcher", ss.str());
return false;
}
return false;
}
std::stringstream ss;
ss << "collections."
<< collection
<< " is configured to use launchers."
<< launcherName
<< "\"";
std::stringstream ss;
ss << "collections."
<< collection
<< " is configured to use launchers."
<< launcherName
<< "\"";
Logger::Write(Logger::ZONE_DEBUG, "Launcher", ss.str());
Logger::Write(Logger::ZONE_DEBUG, "Launcher", ss.str());
return true;
return true;
}
bool Launcher::GetLauncherExecutable(std::string &executable, std::string &currentDirectory, std::string launcherName)
{
std::string executableKey = "launchers." + launcherName + ".executable";
std::string executableKey = "launchers." + launcherName + ".executable";
if(!Config->GetProperty(executableKey, executable))
{
return false;
}
if(!Config->GetProperty(executableKey, executable))
{
return false;
}
std::string currentDirectoryKey = "launchers." + launcherName + ".currentDirectory";
currentDirectory = Utils::GetDirectory(executable);
std::string currentDirectoryKey = "launchers." + launcherName + ".currentDirectory";
currentDirectory = Utils::GetDirectory(executable);
Config->GetProperty(currentDirectoryKey, currentDirectory);
Config->GetProperty(currentDirectoryKey, currentDirectory);
return true;
return true;
}
bool Launcher::GetLauncherArgs(std::string &args, std::string launcherName)
{
std::string argsKey = "launchers." + launcherName + ".arguments";
std::string argsKey = "launchers." + launcherName + ".arguments";
if(!Config->GetProperty(argsKey, args))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "No arguments specified for: " + argsKey);
if(!Config->GetProperty(argsKey, args))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "No arguments specified for: " + argsKey);
return false;
}
return true;
return false;
}
return true;
}
bool Launcher::GetExtensions(std::string &extensions, std::string collection)
{
std::string extensionsKey = "collections." + collection + ".list.extensions";
std::string extensionsKey = "collections." + collection + ".list.extensions";
if(!Config->GetProperty(extensionsKey, extensions))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "No extensions specified for: " + extensionsKey);
return false;
}
if(!Config->GetProperty(extensionsKey, extensions))
{
Logger::Write(Logger::ZONE_ERROR, "Launcher", "No extensions specified for: " + extensionsKey);
return false;
}
extensions = Utils::Replace(extensions, " ", "");
extensions = Utils::Replace(extensions, ".", "");
extensions = Utils::Replace(extensions, " ", "");
extensions = Utils::Replace(extensions, ".", "");
return true;
return true;
}
bool Launcher::GetCollectionDirectory(std::string &directory, std::string collection)
{
std::string itemsPathKey = "collections." + collection + ".list.path";
std::string itemsPathValue;
std::string itemsPathKey = "collections." + collection + ".list.path";
std::string itemsPathValue;
// find the items path folder (i.e. ROM path)
if(!Config->GetPropertyAbsolutePath(itemsPathKey, itemsPathValue))
{
directory = "";
}
else
{
directory += itemsPathValue + "/";
}
// find the items path folder (i.e. ROM path)
if(!Config->GetPropertyAbsolutePath(itemsPathKey, itemsPathValue))
{
directory = "";
}
else
{
directory += itemsPathValue + "/";
}
return true;
return true;
}
bool Launcher::FindFile(std::string &foundFilePath, std::string &foundFilename, std::string directory, std::string filenameWithoutExtension, std::string extensions)
{
std::string extension;
bool fileFound = false;
std::stringstream ss;
ss << extensions;
std::string extension;
bool fileFound = false;
std::stringstream ss;
ss << extensions;
while(!fileFound && std::getline(ss, extension, ',') )
{
std::string selectedItemsPath = directory + filenameWithoutExtension + "." + extension;
std::ifstream f(selectedItemsPath.c_str());
while(!fileFound && std::getline(ss, extension, ',') )
{
std::string selectedItemsPath = directory + filenameWithoutExtension + "." + extension;
std::ifstream f(selectedItemsPath.c_str());
if (f.good())
{
std::stringstream ss;
if (f.good())
{
std::stringstream ss;
ss <<"Checking to see if \""
<< selectedItemsPath << "\" exists [Yes]";
ss <<"Checking to see if \""
<< selectedItemsPath << "\" exists [Yes]";
fileFound = true;
fileFound = true;
Logger::Write(Logger::ZONE_INFO, "Launcher", ss.str());
Logger::Write(Logger::ZONE_INFO, "Launcher", ss.str());
foundFilePath = selectedItemsPath;
foundFilename = extension;
}
else
{
std::stringstream ss;
foundFilePath = selectedItemsPath;
foundFilename = extension;
}
else
{
std::stringstream ss;
ss << "Checking to see if \""
<< selectedItemsPath << "\" exists [No]";
ss << "Checking to see if \""
<< selectedItemsPath << "\" exists [No]";
Logger::Write(Logger::ZONE_WARNING, "Launcher", ss.str());
}
Logger::Write(Logger::ZONE_WARNING, "Launcher", ss.str());
}
f.close();
}
f.close();
}
// get the launchers executable
// get the launchers executable
if(!fileFound)
{
std::stringstream ss;
ss <<"Could not find any files with the name \""
<< filenameWithoutExtension << "\" in folder \""
<< directory;
if(!fileFound)
{
std::stringstream ss;
ss <<"Could not find any files with the name \""
<< filenameWithoutExtension << "\" in folder \""
<< directory;
Logger::Write(Logger::ZONE_ERROR, "Launcher", ss.str());
Logger::Write(Logger::ZONE_ERROR, "Launcher", ss.str());
}
}
return fileFound;
return fileFound;
}

46
Source/Execute/Launcher.h
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#pragma once
@ -12,29 +12,29 @@ class RetroFE;
class Launcher
{
public:
Launcher(RetroFE *p);
bool Run(std::string collection, Item *collectionItem);
Launcher(RetroFE *p);
bool Run(std::string collection, Item *collectionItem);
private:
std::string ReplaceString(
std::string subject,
const std::string &search,
const std::string &replace);
std::string ReplaceString(
std::string subject,
const std::string &search,
const std::string &replace);
bool GetLauncherName(std::string &launcherName, std::string collection);
bool GetLauncherExecutable(std::string &executable, std::string &currentDirectory, std::string launcherName);
bool GetLauncherArgs(std::string &args, std::string launcherName);
bool GetExtensions(std::string &extensions, std::string launcherName);
bool GetCollectionDirectory(std::string &directory, std::string collection);
bool ExecuteCommand(std::string executable, std::string arguments, std::string currentDirectory);
bool FindFile(std::string &foundFilePath, std::string &foundFilename, std::string directory, std::string filenameWithoutExtension, std::string extensions);
std::string ReplaceVariables(std::string str,
std::string itemFilePath,
std::string itemName,
std::string itemFilename,
std::string itemDirectory,
std::string itemCollectionName);
bool GetLauncherName(std::string &launcherName, std::string collection);
bool GetLauncherExecutable(std::string &executable, std::string &currentDirectory, std::string launcherName);
bool GetLauncherArgs(std::string &args, std::string launcherName);
bool GetExtensions(std::string &extensions, std::string launcherName);
bool GetCollectionDirectory(std::string &directory, std::string collection);
bool ExecuteCommand(std::string executable, std::string arguments, std::string currentDirectory);
bool FindFile(std::string &foundFilePath, std::string &foundFilename, std::string directory, std::string filenameWithoutExtension, std::string extensions);
std::string ReplaceVariables(std::string str,
std::string itemFilePath,
std::string itemName,
std::string itemFilename,
std::string itemDirectory,
std::string itemCollectionName);
Configuration *Config;
RetroFE *RetroFEInst;
Configuration *Config;
RetroFE *RetroFEInst;
};

410
Source/Graphics/Animate/Tween.cpp
View File

@ -11,360 +11,360 @@ std::map<std::string, TweenAlgorithm> Tween::TweenTypeMap;
std::map<std::string, TweenProperty> Tween::TweenPropertyMap;
Tween::Tween(TweenProperty property, TweenAlgorithm type, double start, double end, double duration)
: Property(property)
, Type(type)
, Start(start)
, End(end)
, Duration(duration)
: Property(property)
, Type(type)
, Start(start)
, End(end)
, Duration(duration)
{
}
TweenProperty Tween::GetProperty() const
{
return Property;
return Property;
}
bool Tween::GetTweenProperty(std::string name, TweenProperty &property)
{
bool retVal = false;
bool retVal = false;
if(TweenPropertyMap.size() == 0)
{
TweenPropertyMap["x"] = TWEEN_PROPERTY_X;
TweenPropertyMap["y"] = TWEEN_PROPERTY_Y;
TweenPropertyMap["angle"] = TWEEN_PROPERTY_ANGLE;
TweenPropertyMap["transparency"] = TWEEN_PROPERTY_TRANSPARENCY;
TweenPropertyMap["width"] = TWEEN_PROPERTY_WIDTH;
TweenPropertyMap["height"] = TWEEN_PROPERTY_HEIGHT;
TweenPropertyMap["xorigin"] = TWEEN_PROPERTY_X_ORIGIN;
TweenPropertyMap["yorigin"] = TWEEN_PROPERTY_Y_ORIGIN;
TweenPropertyMap["xoffset"] = TWEEN_PROPERTY_X_OFFSET;
TweenPropertyMap["yoffset"] = TWEEN_PROPERTY_Y_OFFSET;
TweenPropertyMap["fontSize"] = TWEEN_PROPERTY_FONT_SIZE;
}
if(TweenPropertyMap.size() == 0)
{
TweenPropertyMap["x"] = TWEEN_PROPERTY_X;
TweenPropertyMap["y"] = TWEEN_PROPERTY_Y;
TweenPropertyMap["angle"] = TWEEN_PROPERTY_ANGLE;
TweenPropertyMap["transparency"] = TWEEN_PROPERTY_TRANSPARENCY;
TweenPropertyMap["width"] = TWEEN_PROPERTY_WIDTH;
TweenPropertyMap["height"] = TWEEN_PROPERTY_HEIGHT;
TweenPropertyMap["xorigin"] = TWEEN_PROPERTY_X_ORIGIN;
TweenPropertyMap["yorigin"] = TWEEN_PROPERTY_Y_ORIGIN;
TweenPropertyMap["xoffset"] = TWEEN_PROPERTY_X_OFFSET;
TweenPropertyMap["yoffset"] = TWEEN_PROPERTY_Y_OFFSET;
TweenPropertyMap["fontSize"] = TWEEN_PROPERTY_FONT_SIZE;
}
std::transform(name.begin(), name.end(), name.begin(), ::tolower);
std::transform(name.begin(), name.end(), name.begin(), ::tolower);
if(TweenPropertyMap.find(name) != TweenPropertyMap.end())
{
property = TweenPropertyMap[name];
retVal = true;
}
if(TweenPropertyMap.find(name) != TweenPropertyMap.end())
{
property = TweenPropertyMap[name];
retVal = true;
}
return retVal;
return retVal;
}
TweenAlgorithm Tween::GetTweenType(std::string name)
{
if(TweenTypeMap.size() == 0)
{
TweenTypeMap["easeinquadratic"] = EASE_IN_QUADRATIC;
TweenTypeMap["easeoutquadratic"] = EASE_OUT_QUADRATIC;
TweenTypeMap["easeinoutquadratic"] = EASE_INOUT_QUADRATIC;
TweenTypeMap["easeincubic"] = EASE_IN_CUBIC;
TweenTypeMap["easeoutcubic"] = EASE_OUT_CUBIC;
TweenTypeMap["easeinoutcubic"] = EASE_INOUT_CUBIC;
TweenTypeMap["easeinquartic"] = EASE_IN_QUARTIC;
TweenTypeMap["easeoutquartic"] = EASE_OUT_QUARTIC;
TweenTypeMap["easeinoutquartic"] = EASE_INOUT_QUARTIC;
TweenTypeMap["easeinquintic"] = EASE_IN_QUINTIC;
TweenTypeMap["easeoutquintic"] = EASE_OUT_QUINTIC;
TweenTypeMap["easeinoutquintic"] = EASE_INOUT_QUINTIC;
TweenTypeMap["easeinsine"] = EASE_IN_SINE;
TweenTypeMap["easeoutsine"] = EASE_OUT_SINE;
TweenTypeMap["easeinoutsine"] = EASE_INOUT_SINE;
TweenTypeMap["easeinexponential"] = EASE_IN_EXPONENTIAL;
TweenTypeMap["easeoutexponential"] = EASE_OUT_EXPONENTIAL;
TweenTypeMap["easeinoutexponential"] = EASE_INOUT_EXPONENTIAL;
TweenTypeMap["easeincircular"] = EASE_IN_CIRCULAR;
TweenTypeMap["easeoutcircular"] = EASE_OUT_CIRCULAR;
TweenTypeMap["easeinoutcircular"] = EASE_INOUT_CIRCULAR;
TweenTypeMap["linear"] = LINEAR;
}
if(TweenTypeMap.size() == 0)
{
TweenTypeMap["easeinquadratic"] = EASE_IN_QUADRATIC;
TweenTypeMap["easeoutquadratic"] = EASE_OUT_QUADRATIC;
TweenTypeMap["easeinoutquadratic"] = EASE_INOUT_QUADRATIC;
TweenTypeMap["easeincubic"] = EASE_IN_CUBIC;
TweenTypeMap["easeoutcubic"] = EASE_OUT_CUBIC;
TweenTypeMap["easeinoutcubic"] = EASE_INOUT_CUBIC;
TweenTypeMap["easeinquartic"] = EASE_IN_QUARTIC;
TweenTypeMap["easeoutquartic"] = EASE_OUT_QUARTIC;
TweenTypeMap["easeinoutquartic"] = EASE_INOUT_QUARTIC;
TweenTypeMap["easeinquintic"] = EASE_IN_QUINTIC;
TweenTypeMap["easeoutquintic"] = EASE_OUT_QUINTIC;
TweenTypeMap["easeinoutquintic"] = EASE_INOUT_QUINTIC;
TweenTypeMap["easeinsine"] = EASE_IN_SINE;
TweenTypeMap["easeoutsine"] = EASE_OUT_SINE;
TweenTypeMap["easeinoutsine"] = EASE_INOUT_SINE;
TweenTypeMap["easeinexponential"] = EASE_IN_EXPONENTIAL;
TweenTypeMap["easeoutexponential"] = EASE_OUT_EXPONENTIAL;
TweenTypeMap["easeinoutexponential"] = EASE_INOUT_EXPONENTIAL;
TweenTypeMap["easeincircular"] = EASE_IN_CIRCULAR;
TweenTypeMap["easeoutcircular"] = EASE_OUT_CIRCULAR;
TweenTypeMap["easeinoutcircular"] = EASE_INOUT_CIRCULAR;
TweenTypeMap["linear"] = LINEAR;
}
std::transform(name.begin(), name.end(), name.begin(), ::tolower);
std::transform(name.begin(), name.end(), name.begin(), ::tolower);
if(TweenTypeMap.find(name) != TweenTypeMap.end())
{
return TweenTypeMap[name];
}
else
{
return TweenTypeMap["linear"];
}
if(TweenTypeMap.find(name) != TweenTypeMap.end())
{
return TweenTypeMap[name];
}
else
{
return TweenTypeMap["linear"];
}
}
float Tween::Animate(double elapsedTime)
{
return AnimateSingle(Type, Start, End, Duration, elapsedTime);
return AnimateSingle(Type, Start, End, Duration, elapsedTime);
}
//todo: SDL likes floats, consider having casting being performed elsewhere
float Tween::AnimateSingle(TweenAlgorithm type, double start, double end, double duration, double elapsedTime)
{
double a = start;
double b = end - start;
double result = 0;
double a = start;
double b = end - start;
double result = 0;
switch(type)
{
case EASE_IN_QUADRATIC:
result = EaseInQuadratic(elapsedTime, duration, a, b);
break;
switch(type)
{
case EASE_IN_QUADRATIC:
result = EaseInQuadratic(elapsedTime, duration, a, b);
break;
case EASE_OUT_QUADRATIC:
result = EaseOutQuadratic(elapsedTime, duration, a, b);
break;
case EASE_OUT_QUADRATIC:
result = EaseOutQuadratic(elapsedTime, duration, a, b);
break;
case EASE_INOUT_QUADRATIC:
result = EaseInOutQuadratic(elapsedTime, duration, a, b);
break;
case EASE_INOUT_QUADRATIC:
result = EaseInOutQuadratic(elapsedTime, duration, a, b);
break;
case EASE_IN_CUBIC:
result = EaseInCubic(elapsedTime, duration, a, b);
break;
case EASE_IN_CUBIC:
result = EaseInCubic(elapsedTime, duration, a, b);
break;
case EASE_OUT_CUBIC:
result = EaseOutCubic(elapsedTime, duration, a, b);
break;
case EASE_OUT_CUBIC:
result = EaseOutCubic(elapsedTime, duration, a, b);
break;
case EASE_INOUT_CUBIC:
result = EaseInOutCubic(elapsedTime, duration, a, b);
break;
case EASE_INOUT_CUBIC:
result = EaseInOutCubic(elapsedTime, duration, a, b);
break;
case EASE_IN_QUARTIC:
result = EaseInQuartic(elapsedTime, duration, a, b);
break;
case EASE_IN_QUARTIC:
result = EaseInQuartic(elapsedTime, duration, a, b);
break;
case EASE_OUT_QUARTIC:
result = EaseOutQuartic(elapsedTime, duration, a, b);
break;
case EASE_OUT_QUARTIC:
result = EaseOutQuartic(elapsedTime, duration, a, b);
break;
case EASE_INOUT_QUARTIC:
result = EaseInOutQuartic(elapsedTime, duration, a, b);
break;
case EASE_INOUT_QUARTIC:
result = EaseInOutQuartic(elapsedTime, duration, a, b);
break;
case EASE_IN_QUINTIC:
result = EaseInQuintic(elapsedTime, duration, a, b);
break;
case EASE_IN_QUINTIC:
result = EaseInQuintic(elapsedTime, duration, a, b);
break;
case EASE_OUT_QUINTIC:
result = EaseOutQuintic(elapsedTime, duration, a, b);
break;
case EASE_OUT_QUINTIC:
result = EaseOutQuintic(elapsedTime, duration, a, b);
break;
case EASE_INOUT_QUINTIC:
result = EaseInOutQuintic(elapsedTime, duration, a, b);
break;
case EASE_INOUT_QUINTIC:
result = EaseInOutQuintic(elapsedTime, duration, a, b);
break;
case EASE_IN_SINE:
result = EaseInSine(elapsedTime, duration, a, b);
break;
case EASE_IN_SINE:
result = EaseInSine(elapsedTime, duration, a, b);
break;
case EASE_OUT_SINE:
result = EaseOutSine(elapsedTime, duration, a, b);
break;
case EASE_OUT_SINE:
result = EaseOutSine(elapsedTime, duration, a, b);
break;
case EASE_INOUT_SINE:
result = EaseInOutSine(elapsedTime, duration, a, b);
break;
case EASE_INOUT_SINE:
result = EaseInOutSine(elapsedTime, duration, a, b);
break;
case EASE_IN_EXPONENTIAL:
result = EaseInExponential(elapsedTime, duration, a, b);
break;
case EASE_IN_EXPONENTIAL:
result = EaseInExponential(elapsedTime, duration, a, b);
break;
case EASE_OUT_EXPONENTIAL:
result = EaseOutExponential(elapsedTime, duration, a, b);
break;
case EASE_OUT_EXPONENTIAL:
result = EaseOutExponential(elapsedTime, duration, a, b);
break;
case EASE_INOUT_EXPONENTIAL:
result = EaseInOutExponential(elapsedTime, duration, a, b);
break;
case EASE_INOUT_EXPONENTIAL:
result = EaseInOutExponential(elapsedTime, duration, a, b);
break;
case EASE_IN_CIRCULAR:
result = EaseInCircular(elapsedTime, duration, a, b);
break;
case EASE_IN_CIRCULAR:
result = EaseInCircular(elapsedTime, duration, a, b);
break;
case EASE_OUT_CIRCULAR:
result = EaseOutCircular(elapsedTime, duration, a, b);
break;
case EASE_OUT_CIRCULAR:
result = EaseOutCircular(elapsedTime, duration, a, b);
break;
case EASE_INOUT_CIRCULAR:
result = EaseInOutCircular(elapsedTime, duration, a, b);
break;
case EASE_INOUT_CIRCULAR:
result = EaseInOutCircular(elapsedTime, duration, a, b);
break;
case LINEAR:
default:
result = Linear(elapsedTime, duration, a, b);
break;
}
case LINEAR:
default:
result = Linear(elapsedTime, duration, a, b);
break;
}
return static_cast<float>(result);
return static_cast<float>(result);
}
double Tween::Linear(double t, double d, double b, double c)
{
if(d == 0) return b;
return c*t/d + b;
if(d == 0) return b;
return c*t/d + b;
};
double Tween::EaseInQuadratic(double t, double d, double b, double c)
{
if(d == 0) return b;
t /= d;
return c*t*t + b;
if(d == 0) return b;
t /= d;
return c*t*t + b;
};
double Tween::EaseOutQuadratic(double t, double d, double b, double c)
{
if(d == 0) return b;
t /= d;
return -c * t*(t-2) + b;
if(d == 0) return b;
t /= d;
return -c * t*(t-2) + b;
};
double Tween::EaseInOutQuadratic(double t, double d, double b, double c)
{
if(d == 0) return b;
t /= d/2;
if (t < 1) return c/2*t*t + b;
t--;
return -c/2 * (t*(t-2) - 1) + b;
if(d == 0) return b;
t /= d/2;
if (t < 1) return c/2*t*t + b;
t--;
return -c/2 * (t*(t-2) - 1) + b;
};
double Tween::EaseInCubic(double t, double d, double b, double c)
{
if(d == 0) return b;
t /= d;
return c*t*t*t + b;
if(d == 0) return b;
t /= d;
return c*t*t*t + b;
};
double Tween::EaseOutCubic(double t, double d, double b, double c)
{
if(d == 0) return b;
t /= d;
t--;
return c*(t*t*t + 1) + b;
if(d == 0) return b;
t /= d;
t--;
return c*(t*t*t + 1) + b;
};
double Tween::EaseInOutCubic(double t, double d, double b, double c)
{
if(d == 0) return b;
t /= d/2;
if (t < 1) return c/2*t*t*t + b;
t -= 2;
return c/2*(t*t*t + 2) + b;
if(d == 0) return b;
t /= d/2;
if (t < 1) return c/2*t*t*t + b;
t -= 2;
return c/2*(t*t*t + 2) + b;
};
double Tween::EaseInQuartic(double t, double d, double b, double c)
{
if(d == 0) return b;
t /= d;
return c*t*t*t*t + b;
if(d == 0) return b;
t /= d;
return c*t*t*t*t + b;
};
double Tween::EaseOutQuartic(double t, double d, double b, double c)
{
if(d == 0) return b;
t /= d;
t--;
return -c * (t*t*t*t - 1) + b;
if(d == 0) return b;
t /= d;
t--;
return -c * (t*t*t*t - 1) + b;
};
double Tween::EaseInOutQuartic(double t, double d, double b, double c)
{
if(d == 0) return b;
t /= d/2;
if (t < 1) return c/2*t*t*t*t + b;
t -= 2;
return -c/2 * (t*t*t*t - 2) + b;
if(d == 0) return b;
t /= d/2;
if (t < 1) return c/2*t*t*t*t + b;
t -= 2;
return -c/2 * (t*t*t*t - 2) + b;
};
double Tween::EaseInQuintic(double t, double d, double b, double c)
{
if(d == 0) return b;
t /= d;
return c*t*t*t*t*t + b;
if(d == 0) return b;
t /= d;
return c*t*t*t*t*t + b;
};
double Tween::EaseOutQuintic(double t, double d, double b, double c)
{
if(d == 0) return b;
t /= d;
t--;
return c*(t*t*t*t*t + 1) + b;
if(d == 0) return b;
t /= d;
t--;
return c*(t*t*t*t*t + 1) + b;
};
double Tween::EaseInOutQuintic(double t, double d, double b, double c)
{
if(d == 0) return b;
t /= d/2;
if (t < 1) return c/2*t*t*t*t*t + b;
t -= 2;
return c/2*(t*t*t*t*t + 2) + b;
if(d == 0) return b;
t /= d/2;
if (t < 1) return c/2*t*t*t*t*t + b;
t -= 2;
return c/2*(t*t*t*t*t + 2) + b;
};
double Tween::EaseInSine(double t, double d, double b, double c)
{
return -c * cos(t/d * (M_PI/2)) + c + b;
return -c * cos(t/d * (M_PI/2)) + c + b;
};
double Tween::EaseOutSine(double t, double d, double b, double c)
{
return c * sin(t/d * (M_PI/2)) + b;
return c * sin(t/d * (M_PI/2)) + b;
};
double Tween::EaseInOutSine(double t, double d, double b, double c)
{
return -c/2 * (cos( M_PI*t/d) - 1) + b;
return -c/2 * (cos( M_PI*t/d) - 1) + b;
};
double Tween::EaseInExponential(double t, double d, double b, double c)
{
return c * pow( 2, 10 * (t/d - 1) ) + b;
return c * pow( 2, 10 * (t/d - 1) ) + b;
};
double Tween::EaseOutExponential(double t, double d, double b, double c)
{
return c * ( - pow( 2, -10 * t/d ) + 1 ) + b;
return c * ( - pow( 2, -10 * t/d ) + 1 ) + b;
};
double Tween::EaseInOutExponential(double t, double d, double b, double c)
{
t /= d/2;
if (t < 1) return c/2 * pow( 2, 10 * (t - 1) ) + b;
t--;
return c/2 * ( -1* pow( 2, -10 * t) + 2 ) + b;
t /= d/2;
if (t < 1) return c/2 * pow( 2, 10 * (t - 1) ) + b;
t--;
return c/2 * ( -1* pow( 2, -10 * t) + 2 ) + b;
};
double Tween::EaseInCircular(double t, double d, double b, double c)
{
t /= d;
return -c * (sqrt(1 - t*t) - 1) + b;
t /= d;
return -c * (sqrt(1 - t*t) - 1) + b;
};
double Tween::EaseOutCircular(double t, double d, double b, double c)
{
t /= d;
t--;
return c * sqrt(1 - t*t) + b;
t /= d;
t--;
return c * sqrt(1 - t*t) + b;
};
double Tween::EaseInOutCircular(double t, double d, double b, double c)
{
t /= d/2;
if (t < 1) return -c/2 * (sqrt(1 - t*t) - 1) + b;
t -= 2;
return c/2 * (sqrt(1 - t*t) + 1) + b;
t /= d/2;
if (t < 1) return -c/2 * (sqrt(1 - t*t) - 1) + b;
t -= 2;
return c/2 * (sqrt(1 - t*t) + 1) + b;
}
;
//todo: sdl requires floats, should the casting be done at this layer?
float Tween::GetDuration() const
{
return static_cast<float>(Duration);
return static_cast<float>(Duration);
}

72
Source/Graphics/Animate/Tween.h
View File

@ -13,43 +13,43 @@ class Tween
{
public:
Tween(TweenProperty name, TweenAlgorithm type, double start, double end, double duration);
float Animate(double elapsedTime);
static float AnimateSingle(TweenAlgorithm type, double start, double end, double duration, double elapsedTime);
static TweenAlgorithm GetTweenType(std::string name);
static bool GetTweenProperty(std::string name, TweenProperty &property);
TweenProperty GetProperty() const;
float GetDuration() const;
Tween(TweenProperty name, TweenAlgorithm type, double start, double end, double duration);
float Animate(double elapsedTime);
static float AnimateSingle(TweenAlgorithm type, double start, double end, double duration, double elapsedTime);
static TweenAlgorithm GetTweenType(std::string name);
static bool GetTweenProperty(std::string name, TweenProperty &property);
TweenProperty GetProperty() const;
float GetDuration() const;
private:
static double EaseInQuadratic(double elapsedTime, double duration, double b, double c);
static double EaseOutQuadratic(double elapsedTime, double duration, double b, double c);
static double EaseInOutQuadratic(double elapsedTime, double duration, double b, double c);
static double EaseInCubic(double elapsedTime, double duration, double b, double c);
static double EaseOutCubic(double elapsedTime, double duration, double b, double c);
static double EaseInOutCubic(double elapsedTime, double duration, double b, double c);
static double EaseInQuartic(double elapsedTime, double duration, double b, double c);
static double EaseOutQuartic(double elapsedTime, double duration, double b, double c);
static double EaseInOutQuartic(double elapsedTime, double duration, double b, double c);
static double EaseInQuintic(double elapsedTime, double duration, double b, double c);
static double EaseOutQuintic(double elapsedTime, double duration, double b, double c);
static double EaseInOutQuintic(double elapsedTime, double duration, double b, double c);
static double EaseInSine(double elapsedTime, double duration, double b, double c);
static double EaseOutSine(double elapsedTime, double duration, double b, double c);
static double EaseInOutSine(double elapsedTime, double duration, double b, double c);
static double EaseInExponential(double elapsedTime, double duration, double b, double c);
static double EaseOutExponential(double elapsedTime, double duration, double b, double c);
static double EaseInOutExponential(double elapsedTime, double duration, double b, double c);
static double EaseInCircular(double elapsedTime, double duration, double b, double c);
static double EaseOutCircular(double elapsedTime, double duration, double b, double c);
static double EaseInOutCircular(double elapsedTime, double duration, double b, double c);
static double Linear(double elapsedTime, double duration, double b, double c);
static double EaseInQuadratic(double elapsedTime, double duration, double b, double c);
static double EaseOutQuadratic(double elapsedTime, double duration, double b, double c);
static double EaseInOutQuadratic(double elapsedTime, double duration, double b, double c);
static double EaseInCubic(double elapsedTime, double duration, double b, double c);
static double EaseOutCubic(double elapsedTime, double duration, double b, double c);
static double EaseInOutCubic(double elapsedTime, double duration, double b, double c);
static double EaseInQuartic(double elapsedTime, double duration, double b, double c);
static double EaseOutQuartic(double elapsedTime, double duration, double b, double c);
static double EaseInOutQuartic(double elapsedTime, double duration, double b, double c);
static double EaseInQuintic(double elapsedTime, double duration, double b, double c);
static double EaseOutQuintic(double elapsedTime, double duration, double b, double c);
static double EaseInOutQuintic(double elapsedTime, double duration, double b, double c);
static double EaseInSine(double elapsedTime, double duration, double b, double c);
static double EaseOutSine(double elapsedTime, double duration, double b, double c);
static double EaseInOutSine(double elapsedTime, double duration, double b, double c);
static double EaseInExponential(double elapsedTime, double duration, double b, double c);
static double EaseOutExponential(double elapsedTime, double duration, double b, double c);
static double EaseInOutExponential(double elapsedTime, double duration, double b, double c);
static double EaseInCircular(double elapsedTime, double duration, double b, double c);
static double EaseOutCircular(double elapsedTime, double duration, double b, double c);
static double EaseInOutCircular(double elapsedTime, double duration, double b, double c);
static double Linear(double elapsedTime, double duration, double b, double c);
static std::map<std::string, TweenAlgorithm> TweenTypeMap;
static std::map<std::string, TweenProperty> TweenPropertyMap;
TweenProperty Property;
TweenAlgorithm Type;
double Start;
double End;
double Duration;
static std::map<std::string, TweenAlgorithm> TweenTypeMap;
static std::map<std::string, TweenProperty> TweenPropertyMap;
TweenProperty Property;
TweenAlgorithm Type;
double Start;
double End;
double Duration;
};

70
Source/Graphics/Animate/TweenTypes.h
View File

@ -1,45 +1,45 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#pragma once
enum TweenAlgorithm
{
LINEAR,
EASE_IN_QUADRATIC,
EASE_OUT_QUADRATIC,
EASE_INOUT_QUADRATIC,
EASE_IN_CUBIC,
EASE_OUT_CUBIC,
EASE_INOUT_CUBIC,
EASE_IN_QUARTIC,
EASE_OUT_QUARTIC,
EASE_INOUT_QUARTIC,
EASE_IN_QUINTIC,
EASE_OUT_QUINTIC,
EASE_INOUT_QUINTIC,
EASE_IN_SINE,
EASE_OUT_SINE,
EASE_INOUT_SINE,
EASE_IN_EXPONENTIAL,
EASE_OUT_EXPONENTIAL,
EASE_INOUT_EXPONENTIAL,
EASE_IN_CIRCULAR,
EASE_OUT_CIRCULAR,
EASE_INOUT_CIRCULAR,
LINEAR,
EASE_IN_QUADRATIC,
EASE_OUT_QUADRATIC,
EASE_INOUT_QUADRATIC,
EASE_IN_CUBIC,
EASE_OUT_CUBIC,
EASE_INOUT_CUBIC,
EASE_IN_QUARTIC,
EASE_OUT_QUARTIC,
EASE_INOUT_QUARTIC,
EASE_IN_QUINTIC,
EASE_OUT_QUINTIC,
EASE_INOUT_QUINTIC,
EASE_IN_SINE,
EASE_OUT_SINE,
EASE_INOUT_SINE,
EASE_IN_EXPONENTIAL,
EASE_OUT_EXPONENTIAL,
EASE_INOUT_EXPONENTIAL,
EASE_IN_CIRCULAR,
EASE_OUT_CIRCULAR,
EASE_INOUT_CIRCULAR,
};
enum TweenProperty
{
TWEEN_PROPERTY_HEIGHT,
TWEEN_PROPERTY_WIDTH,
TWEEN_PROPERTY_ANGLE,
TWEEN_PROPERTY_TRANSPARENCY,
TWEEN_PROPERTY_X,
TWEEN_PROPERTY_Y,
TWEEN_PROPERTY_X_ORIGIN,
TWEEN_PROPERTY_Y_ORIGIN,
TWEEN_PROPERTY_X_OFFSET,
TWEEN_PROPERTY_Y_OFFSET,
TWEEN_PROPERTY_FONT_SIZE
TWEEN_PROPERTY_HEIGHT,
TWEEN_PROPERTY_WIDTH,
TWEEN_PROPERTY_ANGLE,
TWEEN_PROPERTY_TRANSPARENCY,
TWEEN_PROPERTY_X,
TWEEN_PROPERTY_Y,
TWEEN_PROPERTY_X_ORIGIN,
TWEEN_PROPERTY_Y_ORIGIN,
TWEEN_PROPERTY_X_OFFSET,
TWEEN_PROPERTY_Y_OFFSET,
TWEEN_PROPERTY_FONT_SIZE
};

300
Source/Graphics/Component/Component.cpp
View File

@ -8,34 +8,34 @@
Component::Component()
{
OnEnterTweens = NULL;
OnExitTweens = NULL;
OnIdleTweens = NULL;
OnHighlightEnterTweens = NULL;
OnHighlightExitTweens = NULL;
SelectedItem = NULL;
NewItemSelectedSinceEnter = false;
FreeGraphicsMemory();
OnEnterTweens = NULL;
OnExitTweens = NULL;
OnIdleTweens = NULL;
OnHighlightEnterTweens = NULL;
OnHighlightExitTweens = NULL;
SelectedItem = NULL;
NewItemSelectedSinceEnter = false;
FreeGraphicsMemory();
}
Component::~Component()
{
FreeGraphicsMemory();
FreeGraphicsMemory();
}
void Component::FreeGraphicsMemory()
{
CurrentAnimationState = HIDDEN;
EnterRequested = false;
ExitRequested = false;
NewItemSelected = false;
HighlightExitComplete = false;
CurrentTweens = NULL;
CurrentTweenIndex = 0;
CurrentTweenComplete = false;
ElapsedTweenTime =0;
ScrollActive = false;
CurrentAnimationState = HIDDEN;
EnterRequested = false;
ExitRequested = false;
NewItemSelected = false;
HighlightExitComplete = false;
CurrentTweens = NULL;
CurrentTweenIndex = 0;
CurrentTweenComplete = false;
ElapsedTweenTime =0;
ScrollActive = false;
}
void Component::AllocateGraphicsMemory()
{
@ -43,240 +43,240 @@ void Component::AllocateGraphicsMemory()
void Component::TriggerEnterEvent()
{
EnterRequested = true;
EnterRequested = true;
}
void Component::TriggerExitEvent()
{
ExitRequested = true;
ExitRequested = true;
}
void Component::TriggerHighlightEvent(Item *selectedItem)
{
NewItemSelected = true;
this->SelectedItem = selectedItem;
NewItemSelected = true;
this->SelectedItem = selectedItem;
}
bool Component::IsIdle()
{
return (CurrentAnimationState == IDLE);
return (CurrentAnimationState == IDLE);
}
bool Component::IsHidden()
{
return (CurrentAnimationState == HIDDEN);
return (CurrentAnimationState == HIDDEN);
}
bool Component::IsWaiting()
{
return (CurrentAnimationState == HIGHLIGHT_WAIT);
return (CurrentAnimationState == HIGHLIGHT_WAIT);
}
void Component::Update(float dt)
{
ElapsedTweenTime += dt;
HighlightExitComplete = false;
if(IsHidden() || IsWaiting() || (IsIdle() && ExitRequested))
{
CurrentTweenComplete = true;
}
ElapsedTweenTime += dt;
HighlightExitComplete = false;
if(IsHidden() || IsWaiting() || (IsIdle() && ExitRequested))
{
CurrentTweenComplete = true;
}
if(CurrentTweenComplete)
{
CurrentTweens = NULL;
if(CurrentTweenComplete)
{
CurrentTweens = NULL;
// There was no request to override our state path. Continue on as normal.
switch(CurrentAnimationState)
{
case ENTER:
// There was no request to override our state path. Continue on as normal.
switch(CurrentAnimationState)
{
case ENTER:
CurrentTweens = OnHighlightEnterTweens;
CurrentAnimationState = HIGHLIGHT_ENTER;
break;
case EXIT:
case EXIT:
CurrentTweens = NULL;
CurrentAnimationState = HIDDEN;
break;
case HIGHLIGHT_ENTER:
case HIGHLIGHT_ENTER:
CurrentTweens = OnIdleTweens;
CurrentAnimationState = IDLE;
break;
case IDLE:
case IDLE:
// prevent us from automatically jumping to the exit tween upon enter
if(EnterRequested)
{
EnterRequested = false;
NewItemSelected = false;
EnterRequested = false;
NewItemSelected = false;
}
else if(IsScrollActive() || NewItemSelected || ExitRequested)
{
CurrentTweens = OnHighlightExitTweens;
CurrentAnimationState = HIGHLIGHT_EXIT;
CurrentTweens = OnHighlightExitTweens;
CurrentAnimationState = HIGHLIGHT_EXIT;
}
else
{
CurrentTweens = OnIdleTweens;
CurrentAnimationState = IDLE;
CurrentTweens = OnIdleTweens;
CurrentAnimationState = IDLE;
}
break;
case HIGHLIGHT_EXIT:
case HIGHLIGHT_EXIT:
// intentionally break down
case HIGHLIGHT_WAIT:
// intentionally break down
case HIGHLIGHT_WAIT:
if(ExitRequested && (CurrentAnimationState == HIGHLIGHT_WAIT))
{
CurrentTweens = OnHighlightExitTweens;
CurrentAnimationState = HIGHLIGHT_EXIT;
CurrentTweens = OnHighlightExitTweens;
CurrentAnimationState = HIGHLIGHT_EXIT;
}
else if(ExitRequested && (CurrentAnimationState == HIGHLIGHT_EXIT))
{
CurrentTweens = OnExitTweens;
CurrentAnimationState = EXIT;
ExitRequested = false;
CurrentTweens = OnExitTweens;
CurrentAnimationState = EXIT;
ExitRequested = false;
}
else if(IsScrollActive())
{
CurrentTweens = NULL;
CurrentAnimationState = HIGHLIGHT_WAIT;
CurrentTweens = NULL;
CurrentAnimationState = HIGHLIGHT_WAIT;
}
else if(NewItemSelected)
{
CurrentTweens = OnHighlightEnterTweens;
CurrentAnimationState = HIGHLIGHT_ENTER;
HighlightExitComplete = true;
NewItemSelected = false;
CurrentTweens = OnHighlightEnterTweens;
CurrentAnimationState = HIGHLIGHT_ENTER;
HighlightExitComplete = true;
NewItemSelected = false;
}
else
{
CurrentTweens = NULL;
CurrentAnimationState = HIGHLIGHT_WAIT;
CurrentTweens = NULL;
CurrentAnimationState = HIGHLIGHT_WAIT;
}
break;
case HIDDEN:
case HIDDEN:
if(EnterRequested || ExitRequested)
{
CurrentTweens = OnEnterTweens;
CurrentAnimationState = ENTER;
CurrentTweens = OnEnterTweens;
CurrentAnimationState = ENTER;
}
else
{
CurrentTweens = NULL;
CurrentAnimationState = HIDDEN;
CurrentTweens = NULL;
CurrentAnimationState = HIDDEN;
}
}
}
CurrentTweenIndex = 0;
CurrentTweenComplete = false;
CurrentTweenIndex = 0;
CurrentTweenComplete = false;
ElapsedTweenTime = 0;
}
ElapsedTweenTime = 0;
}
CurrentTweenComplete = Animate(IsIdle());
CurrentTweenComplete = Animate(IsIdle());
}
bool Component::Animate(bool loop)
{
bool completeDone = false;
if(!CurrentTweens || CurrentTweenIndex >= CurrentTweens->size())
{
completeDone = true;
}
else if(CurrentTweens)
{
bool currentDone = true;
std::vector<Tween *> *tweenSet = CurrentTweens->at(CurrentTweenIndex);
bool completeDone = false;
if(!CurrentTweens || CurrentTweenIndex >= CurrentTweens->size())
{
completeDone = true;
}
else if(CurrentTweens)
{
bool currentDone = true;
std::vector<Tween *> *tweenSet = CurrentTweens->at(CurrentTweenIndex);
for(unsigned int i = 0; i < tweenSet->size(); i++)
{
Tween *tween = tweenSet->at(i);
float elapsedTime = ElapsedTweenTime;
for(unsigned int i = 0; i < tweenSet->size(); i++)
{
Tween *tween = tweenSet->at(i);
float elapsedTime = ElapsedTweenTime;
//todo: too many levels of nesting
if(elapsedTime < tween->GetDuration())
{
currentDone = false;
}
else
{
elapsedTime = tween->GetDuration();
}
//todo: too many levels of nesting
if(elapsedTime < tween->GetDuration())
{
currentDone = false;
}
else
{
elapsedTime = tween->GetDuration();
}
float value = tween->Animate(elapsedTime);
float value = tween->Animate(elapsedTime);
switch(tween->GetProperty())
{
case TWEEN_PROPERTY_X:
GetBaseViewInfo()->SetX(value);
break;
switch(tween->GetProperty())
{
case TWEEN_PROPERTY_X:
GetBaseViewInfo()->SetX(value);
break;
case TWEEN_PROPERTY_Y:
GetBaseViewInfo()->SetY(value);
break;
case TWEEN_PROPERTY_Y:
GetBaseViewInfo()->SetY(value);
break;
case TWEEN_PROPERTY_HEIGHT:
GetBaseViewInfo()->SetHeight(value);
break;
case TWEEN_PROPERTY_HEIGHT:
GetBaseViewInfo()->SetHeight(value);
break;
case TWEEN_PROPERTY_WIDTH:
GetBaseViewInfo()->SetWidth(value);
break;
case TWEEN_PROPERTY_WIDTH:
GetBaseViewInfo()->SetWidth(value);
break;
case TWEEN_PROPERTY_ANGLE:
GetBaseViewInfo()->SetAngle(value);
break;
case TWEEN_PROPERTY_ANGLE:
GetBaseViewInfo()->SetAngle(value);
break;
case TWEEN_PROPERTY_TRANSPARENCY:
GetBaseViewInfo()->SetTransparency(value);
break;
case TWEEN_PROPERTY_TRANSPARENCY:
GetBaseViewInfo()->SetTransparency(value);
break;
case TWEEN_PROPERTY_X_ORIGIN:
GetBaseViewInfo()->SetXOrigin(value);
break;
case TWEEN_PROPERTY_X_ORIGIN:
GetBaseViewInfo()->SetXOrigin(value);
break;
case TWEEN_PROPERTY_Y_ORIGIN:
GetBaseViewInfo()->SetYOrigin(value);
break;
case TWEEN_PROPERTY_Y_ORIGIN:
GetBaseViewInfo()->SetYOrigin(value);
break;
case TWEEN_PROPERTY_X_OFFSET:
GetBaseViewInfo()->SetXOffset(value);
break;
case TWEEN_PROPERTY_X_OFFSET:
GetBaseViewInfo()->SetXOffset(value);
break;
case TWEEN_PROPERTY_Y_OFFSET:
GetBaseViewInfo()->SetYOffset(value);
break;
case TWEEN_PROPERTY_Y_OFFSET:
GetBaseViewInfo()->SetYOffset(value);
break;
case TWEEN_PROPERTY_FONT_SIZE:
GetBaseViewInfo()->SetFontSize(value);
break;
}
}
case TWEEN_PROPERTY_FONT_SIZE:
GetBaseViewInfo()->SetFontSize(value);
break;
}
}
if(currentDone)
{
CurrentTweenIndex++;
ElapsedTweenTime = 0;
}
}
if(currentDone)
{
CurrentTweenIndex++;
ElapsedTweenTime = 0;
}
}
if(!CurrentTweens || CurrentTweenIndex >= CurrentTweens->size())
{
if(loop)
{
CurrentTweenIndex = 0;
}
completeDone = true;
}
if(!CurrentTweens || CurrentTweenIndex >= CurrentTweens->size())
{
if(loop)
{
CurrentTweenIndex = 0;
}
completeDone = true;
}
return completeDone;
return completeDone;
}

174
Source/Graphics/Component/Component.h
View File

@ -13,110 +13,110 @@
class Component
{
public:
Component();
virtual ~Component();
virtual void FreeGraphicsMemory();
virtual void AllocateGraphicsMemory();
virtual void LaunchEnter() {}
virtual void LaunchExit() {}
void TriggerEnterEvent();
void TriggerExitEvent();
void TriggerHighlightEvent(Item *selectedItem);
bool IsIdle();
bool IsHidden();
bool IsWaiting();
typedef std::vector<std::vector<Tween *> *> TweenSets;
Component();
virtual ~Component();
virtual void FreeGraphicsMemory();
virtual void AllocateGraphicsMemory();
virtual void LaunchEnter() {}
virtual void LaunchExit() {}
void TriggerEnterEvent();
void TriggerExitEvent();
void TriggerHighlightEvent(Item *selectedItem);
bool IsIdle();
bool IsHidden();
bool IsWaiting();
typedef std::vector<std::vector<Tween *> *> TweenSets;
void SetOnEnterTweens(TweenSets *tweens)
{
this->OnEnterTweens = tweens;
}
void SetOnEnterTweens(TweenSets *tweens)
{
this->OnEnterTweens = tweens;
}
void SetOnExitTweens(TweenSets *tweens)
{
this->OnExitTweens = tweens;
}
void SetOnExitTweens(TweenSets *tweens)
{
this->OnExitTweens = tweens;
}
void SetOnIdleTweens(TweenSets *tweens)
{
this->OnIdleTweens = tweens;
}
void SetOnIdleTweens(TweenSets *tweens)
{
this->OnIdleTweens = tweens;
}
void SetOnHighlightEnterTweens(TweenSets *tweens)
{
this->OnHighlightEnterTweens = tweens;
}
void SetOnHighlightEnterTweens(TweenSets *tweens)
{
this->OnHighlightEnterTweens = tweens;
}
void SetOnHighlightExitTweens(TweenSets *tweens)
{
this->OnHighlightExitTweens = tweens;
}
virtual void Update(float dt);
void SetOnHighlightExitTweens(TweenSets *tweens)
{
this->OnHighlightExitTweens = tweens;
}
virtual void Update(float dt);
virtual void Draw() = 0;
virtual void Draw() = 0;
ViewInfo *GetBaseViewInfo()
{
return &BaseViewInfo;
}
void UpdateBaseViewInfo(ViewInfo &info)
{
BaseViewInfo = info;
}
ViewInfo *GetBaseViewInfo()
{
return &BaseViewInfo;
}
void UpdateBaseViewInfo(ViewInfo &info)
{
BaseViewInfo = info;
}
bool IsScrollActive() const
{
return ScrollActive;
}
bool IsScrollActive() const
{
return ScrollActive;
}
void SetScrollActive(bool scrollActive)
{
ScrollActive = scrollActive;
}
void SetScrollActive(bool scrollActive)
{
ScrollActive = scrollActive;
}
protected:
Item *GetSelectedItem()
{
return SelectedItem;
}
enum AnimationState
{
IDLE,
ENTER,
HIGHLIGHT_EXIT,
HIGHLIGHT_WAIT,
HIGHLIGHT_ENTER,
EXIT,
HIDDEN
};
Item *GetSelectedItem()
{
return SelectedItem;
}
enum AnimationState
{
IDLE,
ENTER,
HIGHLIGHT_EXIT,
HIGHLIGHT_WAIT,
HIGHLIGHT_ENTER,
EXIT,
HIDDEN
};
AnimationState CurrentAnimationState;
bool EnterRequested;
bool ExitRequested;
bool NewItemSelected;
bool HighlightExitComplete;
bool NewItemSelectedSinceEnter;
AnimationState CurrentAnimationState;
bool EnterRequested;
bool ExitRequested;
bool NewItemSelected;
bool HighlightExitComplete;
bool NewItemSelectedSinceEnter;
private:
bool Animate(bool loop);
bool IsTweenSequencingComplete();
void ResetTweenSequence(std::vector<ViewInfo *> *tweens);
bool Animate(bool loop);
bool IsTweenSequencingComplete();
void ResetTweenSequence(std::vector<ViewInfo *> *tweens);
TweenSets *OnEnterTweens;
TweenSets *OnExitTweens;
TweenSets *OnIdleTweens;
TweenSets *OnHighlightEnterTweens;
TweenSets *OnHighlightExitTweens;
TweenSets *OnEnterTweens;
TweenSets *OnExitTweens;
TweenSets *OnIdleTweens;
TweenSets *OnHighlightEnterTweens;
TweenSets *OnHighlightExitTweens;
TweenSets *CurrentTweens;
unsigned int CurrentTweenIndex;
TweenSets *CurrentTweens;
unsigned int CurrentTweenIndex;
bool CurrentTweenComplete;
ViewInfo BaseViewInfo;
bool CurrentTweenComplete;
ViewInfo BaseViewInfo;
float ElapsedTweenTime;
Tween *TweenInst;
Item *SelectedItem;
bool ScrollActive;
float ElapsedTweenTime;
Tween *TweenInst;
Item *SelectedItem;
bool ScrollActive;
};

80
Source/Graphics/Component/Image.cpp
View File

@ -8,68 +8,68 @@
#include <SDL2/SDL_image.h>
Image::Image(std::string file, float scaleX, float scaleY)
: Texture(NULL)
, File(file)
, ScaleX(scaleX)
, ScaleY(scaleY)
: Texture(NULL)
, File(file)
, ScaleX(scaleX)
, ScaleY(scaleY)
{
AllocateGraphicsMemory();
AllocateGraphicsMemory();
}
Image::~Image()
{
FreeGraphicsMemory();
FreeGraphicsMemory();
}
void Image::FreeGraphicsMemory()
{
Component::FreeGraphicsMemory();
Component::FreeGraphicsMemory();
SDL_LockMutex(SDL::GetMutex());
if (Texture != NULL)
{
SDL_DestroyTexture(Texture);
Texture = NULL;
}
SDL_UnlockMutex(SDL::GetMutex());
SDL_LockMutex(SDL::GetMutex());
if (Texture != NULL)
{
SDL_DestroyTexture(Texture);
Texture = NULL;
}
SDL_UnlockMutex(SDL::GetMutex());
}
void Image::AllocateGraphicsMemory()
{
int width;
int height;
int width;
int height;
Component::AllocateGraphicsMemory();
Component::AllocateGraphicsMemory();
if(!Texture)
{
SDL_LockMutex(SDL::GetMutex());
Texture = IMG_LoadTexture(SDL::GetRenderer(), File.c_str());
if(!Texture)
{
SDL_LockMutex(SDL::GetMutex());
Texture = IMG_LoadTexture(SDL::GetRenderer(), File.c_str());
if (Texture != NULL)
{
SDL_SetTextureBlendMode(Texture, SDL_BLENDMODE_BLEND);
SDL_QueryTexture(Texture, NULL, NULL, &width, &height);
GetBaseViewInfo()->SetImageWidth(width * ScaleX);
GetBaseViewInfo()->SetImageHeight(height * ScaleY);
}
SDL_UnlockMutex(SDL::GetMutex());
if (Texture != NULL)
{
SDL_SetTextureBlendMode(Texture, SDL_BLENDMODE_BLEND);
SDL_QueryTexture(Texture, NULL, NULL, &width, &height);
GetBaseViewInfo()->SetImageWidth(width * ScaleX);
GetBaseViewInfo()->SetImageHeight(height * ScaleY);
}
SDL_UnlockMutex(SDL::GetMutex());
}
}
}
void Image::Draw()
{
if(Texture)
{
ViewInfo *info = GetBaseViewInfo();
SDL_Rect rect;
if(Texture)
{
ViewInfo *info = GetBaseViewInfo();
SDL_Rect rect;
rect.x = static_cast<int>(info->GetXRelativeToOrigin());
rect.y = static_cast<int>(info->GetYRelativeToOrigin());
rect.h = static_cast<int>(info->GetHeight());
rect.w = static_cast<int>(info->GetWidth());
rect.x = static_cast<int>(info->GetXRelativeToOrigin());
rect.y = static_cast<int>(info->GetYRelativeToOrigin());
rect.h = static_cast<int>(info->GetHeight());
rect.w = static_cast<int>(info->GetWidth());
SDL::RenderCopy(Texture, static_cast<char>((info->GetTransparency() * 255)), NULL, &rect, info->GetAngle());
}
SDL::RenderCopy(Texture, static_cast<char>((info->GetTransparency() * 255)), NULL, &rect, info->GetAngle());
}
}

18
Source/Graphics/Component/Image.h
View File

@ -10,15 +10,15 @@
class Image : public Component
{
public:
Image(std::string file, float scaleX, float scaleY);
virtual ~Image();
void FreeGraphicsMemory();
void AllocateGraphicsMemory();
void Draw();
Image(std::string file, float scaleX, float scaleY);
virtual ~Image();
void FreeGraphicsMemory();
void AllocateGraphicsMemory();
void Draw();
protected:
SDL_Texture *Texture;
std::string File;
float ScaleX;
float ScaleY;
SDL_Texture *Texture;
std::string File;
float ScaleX;
float ScaleY;
};

30
Source/Graphics/Component/ImageBuilder.cpp
View File

@ -8,23 +8,23 @@
Image * ImageBuilder::CreateImage(std::string path, std::string name, float scaleX, float scaleY)
{
Image *image = NULL;
std::vector<std::string> extensions;
Image *image = NULL;
std::vector<std::string> extensions;
extensions.push_back("png");
extensions.push_back("PNG");
extensions.push_back("jpg");
extensions.push_back("JPG");
extensions.push_back("jpeg");
extensions.push_back("JPEG");
extensions.push_back("png");
extensions.push_back("PNG");
extensions.push_back("jpg");
extensions.push_back("JPG");
extensions.push_back("jpeg");
extensions.push_back("JPEG");
std::string prefix = path + "/" + name;
std::string file;
std::string prefix = path + "/" + name;
std::string file;
if(Utils::FindMatchingFile(prefix, extensions, file))
{
image = new Image(file, scaleX, scaleY);
}
if(Utils::FindMatchingFile(prefix, extensions, file))
{
image = new Image(file, scaleX, scaleY);
}
return image;
return image;
}

2
Source/Graphics/Component/ImageBuilder.h
View File

@ -11,5 +11,5 @@
class ImageBuilder
{
public:
Image * CreateImage(std::string path, std::string name, float scaleX, float scaleY);
Image * CreateImage(std::string path, std::string name, float scaleX, float scaleY);
};

210
Source/Graphics/Component/ReloadableMedia.cpp
View File

@ -15,158 +15,158 @@
#include <iostream>
ReloadableMedia::ReloadableMedia(std::string imagePath, std::string videoPath, bool isVideo, float scaleX, float scaleY)
: LoadedComponent(NULL)
, ImagePath(imagePath)
, VideoPath(videoPath)
, ReloadRequested(false)
, FirstLoad(true)
, IsVideo(isVideo)
, ScaleX(scaleX)
, ScaleY(scaleY)
: LoadedComponent(NULL)
, ImagePath(imagePath)
, VideoPath(videoPath)
, ReloadRequested(false)
, FirstLoad(true)
, IsVideo(isVideo)
, ScaleX(scaleX)
, ScaleY(scaleY)
{
AllocateGraphicsMemory();
AllocateGraphicsMemory();
}
ReloadableMedia::~ReloadableMedia()
{
if (LoadedComponent != NULL)
{
delete LoadedComponent;
}
if (LoadedComponent != NULL)
{
delete LoadedComponent;
}
}
void ReloadableMedia::Update(float dt)
{
if(NewItemSelected)
{
ReloadRequested = true;
}
// wait for the right moment to reload the image
if (ReloadRequested && (HighlightExitComplete || FirstLoad))
{
ReloadTexture();
ReloadRequested = false;
FirstLoad = false;
}
if(NewItemSelected)
{
ReloadRequested = true;
}
// wait for the right moment to reload the image
if (ReloadRequested && (HighlightExitComplete || FirstLoad))
{
ReloadTexture();
ReloadRequested = false;
FirstLoad = false;
}
if(LoadedComponent)
{
LoadedComponent->Update(dt);
}
if(LoadedComponent)
{
LoadedComponent->Update(dt);
}
// needs to be ran at the end to prevent the NewItemSelected flag from being detected
Component::Update(dt);
Component::Update(dt);
}
void ReloadableMedia::AllocateGraphicsMemory()
{
FirstLoad = true;
FirstLoad = true;
if(LoadedComponent)
{
LoadedComponent->AllocateGraphicsMemory();
}
if(LoadedComponent)
{
LoadedComponent->AllocateGraphicsMemory();
}
// NOTICE! needs to be done last to prevent flags from being missed
Component::AllocateGraphicsMemory();
// NOTICE! needs to be done last to prevent flags from being missed
Component::AllocateGraphicsMemory();
}
void ReloadableMedia::LaunchEnter()
{
if(LoadedComponent)
{
LoadedComponent->LaunchEnter();
}
if(LoadedComponent)
{
LoadedComponent->LaunchEnter();
}
}
void ReloadableMedia::LaunchExit()
{
if(LoadedComponent)
{
LoadedComponent->LaunchExit();
}
if(LoadedComponent)
{
LoadedComponent->LaunchExit();
}
}
void ReloadableMedia::FreeGraphicsMemory()
{
Component::FreeGraphicsMemory();
Component::FreeGraphicsMemory();
if(LoadedComponent)
{
LoadedComponent->FreeGraphicsMemory();
}
if(LoadedComponent)
{
LoadedComponent->FreeGraphicsMemory();
}
}
void ReloadableMedia::ReloadTexture()
{
bool found = false;
bool found = false;
if(LoadedComponent)
{
delete LoadedComponent;
LoadedComponent = NULL;
}
if(LoadedComponent)
{
delete LoadedComponent;
LoadedComponent = NULL;
}
Item *selectedItem = GetSelectedItem();
Item *selectedItem = GetSelectedItem();
if (selectedItem != NULL)
{
if(IsVideo)
{
std::vector<std::string> names;
if (selectedItem != NULL)
{
if(IsVideo)
{
std::vector<std::string> names;
names.push_back(selectedItem->GetName());
names.push_back(selectedItem->GetName());
if(selectedItem->GetCloneOf().length() > 0)
{
names.push_back(selectedItem->GetCloneOf());
}
for(unsigned int n = 0; n < names.size() && !found; ++n)
{
std::string filePrefix;
filePrefix.append(VideoPath);
filePrefix.append("/");
filePrefix.append(names[n]);
std::string file;
VideoBuilder videoBuild;
LoadedComponent = videoBuild.CreateVideo(VideoPath, names[n], ScaleX, ScaleY);
if(LoadedComponent)
if(selectedItem->GetCloneOf().length() > 0)
{
LoadedComponent->AllocateGraphicsMemory();
found = true;
names.push_back(selectedItem->GetCloneOf());
}
}
}
if(!LoadedComponent)
{
ImageBuilder imageBuild;
LoadedComponent = imageBuild.CreateImage(ImagePath, selectedItem->GetFullTitle(), ScaleX, ScaleY);
for(unsigned int n = 0; n < names.size() && !found; ++n)
{
std::string filePrefix;
filePrefix.append(VideoPath);
filePrefix.append("/");
filePrefix.append(names[n]);
if (LoadedComponent != NULL)
{
LoadedComponent->AllocateGraphicsMemory();
GetBaseViewInfo()->SetImageWidth(LoadedComponent->GetBaseViewInfo()->GetImageWidth());
GetBaseViewInfo()->SetImageHeight(LoadedComponent->GetBaseViewInfo()->GetImageHeight());
}
}
}
std::string file;
VideoBuilder videoBuild;
LoadedComponent = videoBuild.CreateVideo(VideoPath, names[n], ScaleX, ScaleY);
if(LoadedComponent)
{
LoadedComponent->AllocateGraphicsMemory();
found = true;
}
}
}
if(!LoadedComponent)
{
ImageBuilder imageBuild;
LoadedComponent = imageBuild.CreateImage(ImagePath, selectedItem->GetFullTitle(), ScaleX, ScaleY);
if (LoadedComponent != NULL)
{
LoadedComponent->AllocateGraphicsMemory();
GetBaseViewInfo()->SetImageWidth(LoadedComponent->GetBaseViewInfo()->GetImageWidth());
GetBaseViewInfo()->SetImageHeight(LoadedComponent->GetBaseViewInfo()->GetImageHeight());
}
}
}
}
void ReloadableMedia::Draw()
{
ViewInfo *info = GetBaseViewInfo();
ViewInfo *info = GetBaseViewInfo();
if(LoadedComponent)
{
info->SetImageHeight(LoadedComponent->GetBaseViewInfo()->GetImageHeight());
info->SetImageWidth(LoadedComponent->GetBaseViewInfo()->GetImageWidth());
LoadedComponent->UpdateBaseViewInfo(*info);
LoadedComponent->Draw();
}
if(LoadedComponent)
{
info->SetImageHeight(LoadedComponent->GetBaseViewInfo()->GetImageHeight());
info->SetImageWidth(LoadedComponent->GetBaseViewInfo()->GetImageWidth());
LoadedComponent->UpdateBaseViewInfo(*info);
LoadedComponent->Draw();
}
}

36
Source/Graphics/Component/ReloadableMedia.h
View File

@ -14,25 +14,25 @@ class Image;
class ReloadableMedia : public Component
{
public:
ReloadableMedia(std::string imagePath, std::string videoPath, bool isVideo, float scaleX, float scaleY);
virtual ~ReloadableMedia();
void Update(float dt);
void Draw();
void FreeGraphicsMemory();
void AllocateGraphicsMemory();
void LaunchEnter();
void LaunchExit();
ReloadableMedia(std::string imagePath, std::string videoPath, bool isVideo, float scaleX, float scaleY);
virtual ~ReloadableMedia();
void Update(float dt);
void Draw();
void FreeGraphicsMemory();
void AllocateGraphicsMemory();
void LaunchEnter();
void LaunchExit();
private:
void ReloadTexture();
Component *LoadedComponent;
std::string ImagePath;
std::string VideoPath;
bool ReloadRequested;
bool FirstLoad;
IVideo *VideoInst;
void ReloadTexture();
Component *LoadedComponent;
std::string ImagePath;
std::string VideoPath;
bool ReloadRequested;
bool FirstLoad;
IVideo *VideoInst;
bool IsVideo;
float ScaleX;
float ScaleY;
bool IsVideo;
float ScaleX;
float ScaleY;
};

192
Source/Graphics/Component/ReloadableText.cpp
View File

@ -11,80 +11,80 @@
#include <iostream>
ReloadableText::ReloadableText(std::string type, Font *font, SDL_Color color, std::string layoutKey, std::string collection, float scaleX, float scaleY)
: ImageInst(NULL)
, LayoutKey(layoutKey)
, Collection(collection)
, ReloadRequested(false)
, FirstLoad(true)
, FontInst(font)
, FontColor(color)
, ScaleX(scaleX)
, ScaleY(scaleY)
: ImageInst(NULL)
, LayoutKey(layoutKey)
, Collection(collection)
, ReloadRequested(false)
, FirstLoad(true)
, FontInst(font)
, FontColor(color)
, ScaleX(scaleX)
, ScaleY(scaleY)
{
Type = TextTypeUnknown;
Type = TextTypeUnknown;
if(type == "numberButtons")
{
Type = TextTypeNumberButtons;
}
else if(type == "numberPlayers")
{
Type = TextTypeNumberPlayers;
}
else if(type == "year")
{
Type = TextTypeYear;
}
else if(type == "title")
{
Type = TextTypeTitle;
}
else if(type == "manufacturer")
{
Type = TextTypeManufacturer;
}
if(type == "numberButtons")
{
Type = TextTypeNumberButtons;
}
else if(type == "numberPlayers")
{
Type = TextTypeNumberPlayers;
}
else if(type == "year")
{
Type = TextTypeYear;
}
else if(type == "title")
{
Type = TextTypeTitle;
}
else if(type == "manufacturer")
{
Type = TextTypeManufacturer;
}
AllocateGraphicsMemory();
AllocateGraphicsMemory();
}
ReloadableText::~ReloadableText()
{
if (ImageInst != NULL)
{
delete ImageInst;
}
if (ImageInst != NULL)
{
delete ImageInst;
}
}
void ReloadableText::Update(float dt)
{
if(NewItemSelected)
{
ReloadRequested = true;
}
// wait for the right moment to reload the image
if (ReloadRequested && (HighlightExitComplete || FirstLoad))
{
ReloadTexture();
ReloadRequested = false;
FirstLoad = false;
}
if(NewItemSelected)
{
ReloadRequested = true;
}
// wait for the right moment to reload the image
if (ReloadRequested && (HighlightExitComplete || FirstLoad))
{
ReloadTexture();
ReloadRequested = false;
FirstLoad = false;
}
// needs to be ran at the end to prevent the NewItemSelected flag from being detected
Component::Update(dt);
// needs to be ran at the end to prevent the NewItemSelected flag from being detected
Component::Update(dt);
}
void ReloadableText::AllocateGraphicsMemory()
{
FirstLoad = true;
FirstLoad = true;
ReloadTexture();
ReloadTexture();
// NOTICE! needs to be done last to prevent flags from being missed
Component::AllocateGraphicsMemory();
// NOTICE! needs to be done last to prevent flags from being missed
Component::AllocateGraphicsMemory();
}
void ReloadableText::LaunchEnter()
@ -97,61 +97,61 @@ void ReloadableText::LaunchExit()
void ReloadableText::FreeGraphicsMemory()
{
Component::FreeGraphicsMemory();
Component::FreeGraphicsMemory();
if (ImageInst != NULL)
{
delete ImageInst;
ImageInst = NULL;
}
if (ImageInst != NULL)
{
delete ImageInst;
ImageInst = NULL;
}
}
void ReloadableText::ReloadTexture()
{
if (ImageInst != NULL)
{
delete ImageInst;
ImageInst = NULL;
}
if (ImageInst != NULL)
{
delete ImageInst;
ImageInst = NULL;
}
Item *selectedItem = GetSelectedItem();
Item *selectedItem = GetSelectedItem();
if (selectedItem != NULL)
{
std::stringstream ss;
std::string text;
switch(Type)
{
case TextTypeNumberButtons:
ss << selectedItem->GetNumberButtons();
break;
case TextTypeNumberPlayers:
ss << selectedItem->GetNumberPlayers();
break;
case TextTypeYear:
ss << selectedItem->GetYear();
break;
case TextTypeTitle:
ss << selectedItem->GetTitle();
break;
case TextTypeManufacturer:
ss << selectedItem->GetManufacturer();
break;
default:
break;
}
if (selectedItem != NULL)
{
std::stringstream ss;
std::string text;
switch(Type)
{
case TextTypeNumberButtons:
ss << selectedItem->GetNumberButtons();
break;
case TextTypeNumberPlayers:
ss << selectedItem->GetNumberPlayers();
break;
case TextTypeYear:
ss << selectedItem->GetYear();
break;
case TextTypeTitle:
ss << selectedItem->GetTitle();
break;
case TextTypeManufacturer:
ss << selectedItem->GetManufacturer();
break;
default:
break;
}
ImageInst = new Text(ss.str(), FontInst, FontColor, ScaleX, ScaleY);
}
ImageInst = new Text(ss.str(), FontInst, FontColor, ScaleX, ScaleY);
}
}
void ReloadableText::Draw()
{
ViewInfo *info = GetBaseViewInfo();
ViewInfo *info = GetBaseViewInfo();
if(ImageInst)
{
ImageInst->UpdateBaseViewInfo(*info);
ImageInst->Draw();
}
if(ImageInst)
{
ImageInst->UpdateBaseViewInfo(*info);
ImageInst->Draw();
}
}

56
Source/Graphics/Component/ReloadableText.h
View File

@ -12,37 +12,37 @@
class ReloadableText : public Component
{
public:
ReloadableText(std::string type, Font *font, SDL_Color color, std::string layoutKey, std::string collectionName, float scaleX, float scaleY);
virtual ~ReloadableText();
void Update(float dt);
void Draw();
void FreeGraphicsMemory();
void AllocateGraphicsMemory();
void LaunchEnter();
void LaunchExit();
ReloadableText(std::string type, Font *font, SDL_Color color, std::string layoutKey, std::string collectionName, float scaleX, float scaleY);
virtual ~ReloadableText();
void Update(float dt);
void Draw();
void FreeGraphicsMemory();
void AllocateGraphicsMemory();
void LaunchEnter();
void LaunchExit();
private:
enum TextType
{
TextTypeUnknown = 0,
TextTypeNumberButtons,
TextTypeNumberPlayers,
TextTypeYear,
TextTypeTitle,
TextTypeManufacturer,
};
enum TextType
{
TextTypeUnknown = 0,
TextTypeNumberButtons,
TextTypeNumberPlayers,
TextTypeYear,
TextTypeTitle,
TextTypeManufacturer,
};
void ReloadTexture();
void ReloadTexture();
Text *ImageInst;
TextType Type;
std::string LayoutKey;
std::string Collection;
bool ReloadRequested;
bool FirstLoad;
Font *FontInst;
SDL_Color FontColor;
Text *ImageInst;
TextType Type;
std::string LayoutKey;
std::string Collection;
bool ReloadRequested;
bool FirstLoad;
Font *FontInst;
SDL_Color FontColor;
float ScaleX;
float ScaleY;
float ScaleX;
float ScaleY;
};

890
Source/Graphics/Component/ScrollingList.cpp
View File

File diff suppressed because it is too large Load Diff

136
Source/Graphics/Component/ScrollingList.h
View File

@ -23,83 +23,83 @@ class Font;
class ScrollingList : public Component
{
public:
enum ScrollDirection
{
ScrollDirectionBack,
ScrollDirectionForward,
ScrollDirectionIdle,
enum ScrollDirection
{
ScrollDirectionBack,
ScrollDirectionForward,
ScrollDirectionIdle,
};
};
ScrollingList(Configuration *c, float scaleX, float scaleY, Font *font, SDL_Color fontColor, std::string layoutKey, std::string CollectionName, std::string imageType);
virtual ~ScrollingList();
void AllocateTexture(ComponentItemBinding *s);
void DeallocateTexture(ComponentItemBinding *s);
void SetItems(std::vector<ComponentItemBinding *> *spriteList);
void SetPoints(std::vector<ViewInfo *> *scrollPoints);
void SetScrollDirection(ScrollDirection direction);
void PageUp();
void PageDown();
bool IsIdle();
void SetSelectedIndex(int selectedIndex);
ComponentItemBinding *GetSelectedCollectionItemSprite();
ComponentItemBinding *GetPendingCollectionItemSprite();
ComponentItemBinding *GetPendingSelectedCollectionItemSprite();
void AddComponentForNotifications(MenuNotifierInterface *c);
void RemoveComponentForNotifications(MenuNotifierInterface *c);
std::vector<ComponentItemBinding *> *GetCollectionItemSprites();
void RemoveSelectedItem();
void FreeGraphicsMemory();
void Update(float dt);
void Draw();
void Draw(unsigned int layer);
ScrollingList(Configuration *c, float scaleX, float scaleY, Font *font, SDL_Color fontColor, std::string layoutKey, std::string CollectionName, std::string imageType);
virtual ~ScrollingList();
void AllocateTexture(ComponentItemBinding *s);
void DeallocateTexture(ComponentItemBinding *s);
void SetItems(std::vector<ComponentItemBinding *> *spriteList);
void SetPoints(std::vector<ViewInfo *> *scrollPoints);
void SetScrollDirection(ScrollDirection direction);
void PageUp();
void PageDown();
bool IsIdle();
void SetSelectedIndex(int selectedIndex);
ComponentItemBinding *GetSelectedCollectionItemSprite();
ComponentItemBinding *GetPendingCollectionItemSprite();
ComponentItemBinding *GetPendingSelectedCollectionItemSprite();
void AddComponentForNotifications(MenuNotifierInterface *c);
void RemoveComponentForNotifications(MenuNotifierInterface *c);
std::vector<ComponentItemBinding *> *GetCollectionItemSprites();
void RemoveSelectedItem();
void FreeGraphicsMemory();
void Update(float dt);
void Draw();
void Draw(unsigned int layer);
private:
void Click();
unsigned int GetNextTween(unsigned int currentIndex, std::vector<ViewInfo *> *list);
bool IsScrollChangedStarted;
bool IsScrollChangedSignalled;
bool IsScrollChangedComplete;
void Click();
unsigned int GetNextTween(unsigned int currentIndex, std::vector<ViewInfo *> *list);
bool IsScrollChangedStarted;
bool IsScrollChangedSignalled;
bool IsScrollChangedComplete;
enum ScrollState
{
ScrollStateActive,
ScrollStatePageChange,
ScrollStateStopping,
ScrollStateIdle
};
enum ScrollState
{
ScrollStateActive,
ScrollStatePageChange,
ScrollStateStopping,
ScrollStateIdle
};
std::vector<ComponentItemBinding *> *SpriteList;
std::vector<ViewInfo *> *ScrollPoints;
std::vector<MenuNotifierInterface *> NotificationComponents;
float TweenEnterTime;
std::vector<ComponentItemBinding *> *SpriteList;
std::vector<ViewInfo *> *ScrollPoints;
std::vector<MenuNotifierInterface *> NotificationComponents;
float TweenEnterTime;
unsigned int FirstSpriteIndex;
unsigned int SelectedSpriteListIndex;
float CurrentAnimateTime;
float ScrollTime;
unsigned int FirstSpriteIndex;
unsigned int SelectedSpriteListIndex;
float CurrentAnimateTime;
float ScrollTime;
ScrollDirection CurrentScrollDirection;
ScrollDirection RequestedScrollDirection;
ScrollState CurrentScrollState;
float ScrollAcceleration;
float ScrollVelocity;
ScrollDirection CurrentScrollDirection;
ScrollDirection RequestedScrollDirection;
ScrollState CurrentScrollState;
float ScrollAcceleration;
float ScrollVelocity;
void CircularIncrement(unsigned &index, std::vector<ComponentItemBinding *> *list);
void CircularDecrement(unsigned &index, std::vector<ComponentItemBinding *> *list);
void CircularIncrement(unsigned &index, std::vector<ViewInfo *> *list);
void CircularDecrement(unsigned &index, std::vector<ViewInfo *> *list);
void UpdateOffset(float dt);
void CircularIncrement(unsigned &index, std::vector<ComponentItemBinding *> *list);
void CircularDecrement(unsigned &index, std::vector<ComponentItemBinding *> *list);
void CircularIncrement(unsigned &index, std::vector<ViewInfo *> *list);
void CircularDecrement(unsigned &index, std::vector<ViewInfo *> *list);
void UpdateOffset(float dt);
std::string Collection;
Configuration *Config;
float ScaleX;
float ScaleY;
Font *FontInst;
SDL_Color FontColor;
std::string LayoutKey;
std::string CollectionName;
std::string ImageType;
unsigned int MaxLayer;
std::string Collection;
Configuration *Config;
float ScaleX;
float ScaleY;
Font *FontInst;
SDL_Color FontColor;
std::string LayoutKey;
std::string CollectionName;
std::string ImageType;
unsigned int MaxLayer;
};

118
Source/Graphics/Component/Text.cpp
View File

@ -8,96 +8,96 @@
#include <sstream>
Text::Text(std::string text, Font *font, SDL_Color fontColor, float scaleX, float scaleY)
: TextData(text)
, FontInst(font)
, FontColor(fontColor)
, ScaleX(scaleX)
, ScaleY(scaleY)
: TextData(text)
, FontInst(font)
, FontColor(fontColor)
, ScaleX(scaleX)
, ScaleY(scaleY)
{
AllocateGraphicsMemory();
AllocateGraphicsMemory();
}
Text::~Text()
{
FreeGraphicsMemory();
FreeGraphicsMemory();
}
void Text::FreeGraphicsMemory()
{
Component::FreeGraphicsMemory();
Component::FreeGraphicsMemory();
}
void Text::AllocateGraphicsMemory()
{
//todo: make the font blend color a parameter that is passed in
Component::AllocateGraphicsMemory();
//todo: make the font blend color a parameter that is passed in
Component::AllocateGraphicsMemory();
}
void Text::Draw()
{
SDL_Texture *t = FontInst->GetTexture();
SDL_Texture *t = FontInst->GetTexture();
ViewInfo *info = GetBaseViewInfo();
float imageHeight = 0;
float imageWidth = 0;
ViewInfo *info = GetBaseViewInfo();
float imageHeight = 0;
float imageWidth = 0;
// determine image width
for(unsigned int i = 0; i < TextData.size(); ++i)
{
Font::GlyphInfo glyph;
if(FontInst->GetRect(TextData[i], glyph))
{
imageWidth += glyph.Advance;
imageHeight = (imageHeight >= glyph.Rect.h) ? imageHeight : glyph.Rect.h;
}
}
// determine image width
for(unsigned int i = 0; i < TextData.size(); ++i)
{
Font::GlyphInfo glyph;
if(FontInst->GetRect(TextData[i], glyph))
{
imageWidth += glyph.Advance;
imageHeight = (imageHeight >= glyph.Rect.h) ? imageHeight : glyph.Rect.h;
}
}
float scale = (float)info->GetFontSize() / (float)imageHeight;
float scale = (float)info->GetFontSize() / (float)imageHeight;
float width = info->GetRawWidth();
float height = info->GetRawHeight();
float width = info->GetRawWidth();
float height = info->GetRawHeight();
info->SetWidth(imageWidth*scale);
info->SetHeight(imageHeight*scale);
info->SetWidth(imageWidth*scale);
info->SetHeight(imageHeight*scale);
float xOrigin = info->GetXRelativeToOrigin();
float yOrigin = info->GetYRelativeToOrigin();
float xOrigin = info->GetXRelativeToOrigin();
float yOrigin = info->GetYRelativeToOrigin();
info->SetWidth(width);
info->SetHeight(height);
info->SetWidth(width);
info->SetHeight(height);
SDL_Rect rect;
rect.x = static_cast<int>(xOrigin);
SDL_Rect rect;
rect.x = static_cast<int>(xOrigin);
for(unsigned int i = 0; i < TextData.size(); ++i)
{
Font::GlyphInfo glyph;
for(unsigned int i = 0; i < TextData.size(); ++i)
{
Font::GlyphInfo glyph;
if(FontInst->GetRect(TextData[i], glyph) && glyph.Rect.h > 0)
{
SDL_Rect charRect = glyph.Rect;
float h = static_cast<float>(charRect.h * scale);
float w = static_cast<float>(charRect.w * scale);
rect.h = static_cast<int>(h);
rect.w = static_cast<int>(w);
rect.y = static_cast<int>(yOrigin);
/*
std::stringstream ss;
ss << " cx:" << charRect.x << " cy:" << charRect.y << " cw:" << charRect.w << " ch:" << charRect.h;
ss << " x:" << rect.x << " y:" << rect.y << " w:" << rect.w << " h:" << rect.h;
Logger::Write(Logger::ZONE_DEBUG, "Text", ss.str());
*/
if(FontInst->GetRect(TextData[i], glyph) && glyph.Rect.h > 0)
{
SDL_Rect charRect = glyph.Rect;
float h = static_cast<float>(charRect.h * scale);
float w = static_cast<float>(charRect.w * scale);
rect.h = static_cast<int>(h);
rect.w = static_cast<int>(w);
rect.y = static_cast<int>(yOrigin);
/*
std::stringstream ss;
ss << " cx:" << charRect.x << " cy:" << charRect.y << " cw:" << charRect.w << " ch:" << charRect.h;
ss << " x:" << rect.x << " y:" << rect.y << " w:" << rect.w << " h:" << rect.h;
Logger::Write(Logger::ZONE_DEBUG, "Text", ss.str());
*/
SDL_LockMutex(SDL::GetMutex());
SDL_SetTextureColorMod(t, FontColor.r, FontColor.g, FontColor.b);
SDL_UnlockMutex(SDL::GetMutex());
SDL_LockMutex(SDL::GetMutex());
SDL_SetTextureColorMod(t, FontColor.r, FontColor.g, FontColor.b);
SDL_UnlockMutex(SDL::GetMutex());
SDL::RenderCopy(t, static_cast<char>(info->GetTransparency() * 255), &charRect, &rect, info->GetAngle());
rect.x += static_cast<int>(glyph.Advance * scale);
}
}
SDL::RenderCopy(t, static_cast<char>(info->GetTransparency() * 255), &charRect, &rect, info->GetAngle());
rect.x += static_cast<int>(glyph.Advance * scale);
}
}
}

22
Source/Graphics/Component/Text.h
View File

@ -13,17 +13,17 @@ class Font;
class Text : public Component
{
public:
//todo: should have a Font flass that references fontcache, pass that in as an argument
Text(std::string text, Font *font, SDL_Color fontColor, float scaleX, float scaleY);
virtual ~Text();
void AllocateGraphicsMemory();
void FreeGraphicsMemory();
void Draw();
//todo: should have a Font flass that references fontcache, pass that in as an argument
Text(std::string text, Font *font, SDL_Color fontColor, float scaleX, float scaleY);
virtual ~Text();
void AllocateGraphicsMemory();
void FreeGraphicsMemory();
void Draw();
private:
std::string TextData;
Font *FontInst;
SDL_Color FontColor;
float ScaleX;
float ScaleY;
std::string TextData;
Font *FontInst;
SDL_Color FontColor;
float ScaleX;
float ScaleY;
};

34
Source/Graphics/Component/VideoBuilder.cpp
View File

@ -10,27 +10,27 @@
VideoComponent * VideoBuilder::CreateVideo(std::string path, std::string name, float scaleX, float scaleY)
{
VideoComponent *component = NULL;
std::vector<std::string> extensions;
VideoComponent *component = NULL;
std::vector<std::string> extensions;
extensions.push_back("mp4");
extensions.push_back("MP4");
extensions.push_back("avi");
extensions.push_back("AVI");
extensions.push_back("mp4");
extensions.push_back("MP4");
extensions.push_back("avi");
extensions.push_back("AVI");
std::string prefix = path + "/" + name;
std::string file;
std::string prefix = path + "/" + name;
std::string file;
if(Utils::FindMatchingFile(prefix, extensions, file))
{
IVideo *video = Factory.CreateVideo();
if(Utils::FindMatchingFile(prefix, extensions, file))
{
IVideo *video = Factory.CreateVideo();
if(video)
{
component = new VideoComponent(video, file, scaleX, scaleY);
}
}
if(video)
{
component = new VideoComponent(video, file, scaleX, scaleY);
}
}
return component;
return component;
}

4
Source/Graphics/Component/VideoBuilder.h
View File

@ -11,8 +11,8 @@
class VideoBuilder
{
public:
VideoComponent * CreateVideo(std::string path, std::string name, float scaleX, float scaleY);
VideoComponent * CreateVideo(std::string path, std::string name, float scaleX, float scaleY);
private:
VideoFactory Factory;
VideoFactory Factory;
};

84
Source/Graphics/Component/VideoComponent.cpp
View File

@ -8,77 +8,77 @@
#include "../../SDL.h"
VideoComponent::VideoComponent(IVideo *videoInst, std::string videoFile, float scaleX, float scaleY)
: VideoTexture(NULL)
, VideoFile(videoFile)
, VideoInst(videoInst)
, ScaleX(scaleX)
, ScaleY(scaleY)
, IsPlaying(false)
: VideoTexture(NULL)
, VideoFile(videoFile)
, VideoInst(videoInst)
, ScaleX(scaleX)
, ScaleY(scaleY)
, IsPlaying(false)
{
// AllocateGraphicsMemory();
}
VideoComponent::~VideoComponent()
{
FreeGraphicsMemory();
FreeGraphicsMemory();
if(VideoInst)
{
VideoInst->Stop();
}
if(VideoInst)
{
VideoInst->Stop();
}
}
void VideoComponent::Update(float dt)
{
if(IsPlaying)
{
VideoInst->Update(dt);
}
if(IsPlaying)
{
VideoInst->Update(dt);
}
Component::Update(dt);
Component::Update(dt);
}
void VideoComponent::AllocateGraphicsMemory()
{
Component::AllocateGraphicsMemory();
Component::AllocateGraphicsMemory();
if(!IsPlaying)
{
IsPlaying = VideoInst->Play(VideoFile);
}
if(!IsPlaying)
{
IsPlaying = VideoInst->Play(VideoFile);
}
}
void VideoComponent::FreeGraphicsMemory()
{
VideoInst->Stop();
IsPlaying = false;
VideoInst->Stop();
IsPlaying = false;
if (VideoTexture != NULL)
{
SDL_LockMutex(SDL::GetMutex());
SDL_DestroyTexture(VideoTexture);
SDL_UnlockMutex(SDL::GetMutex());
}
if (VideoTexture != NULL)
{
SDL_LockMutex(SDL::GetMutex());
SDL_DestroyTexture(VideoTexture);
SDL_UnlockMutex(SDL::GetMutex());
}
Component::FreeGraphicsMemory();
Component::FreeGraphicsMemory();
}
void VideoComponent::Draw()
{
ViewInfo *info = GetBaseViewInfo();
SDL_Rect rect;
ViewInfo *info = GetBaseViewInfo();
SDL_Rect rect;
rect.x = static_cast<int>(info->GetXRelativeToOrigin());
rect.y = static_cast<int>(info->GetYRelativeToOrigin());
rect.h = static_cast<int>(info->GetHeight());
rect.w = static_cast<int>(info->GetWidth());
rect.x = static_cast<int>(info->GetXRelativeToOrigin());
rect.y = static_cast<int>(info->GetYRelativeToOrigin());
rect.h = static_cast<int>(info->GetHeight());
rect.w = static_cast<int>(info->GetWidth());
VideoInst->Draw();
SDL_Texture *texture = VideoInst->GetTexture();
VideoInst->Draw();
SDL_Texture *texture = VideoInst->GetTexture();
if(texture)
{
SDL::RenderCopy(texture, static_cast<int>(info->GetTransparency() * 255), NULL, &rect, info->GetAngle());
}
if(texture)
{
SDL::RenderCopy(texture, static_cast<int>(info->GetTransparency() * 255), NULL, &rect, info->GetAngle());
}
}

36
Source/Graphics/Component/VideoComponent.h
View File

@ -12,21 +12,27 @@
class VideoComponent : public Component
{
public:
VideoComponent(IVideo *videoInst, std::string videoFile, float scaleX, float scaleY);
virtual ~VideoComponent();
void Update(float dt);
void Draw();
void FreeGraphicsMemory();
void AllocateGraphicsMemory();
void LaunchEnter() {FreeGraphicsMemory(); }
void LaunchExit() { AllocateGraphicsMemory(); }
VideoComponent(IVideo *videoInst, std::string videoFile, float scaleX, float scaleY);
virtual ~VideoComponent();
void Update(float dt);
void Draw();
void FreeGraphicsMemory();
void AllocateGraphicsMemory();
void LaunchEnter()
{
FreeGraphicsMemory();
}
void LaunchExit()
{
AllocateGraphicsMemory();
}
private:
SDL_Texture *VideoTexture;
std::string VideoFile;
std::string Name;
IVideo *VideoInst;
float ScaleX;
float ScaleY;
bool IsPlaying;
SDL_Texture *VideoTexture;
std::string VideoFile;
std::string Name;
IVideo *VideoInst;
float ScaleX;
float ScaleY;
bool IsPlaying;
};

18
Source/Graphics/ComponentItemBinding.cpp
View File

@ -1,17 +1,17 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#include "ComponentItemBinding.h"
ComponentItemBinding::ComponentItemBinding( Component *c, Item *item)
: CollectionComponent(c)
, CollectionItem(item)
: CollectionComponent(c)
, CollectionItem(item)
{
}
ComponentItemBinding::ComponentItemBinding(Item *item)
: CollectionComponent(NULL)
, CollectionItem(item)
: CollectionComponent(NULL)
, CollectionItem(item)
{
}
@ -21,15 +21,15 @@ ComponentItemBinding::~ComponentItemBinding()
Item* ComponentItemBinding::GetCollectionItem() const
{
return CollectionItem;
return CollectionItem;
}
void ComponentItemBinding::SetComponent(Component *c)
{
CollectionComponent = c;
CollectionComponent = c;
}
Component* ComponentItemBinding::GetComponent() const
{
return CollectionComponent;
return CollectionComponent;
}

20
Source/Graphics/ComponentItemBinding.h
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#pragma once
@ -9,15 +9,15 @@
class ComponentItemBinding
{
public:
ComponentItemBinding(Component *c, Item *item);
ComponentItemBinding(Item *item);
virtual ~ComponentItemBinding();
Item* GetCollectionItem() const;
ComponentItemBinding(Component *c, Item *item);
ComponentItemBinding(Item *item);
virtual ~ComponentItemBinding();
Item* GetCollectionItem() const;
void SetComponent(Component *c);
Component* GetComponent() const;
void SetComponent(Component *c);
Component* GetComponent() const;
private:
Component *CollectionComponent;
Item *CollectionItem;
Component *CollectionComponent;
Item *CollectionItem;
};

20
Source/Graphics/ComponentItemBindingBuilder.cpp
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#include "ComponentItemBindingBuilder.h"
#include "ComponentItemBinding.h"
@ -16,14 +16,14 @@ ComponentItemBindingBuilder::~ComponentItemBindingBuilder()
std::vector<ComponentItemBinding *> *ComponentItemBindingBuilder::BuildCollectionItems(std::vector<Item *> *infoList)
{
std::vector<ComponentItemBinding *> *sprites = new std::vector<ComponentItemBinding *>();
std::vector<Item *>::iterator it;
std::vector<ComponentItemBinding *> *sprites = new std::vector<ComponentItemBinding *>();
std::vector<Item *>::iterator it;
for(it = infoList->begin(); it != infoList->end(); ++it)
{
ComponentItemBinding *s = new ComponentItemBinding(*it);
sprites->push_back(s);
}
for(it = infoList->begin(); it != infoList->end(); ++it)
{
ComponentItemBinding *s = new ComponentItemBinding(*it);
sprites->push_back(s);
}
return sprites;
return sprites;
}

10
Source/Graphics/ComponentItemBindingBuilder.h
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#pragma once
@ -12,7 +12,7 @@ class ComponentItemBinding;
class ComponentItemBindingBuilder
{
public:
ComponentItemBindingBuilder();
virtual ~ComponentItemBindingBuilder();
static std::vector<ComponentItemBinding *> *BuildCollectionItems(std::vector<Item *> *infoList);
ComponentItemBindingBuilder();
virtual ~ComponentItemBindingBuilder();
static std::vector<ComponentItemBinding *> *BuildCollectionItems(std::vector<Item *> *infoList);
};

184
Source/Graphics/Font.cpp
View File

@ -1,6 +1,6 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
*/
#include "Font.h"
#include "../SDL.h"
#include "../Utility/Log.h"
@ -8,138 +8,138 @@
#include <SDL2/SDL_ttf.h>
Font::Font()
: Texture(NULL)
: Texture(NULL)
{
}
Font::~Font()
{
DeInitialize();
DeInitialize();
}
SDL_Texture *Font::GetTexture()
{
return Texture;
return Texture;
}
bool Font::GetRect(unsigned int charCode, GlyphInfo &glyph)
{
std::map<unsigned int, GlyphInfoBuild *>::iterator it = Atlas.find(charCode);
std::map<unsigned int, GlyphInfoBuild *>::iterator it = Atlas.find(charCode);
if(it != Atlas.end())
{
GlyphInfoBuild *info = it->second;
if(it != Atlas.end())
{
GlyphInfoBuild *info = it->second;
glyph = info->Glyph;
glyph = info->Glyph;
return true;
}
return true;
}
return false;
return false;
}
bool Font::Initialize(std::string fontPath, SDL_Color color)
{
TTF_Font *font = TTF_OpenFont(fontPath.c_str(), 128);
TTF_Font *font = TTF_OpenFont(fontPath.c_str(), 128);
if (!font)
{
Logger::Write(Logger::ZONE_ERROR, "FontCache", "TTF_OpenFont failed");
return false;
}
if (!font)
{
Logger::Write(Logger::ZONE_ERROR, "FontCache", "TTF_OpenFont failed");
return false;
}
int x = 0;
int y = 0;
int atlasHeight = 0;
int atlasWidth = 0;
int x = 0;
int y = 0;
int atlasHeight = 0;
int atlasWidth = 0;
for(unsigned short int i = 32; i < 128; ++i)
{
GlyphInfoBuild *info = new GlyphInfoBuild;
memset(info, sizeof(GlyphInfoBuild), 0);
for(unsigned short int i = 32; i < 128; ++i)
{
GlyphInfoBuild *info = new GlyphInfoBuild;
memset(info, sizeof(GlyphInfoBuild), 0);
info->Surface = TTF_RenderGlyph_Blended(font, i, color);
TTF_GlyphMetrics(font, i, &info->Glyph.MinX, &info->Glyph.MaxX, &info->Glyph.MinY, &info->Glyph.MaxY, &info->Glyph.Advance);
info->Surface = TTF_RenderGlyph_Blended(font, i, color);
TTF_GlyphMetrics(font, i, &info->Glyph.MinX, &info->Glyph.MaxX, &info->Glyph.MinY, &info->Glyph.MaxY, &info->Glyph.Advance);
if(x + info->Surface->w >= 1024)
{
atlasHeight += y;
atlasWidth = (atlasWidth >= x) ? atlasWidth : x;
x = 0;
y = 0;
}
if(x + info->Surface->w >= 1024)
{
atlasHeight += y;
atlasWidth = (atlasWidth >= x) ? atlasWidth : x;
x = 0;
y = 0;
}
info->Glyph.Rect.w = info->Surface->w;
info->Glyph.Rect.h = info->Surface->h;
info->Glyph.Rect.x = x;
info->Glyph.Rect.y = atlasHeight;
Atlas[i] = info;
info->Glyph.Rect.w = info->Surface->w;
info->Glyph.Rect.h = info->Surface->h;
info->Glyph.Rect.x = x;
info->Glyph.Rect.y = atlasHeight;
Atlas[i] = info;
x += info->Glyph.Rect.w;
y = (y > info->Glyph.Rect.h) ? y : info->Glyph.Rect.h;
/*
std::stringstream ss;
ss << " tw:" << atlasWidth << " th:" << atlasHeight << " x:" << x << " y:" << y << " w:" << info->Glyph.Rect.w << " h:" << info->Glyph.Rect.h;
Logger::Write(Logger::ZONE_ERROR, "FontCache", ss.str());
*/
}
x += info->Glyph.Rect.w;
y = (y > info->Glyph.Rect.h) ? y : info->Glyph.Rect.h;
/*
std::stringstream ss;
ss << " tw:" << atlasWidth << " th:" << atlasHeight << " x:" << x << " y:" << y << " w:" << info->Glyph.Rect.w << " h:" << info->Glyph.Rect.h;
Logger::Write(Logger::ZONE_ERROR, "FontCache", ss.str());
*/
}
atlasWidth = (atlasWidth >= x) ? atlasWidth : x;
atlasHeight += y;
atlasWidth = (atlasWidth >= x) ? atlasWidth : x;
atlasHeight += y;
unsigned int rmask;
unsigned int gmask;
unsigned int bmask;
unsigned int amask;
unsigned int rmask;
unsigned int gmask;
unsigned int bmask;
unsigned int amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
#else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
#endif
SDL_Surface *atlasSurface = SDL_CreateRGBSurface(0, atlasWidth, atlasHeight, 24, rmask, gmask, bmask, amask);
SDL_Surface *atlasSurface = SDL_CreateRGBSurface(0, atlasWidth, atlasHeight, 24, rmask, gmask, bmask, amask);
std::map<unsigned int, GlyphInfoBuild *>::iterator it;
for(it = Atlas.begin(); it != Atlas.end(); it++)
{
GlyphInfoBuild *info = it->second;
SDL_BlitSurface(info->Surface, NULL, atlasSurface, &info->Glyph.Rect);
SDL_FreeSurface(info->Surface);
info->Surface = NULL;
}
std::map<unsigned int, GlyphInfoBuild *>::iterator it;
for(it = Atlas.begin(); it != Atlas.end(); it++)
{
GlyphInfoBuild *info = it->second;
SDL_BlitSurface(info->Surface, NULL, atlasSurface, &info->Glyph.Rect);
SDL_FreeSurface(info->Surface);
info->Surface = NULL;
}
SDL_LockMutex(SDL::GetMutex());
SDL_SetColorKey(atlasSurface, SDL_TRUE, SDL_MapRGB(atlasSurface->format, 0, 0, 0));
Texture = SDL_CreateTextureFromSurface(SDL::GetRenderer(), atlasSurface);
SDL_FreeSurface(atlasSurface);
SDL_UnlockMutex(SDL::GetMutex());
SDL_LockMutex(SDL::GetMutex());
SDL_SetColorKey(atlasSurface, SDL_TRUE, SDL_MapRGB(atlasSurface->format, 0, 0, 0));
Texture = SDL_CreateTextureFromSurface(SDL::GetRenderer(), atlasSurface);
SDL_FreeSurface(atlasSurface);
SDL_UnlockMutex(SDL::GetMutex());
TTF_CloseFont(font);
TTF_CloseFont(font);
return true;
return true;
}
void Font::DeInitialize()
{
if(Texture)
{
SDL_LockMutex(SDL::GetMutex());
SDL_DestroyTexture(Texture);
Texture = NULL;
SDL_UnlockMutex(SDL::GetMutex());
}
if(Texture)
{
SDL_LockMutex(SDL::GetMutex());
SDL_DestroyTexture(Texture);
Texture = NULL;
SDL_UnlockMutex(SDL::GetMutex());
}
std::map<unsigned int, GlyphInfoBuild *>::iterator atlasIt = Atlas.begin();
while(atlasIt != Atlas.end())
{
delete atlasIt->second;
Atlas.erase(atlasIt);
atlasIt = Atlas.begin();
}
std::map<unsigned int, GlyphInfoBuild *>::iterator atlasIt = Atlas.begin();
while(atlasIt != Atlas.end())
{
delete atlasIt->second;
Atlas.erase(atlasIt);
atlasIt = Atlas.begin();
}
}

46
Source/Graphics/Font.h
View File

@ -1,6 +1,6 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
*/
#pragma once
#include <SDL2/SDL.h>
@ -10,33 +10,33 @@
class Font
{
public:
struct GlyphInfo
{
int MinX;
int MaxX;
int MinY;
int MaxY;
int Advance;
SDL_Rect Rect;
};
struct GlyphInfo
{
int MinX;
int MaxX;
int MinY;
int MaxY;
int Advance;
SDL_Rect Rect;
};
Font();
virtual ~Font();
bool Initialize(std::string fontPath, SDL_Color color);
void DeInitialize();
SDL_Texture *GetTexture();
bool GetRect(unsigned int charCode, GlyphInfo &glyph);
Font();
virtual ~Font();
bool Initialize(std::string fontPath, SDL_Color color);
void DeInitialize();
SDL_Texture *GetTexture();
bool GetRect(unsigned int charCode, GlyphInfo &glyph);
private:
struct GlyphInfoBuild
{
Font::GlyphInfo Glyph;
SDL_Surface *Surface;
};
struct GlyphInfoBuild
{
Font::GlyphInfo Glyph;
SDL_Surface *Surface;
};
std::map<unsigned int, GlyphInfoBuild *> Atlas;
SDL_Texture *Texture;
std::map<unsigned int, GlyphInfoBuild *> Atlas;
SDL_Texture *Texture;
};

64
Source/Graphics/FontCache.cpp
View File

@ -1,6 +1,6 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
*/
#include "FontCache.h"
#include "Font.h"
#include "../Utility/Log.h"
@ -10,63 +10,63 @@
//todo: memory leak when launching games
FontCache::FontCache()
: IsInitialized(false)
: IsInitialized(false)
{
}
FontCache::~FontCache()
{
DeInitialize();
DeInitialize();
}
void FontCache::DeInitialize()
{
IsInitialized = false;
std::map<std::string, Font *>::iterator it = FontFaceMap.begin();
while(it != FontFaceMap.end())
{
delete it->second;
FontFaceMap.erase(it);
it = FontFaceMap.begin();
}
IsInitialized = false;
std::map<std::string, Font *>::iterator it = FontFaceMap.begin();
while(it != FontFaceMap.end())
{
delete it->second;
FontFaceMap.erase(it);
it = FontFaceMap.begin();
}
SDL_LockMutex(SDL::GetMutex());
TTF_Quit();
SDL_UnlockMutex(SDL::GetMutex());
SDL_LockMutex(SDL::GetMutex());
TTF_Quit();
SDL_UnlockMutex(SDL::GetMutex());
}
void FontCache::Initialize()
{
//todo: make bool
TTF_Init();
IsInitialized = true;
//todo: make bool
TTF_Init();
IsInitialized = true;
}
Font *FontCache::GetFont(std::string fontPath)
{
Font *t = NULL;
Font *t = NULL;
std::map<std::string, Font *>::iterator it = FontFaceMap.find(fontPath);
std::map<std::string, Font *>::iterator it = FontFaceMap.find(fontPath);
if(it != FontFaceMap.end())
{
t = it->second;
}
if(it != FontFaceMap.end())
{
t = it->second;
}
return t;
return t;
}
bool FontCache::LoadFont(std::string fontPath, SDL_Color color)
{
std::map<std::string, Font *>::iterator it = FontFaceMap.find(fontPath);
std::map<std::string, Font *>::iterator it = FontFaceMap.find(fontPath);
if(it == FontFaceMap.end())
{
Font *f = new Font();
f->Initialize(fontPath, color);
FontFaceMap[fontPath] = f;
}
if(it == FontFaceMap.end())
{
Font *f = new Font();
f->Initialize(fontPath, color);
FontFaceMap[fontPath] = f;
}
return true;
return true;
}

18
Source/Graphics/FontCache.h
View File

@ -1,6 +1,6 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
*/
#pragma once
#include "Font.h"
@ -10,17 +10,17 @@
class FontCache
{
public:
void Initialize();
void DeInitialize();
FontCache();
bool LoadFont(std::string font, SDL_Color color);
Font *GetFont(std::string font);
void Initialize();
void DeInitialize();
FontCache();
bool LoadFont(std::string font, SDL_Color color);
Font *GetFont(std::string font);
virtual ~FontCache();
virtual ~FontCache();
private:
bool IsInitialized;
bool IsInitialized;
std::map<std::string, Font *> FontFaceMap;
std::map<std::string, Font *> FontFaceMap;
};

6
Source/Graphics/MenuNotifierInterface.h
View File

@ -1,6 +1,6 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
*/
#pragma once
#include "../Collection/Item.h"
@ -8,7 +8,7 @@
class MenuNotifierInterface
{
public:
virtual ~MenuNotifierInterface() {}
virtual void OnNewItemSelected(Item *) = 0;
virtual ~MenuNotifierInterface() {}
virtual void OnNewItemSelected(Item *) = 0;
};

508
Source/Graphics/Page.cpp
View File

@ -11,145 +11,145 @@
#include <sstream>
Page::Page(std::string collectionName)
: CollectionName(collectionName)
, Menu(NULL)
, Items(NULL)
, ScrollActive(false)
, SelectedItem(NULL)
, SelectedItemChanged(false)
, LoadSoundChunk(NULL)
, UnloadSoundChunk(NULL)
, HighlightSoundChunk(NULL)
, SelectSoundChunk(NULL)
, HasSoundedWhenActive(false)
, FirstSoundPlayed(false)
: CollectionName(collectionName)
, Menu(NULL)
, Items(NULL)
, ScrollActive(false)
, SelectedItem(NULL)
, SelectedItemChanged(false)
, LoadSoundChunk(NULL)
, UnloadSoundChunk(NULL)
, HighlightSoundChunk(NULL)
, SelectSoundChunk(NULL)
, HasSoundedWhenActive(false)
, FirstSoundPlayed(false)
{
}
Page::~Page()
{
if(Menu)
{
Menu->RemoveComponentForNotifications(this);
}
if(Menu)
{
Menu->RemoveComponentForNotifications(this);
}
for(unsigned int i = 0; i < sizeof(LayerComponents)/sizeof(LayerComponents[0]); ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
delete *it;
}
for(unsigned int i = 0; i < sizeof(LayerComponents)/sizeof(LayerComponents[0]); ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
delete *it;
}
LayerComponents[i].clear();
}
LayerComponents[i].clear();
}
if(Menu)
{
delete Menu;
}
if(Menu)
{
delete Menu;
}
if(LoadSoundChunk)
{
delete LoadSoundChunk;
LoadSoundChunk = NULL;
}
if(LoadSoundChunk)
{
delete LoadSoundChunk;
LoadSoundChunk = NULL;
}
if(UnloadSoundChunk)
{
delete UnloadSoundChunk;
UnloadSoundChunk = NULL;
}
if(UnloadSoundChunk)
{
delete UnloadSoundChunk;
UnloadSoundChunk = NULL;
}
if(HighlightSoundChunk)
{
delete HighlightSoundChunk;
HighlightSoundChunk = NULL;
}
if(HighlightSoundChunk)
{
delete HighlightSoundChunk;
HighlightSoundChunk = NULL;
}
if(SelectSoundChunk)
{
delete SelectSoundChunk;
SelectSoundChunk = NULL;
}
if(SelectSoundChunk)
{
delete SelectSoundChunk;
SelectSoundChunk = NULL;
}
}
void Page::OnNewItemSelected(Item *item)
{
SelectedItem = item;
SelectedItemChanged = true;
SelectedItem = item;
SelectedItemChanged = true;
}
void Page::SetMenu(ScrollingList *s)
{
// todo: delete the old menu
Menu = s;
// todo: delete the old menu
Menu = s;
if(Menu)
{
Menu->AddComponentForNotifications(this);
}
if(Menu)
{
Menu->AddComponentForNotifications(this);
}
}
bool Page::AddComponent(Component *c)
{
bool retVal = false;
bool retVal = false;
unsigned int layer = c->GetBaseViewInfo()->GetLayer();
unsigned int layer = c->GetBaseViewInfo()->GetLayer();
if(layer < NUM_LAYERS)
{
LayerComponents[layer].push_back(c);
if(layer < NUM_LAYERS)
{
LayerComponents[layer].push_back(c);
retVal = true;
}
else
{
std::stringstream ss;
ss << "Component layer too large Layer: " << layer;
Logger::Write(Logger::ZONE_ERROR, "Page", ss.str());
}
retVal = true;
}
else
{
std::stringstream ss;
ss << "Component layer too large Layer: " << layer;
Logger::Write(Logger::ZONE_ERROR, "Page", ss.str());
}
return retVal;
return retVal;
}
bool Page::IsIdle()
{
bool idle = true;
bool idle = true;
if(Menu != NULL && !Menu->IsIdle())
{
idle = false;
}
if(Menu != NULL && !Menu->IsIdle())
{
idle = false;
}
for(unsigned int i = 0; i < NUM_LAYERS && idle; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end() && idle; ++it)
{
idle = (*it)->IsIdle();
}
}
for(unsigned int i = 0; i < NUM_LAYERS && idle; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end() && idle; ++it)
{
idle = (*it)->IsIdle();
}
}
return idle;
return idle;
}
bool Page::IsHidden()
{
bool hidden = true;
bool hidden = true;
if(Menu != NULL)
{
hidden = Menu->IsHidden();
hidden = Menu->IsHidden();
}
for(unsigned int i = 0; hidden && i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); hidden && it != LayerComponents[i].end(); ++it)
{
hidden = (*it)->IsHidden();
}
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); hidden && it != LayerComponents[i].end(); ++it)
{
hidden = (*it)->IsHidden();
}
}
return hidden;
@ -157,250 +157,250 @@ bool Page::IsHidden()
void Page::Start()
{
Menu->TriggerEnterEvent();
Menu->TriggerEnterEvent();
if(LoadSoundChunk)
{
LoadSoundChunk->Play();
}
if(LoadSoundChunk)
{
LoadSoundChunk->Play();
}
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->TriggerEnterEvent();
}
}
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->TriggerEnterEvent();
}
}
}
void Page::Stop()
{
Menu->TriggerExitEvent();
Menu->TriggerExitEvent();
if(UnloadSoundChunk)
{
UnloadSoundChunk->Play();
}
if(UnloadSoundChunk)
{
UnloadSoundChunk->Play();
}
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->TriggerExitEvent();
}
}
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->TriggerExitEvent();
}
}
}
Item *Page::GetSelectedItem()
{
return SelectedItem;
return SelectedItem;
}
void Page::RemoveSelectedItem()
{
if(Menu)
{
//todo: change method to RemoveItem() and pass in SelectedItem
Menu->RemoveSelectedItem();
SelectedItem = NULL;
}
if(Menu)
{
//todo: change method to RemoveItem() and pass in SelectedItem
Menu->RemoveSelectedItem();
SelectedItem = NULL;
}
}
void Page::Highlight()
{
Item *item = SelectedItem;
Item *item = SelectedItem;
if(item)
{
if(Menu)
{
Menu->TriggerHighlightEvent(item);
Menu->SetScrollActive(ScrollActive);
}
if(item)
{
if(Menu)
{
Menu->TriggerHighlightEvent(item);
Menu->SetScrollActive(ScrollActive);
}
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->TriggerHighlightEvent(item);
(*it)->SetScrollActive(ScrollActive);
}
}
}
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->TriggerHighlightEvent(item);
(*it)->SetScrollActive(ScrollActive);
}
}
}
}
void Page::SetScrolling(ScrollDirection direction)
{
ScrollingList::ScrollDirection menuDirection;
ScrollingList::ScrollDirection menuDirection;
switch(direction)
{
case ScrollDirectionForward:
menuDirection = ScrollingList::ScrollDirectionForward;
ScrollActive = true;
break;
case ScrollDirectionBack:
menuDirection = ScrollingList::ScrollDirectionBack;
ScrollActive = true;
break;
case ScrollDirectionIdle:
default:
menuDirection = ScrollingList::ScrollDirectionIdle;
ScrollActive = false;
break;
}
if(Menu)
{
Menu->SetScrollDirection(menuDirection);
}
switch(direction)
{
case ScrollDirectionForward:
menuDirection = ScrollingList::ScrollDirectionForward;
ScrollActive = true;
break;
case ScrollDirectionBack:
menuDirection = ScrollingList::ScrollDirectionBack;
ScrollActive = true;
break;
case ScrollDirectionIdle:
default:
menuDirection = ScrollingList::ScrollDirectionIdle;
ScrollActive = false;
break;
}
if(Menu)
{
Menu->SetScrollDirection(menuDirection);
}
}
void Page::PageScroll(ScrollDirection direction)
{
if(Menu)
{
if(direction == ScrollDirectionForward)
{
Menu->PageDown();
}
if(direction == ScrollDirectionBack)
{
Menu->PageUp();
}
}
if(Menu)
{
if(direction == ScrollDirectionForward)
{
Menu->PageDown();
}
if(direction == ScrollDirectionBack)
{
Menu->PageUp();
}
}
}
void Page::SetItems(std::vector<Item *> *items)
{
std::vector<ComponentItemBinding *> *sprites = ComponentItemBindingBuilder::BuildCollectionItems(items);
std::vector<ComponentItemBinding *> *sprites = ComponentItemBindingBuilder::BuildCollectionItems(items);
if(Menu != NULL)
{
Menu->SetItems(sprites);
}
if(Menu != NULL)
{
Menu->SetItems(sprites);
}
}
void Page::Update(float dt)
{
if(Menu != NULL)
{
Menu->Update(dt);
}
if(SelectedItemChanged && !HasSoundedWhenActive && HighlightSoundChunk)
{
// skip the first sound being played (as it is part of the on-enter)
if(FirstSoundPlayed)
{
HighlightSoundChunk->Play();
HasSoundedWhenActive = true;
}
FirstSoundPlayed = true;
}
if(Menu != NULL)
{
Menu->Update(dt);
}
if(SelectedItemChanged && !HasSoundedWhenActive && HighlightSoundChunk)
{
// skip the first sound being played (as it is part of the on-enter)
if(FirstSoundPlayed)
{
HighlightSoundChunk->Play();
HasSoundedWhenActive = true;
}
FirstSoundPlayed = true;
}
if(SelectedItemChanged && !ScrollActive)
{
Highlight();
SelectedItemChanged = false;
HasSoundedWhenActive = false;
}
if(SelectedItemChanged && !ScrollActive)
{
Highlight();
SelectedItemChanged = false;
HasSoundedWhenActive = false;
}
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->Update(dt);
}
}
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->Update(dt);
}
}
}
void Page::Draw()
{
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->Draw();
}
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->Draw();
}
Menu->Draw(i);
}
Menu->Draw(i);
}
}
const std::string& Page::GetCollectionName() const
{
return CollectionName;
return CollectionName;
}
void Page::FreeGraphicsMemory()
{
Logger::Write(Logger::ZONE_DEBUG, "Page", "Free");
Menu->FreeGraphicsMemory();
Logger::Write(Logger::ZONE_DEBUG, "Page", "Free");
Menu->FreeGraphicsMemory();
if(LoadSoundChunk) LoadSoundChunk->Free();
if(UnloadSoundChunk) UnloadSoundChunk->Free();
if(HighlightSoundChunk) HighlightSoundChunk->Free();
if(SelectSoundChunk) SelectSoundChunk->Free();
if(LoadSoundChunk) LoadSoundChunk->Free();
if(UnloadSoundChunk) UnloadSoundChunk->Free();
if(HighlightSoundChunk) HighlightSoundChunk->Free();
if(SelectSoundChunk) SelectSoundChunk->Free();
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->FreeGraphicsMemory();
}
}
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->FreeGraphicsMemory();
}
}
}
void Page::AllocateGraphicsMemory()
{
FirstSoundPlayed = false;
Logger::Write(Logger::ZONE_DEBUG, "Page", "Allocating graphics memory");
Menu->AllocateGraphicsMemory();
FirstSoundPlayed = false;
Logger::Write(Logger::ZONE_DEBUG, "Page", "Allocating graphics memory");
Menu->AllocateGraphicsMemory();
if(LoadSoundChunk) LoadSoundChunk->Allocate();
if(UnloadSoundChunk) UnloadSoundChunk->Allocate();
if(HighlightSoundChunk) HighlightSoundChunk->Allocate();
if(SelectSoundChunk) SelectSoundChunk->Allocate();
if(LoadSoundChunk) LoadSoundChunk->Allocate();
if(UnloadSoundChunk) UnloadSoundChunk->Allocate();
if(HighlightSoundChunk) HighlightSoundChunk->Allocate();
if(SelectSoundChunk) SelectSoundChunk->Allocate();
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->AllocateGraphicsMemory();
}
}
Logger::Write(Logger::ZONE_DEBUG, "Page", "Allocate graphics memory complete");
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->AllocateGraphicsMemory();
}
}
Logger::Write(Logger::ZONE_DEBUG, "Page", "Allocate graphics memory complete");
}
void Page::LaunchEnter()
{
Menu->LaunchEnter();
Menu->LaunchEnter();
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->LaunchEnter();
}
}
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->LaunchEnter();
}
}
}
void Page::LaunchExit()
{
Menu->LaunchExit();
Menu->LaunchExit();
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->LaunchExit();
}
}
for(unsigned int i = 0; i < NUM_LAYERS; ++i)
{
for(std::vector<Component *>::iterator it = LayerComponents[i].begin(); it != LayerComponents[i].end(); ++it)
{
(*it)->LaunchExit();
}
}
}

106
Source/Graphics/Page.h
View File

@ -16,56 +16,68 @@ class Sound;
class Page : public MenuNotifierInterface
{
public:
enum ScrollDirection
{
ScrollDirectionForward,
ScrollDirectionBack,
ScrollDirectionIdle
enum ScrollDirection
{
ScrollDirectionForward,
ScrollDirectionBack,
ScrollDirectionIdle
};
};
Page(std::string collectionName);
virtual ~Page();
virtual void OnNewItemSelected(Item *);
void SetItems(std::vector<Item *> *items);
void SetMenu(ScrollingList *s);
void SetLoadSound(Sound *chunk) { LoadSoundChunk = chunk; }
void SetUnloadSound(Sound *chunk) { UnloadSoundChunk = chunk; }
void SetHighlightSound(Sound *chunk) { HighlightSoundChunk = chunk; }
void SetSelectSound(Sound *chunk) { SelectSoundChunk = chunk; }
bool AddComponent(Component *c);
void PageScroll(ScrollDirection direction);
void Start();
void Stop();
void SetScrolling(ScrollDirection direction);
Item *GetSelectedItem();
Item *GetPendingSelectedItem();
void RemoveSelectedItem();
bool IsIdle();
bool IsHidden();
void Update(float dt);
void Draw();
void FreeGraphicsMemory();
void AllocateGraphicsMemory();
void LaunchEnter();
void LaunchExit();
const std::string& GetCollectionName() const;
Page(std::string collectionName);
virtual ~Page();
virtual void OnNewItemSelected(Item *);
void SetItems(std::vector<Item *> *items);
void SetMenu(ScrollingList *s);
void SetLoadSound(Sound *chunk)
{
LoadSoundChunk = chunk;
}
void SetUnloadSound(Sound *chunk)
{
UnloadSoundChunk = chunk;
}
void SetHighlightSound(Sound *chunk)
{
HighlightSoundChunk = chunk;
}
void SetSelectSound(Sound *chunk)
{
SelectSoundChunk = chunk;
}
bool AddComponent(Component *c);
void PageScroll(ScrollDirection direction);
void Start();
void Stop();
void SetScrolling(ScrollDirection direction);
Item *GetSelectedItem();
Item *GetPendingSelectedItem();
void RemoveSelectedItem();
bool IsIdle();
bool IsHidden();
void Update(float dt);
void Draw();
void FreeGraphicsMemory();
void AllocateGraphicsMemory();
void LaunchEnter();
void LaunchExit();
const std::string& GetCollectionName() const;
private:
void Highlight();
std::string CollectionName;
ScrollingList *Menu;
static const unsigned int NUM_LAYERS = 8;
std::vector<Component *> LayerComponents[NUM_LAYERS];
std::vector<Item *> *Items;
bool ScrollActive;
Item *SelectedItem;
bool SelectedItemChanged;
Sound *LoadSoundChunk;
Sound *UnloadSoundChunk;
Sound *HighlightSoundChunk;
Sound *SelectSoundChunk;
bool HasSoundedWhenActive;
bool FirstSoundPlayed;
void Highlight();
std::string CollectionName;
ScrollingList *Menu;
static const unsigned int NUM_LAYERS = 8;
std::vector<Component *> LayerComponents[NUM_LAYERS];
std::vector<Item *> *Items;
bool ScrollActive;
Item *SelectedItem;
bool SelectedItemChanged;
Sound *LoadSoundChunk;
Sound *UnloadSoundChunk;
Sound *HighlightSoundChunk;
Sound *SelectSoundChunk;
bool HasSoundedWhenActive;
bool FirstSoundPlayed;
};

994
Source/Graphics/PageBuilder.cpp
View File

File diff suppressed because it is too large Load Diff

62
Source/Graphics/PageBuilder.h
View File

@ -18,42 +18,42 @@ class Configuration;
class PageBuilder
{
public:
PageBuilder(std::string layoutKey, std::string collection, Configuration *c, FontCache *fc);
virtual ~PageBuilder();
Page *BuildPage();
PageBuilder(std::string layoutKey, std::string collection, Configuration *c, FontCache *fc);
virtual ~PageBuilder();
Page *BuildPage();
private:
std::string LayoutKey;
std::string LayoutPath;
std::string Collection;
Configuration *Config;
float ScaleX;
float ScaleY;
int ScreenHeight;
int ScreenWidth;
SDL_Color FontColor;
std::string Font;
FontCache *FC; //todo: don't need Font itself, just need cache instances
void LoadReloadableImages(rapidxml::xml_node<> *layout, std::string tagName, Page *page);
std::string LayoutKey;
std::string LayoutPath;
std::string Collection;
Configuration *Config;
float ScaleX;
float ScaleY;
int ScreenHeight;
int ScreenWidth;
SDL_Color FontColor;
std::string Font;
FontCache *FC; //todo: don't need Font itself, just need cache instances
void LoadReloadableImages(rapidxml::xml_node<> *layout, std::string tagName, Page *page);
float GetVerticalAlignment(rapidxml::xml_attribute<> *attribute, float valueIfNull);
float GetHorizontalAlignment(rapidxml::xml_attribute<> *attribute, float valueIfNull);
void BuildViewInfo(rapidxml::xml_node<> *componentXml, ViewInfo *info);
bool BuildComponents(rapidxml::xml_node<> *layout, Page *page);
void LoadTweens(Component *c, rapidxml::xml_node<> *componentXml);
ScrollingList * BuildCustomMenu(rapidxml::xml_node<> *menuXml);
rapidxml::xml_attribute<> *FindRecursiveAttribute(rapidxml::xml_node<> *componentXml, std::string attribute);
float GetVerticalAlignment(rapidxml::xml_attribute<> *attribute, float valueIfNull);
float GetHorizontalAlignment(rapidxml::xml_attribute<> *attribute, float valueIfNull);
void BuildViewInfo(rapidxml::xml_node<> *componentXml, ViewInfo *info);
bool BuildComponents(rapidxml::xml_node<> *layout, Page *page);
void LoadTweens(Component *c, rapidxml::xml_node<> *componentXml);
ScrollingList * BuildCustomMenu(rapidxml::xml_node<> *menuXml);
rapidxml::xml_attribute<> *FindRecursiveAttribute(rapidxml::xml_node<> *componentXml, std::string attribute);
void GetTweenSets(rapidxml::xml_node<> *node, std::vector<std::vector<Tween *> *> *tweenSets);
void GetTweenSet(rapidxml::xml_node<> *node, std::vector<Tween *> &tweens);
void GetTweenSets(rapidxml::xml_node<> *node, std::vector<std::vector<Tween *> *> *tweenSets);
void GetTweenSet(rapidxml::xml_node<> *node, std::vector<Tween *> &tweens);
void LoadLayoutXml();
void LoadAnimations(std::string keyPrefix, Component &component, ViewInfo *defaults);
std::vector<ViewInfo *> *BuildTweenPoints(std::string iteratorPrefix, ViewInfo *defaults);
Component * LoadComponent(std::string keyPrefix);
ScrollingList * LoadMenu();
void LoadLayoutXml();
void LoadAnimations(std::string keyPrefix, Component &component, ViewInfo *defaults);
std::vector<ViewInfo *> *BuildTweenPoints(std::string iteratorPrefix, ViewInfo *defaults);
Component * LoadComponent(std::string keyPrefix);
ScrollingList * LoadMenu();
void LoadListItems(std::string keyPrefix, std::vector<ViewInfo *> *tweenPointList, ViewInfo *defaults, int &selectedItemIndex);
void UpdateViewInfoFromTag(std::string keyPrefix, ViewInfo *p, ViewInfo *defaults);
void LoadListItems(std::string keyPrefix, std::vector<ViewInfo *> *tweenPointList, ViewInfo *defaults, int &selectedItemIndex);
void UpdateViewInfoFromTag(std::string keyPrefix, ViewInfo *p, ViewInfo *defaults);
};

214
Source/Graphics/ViewInfo.cpp
View File

@ -7,24 +7,24 @@
#include <cfloat>
ViewInfo::ViewInfo()
: X(0)
, Y(0)
, XOrigin(0)
, YOrigin(0)
, XOffset(0)
, YOffset(0)
, Width(-1)
, MinWidth(0)
, MaxWidth(FLT_MAX)
, Height(-1)
, MinHeight(0)
, MaxHeight(FLT_MAX)
, ImageWidth(0)
, ImageHeight(0)
, FontSize(-1)
, Angle(0)
, Transparency(1)
, Layer(0)
: X(0)
, Y(0)
, XOrigin(0)
, YOrigin(0)
, XOffset(0)
, YOffset(0)
, Width(-1)
, MinWidth(0)
, MaxWidth(FLT_MAX)
, Height(-1)
, MinHeight(0)
, MaxHeight(FLT_MAX)
, ImageWidth(0)
, ImageHeight(0)
, FontSize(-1)
, Angle(0)
, Transparency(1)
, Layer(0)
{
}
@ -35,266 +35,266 @@ ViewInfo::~ViewInfo()
float ViewInfo::GetXRelativeToOrigin() const
{
return X + XOffset - XOrigin*GetWidth();
return X + XOffset - XOrigin*GetWidth();
}
float ViewInfo::GetYRelativeToOrigin() const
{
return Y + YOffset - YOrigin*GetHeight();
return Y + YOffset - YOrigin*GetHeight();
}
float ViewInfo::GetHeight() const
{
float value = Height;
float value = Height;
if(Height == -1 && Width == -1)
{
value = ImageHeight;
}
else
{
if (Height == -1 && ImageWidth != 0)
{
value = ImageHeight * Width / ImageWidth;
}
if(Height == -1 && Width == -1)
{
value = ImageHeight;
}
else
{
if (Height == -1 && ImageWidth != 0)
{
value = ImageHeight * Width / ImageWidth;
}
if (value < MinHeight)
{
value = MinHeight;
}
else if (value > MaxHeight)
{
value = MaxHeight;
}
}
if (value < MinHeight)
{
value = MinHeight;
}
else if (value > MaxHeight)
{
value = MaxHeight;
}
}
return value;
return value;
}
float ViewInfo::GetWidth() const
{
float value = Width;
float value = Width;
if(Height == -1 && Width == -1)
{
value = ImageWidth;
}
else
{
if (Width == -1 && ImageHeight != 0)
{
value = ImageWidth * Height / ImageHeight;
}
if (value < MinWidth)
{
value = MinWidth;
}
else if (value > MaxWidth)
{
value = MaxWidth;
}
}
if(Height == -1 && Width == -1)
{
value = ImageWidth;
}
else
{
if (Width == -1 && ImageHeight != 0)
{
value = ImageWidth * Height / ImageHeight;
}
if (value < MinWidth)
{
value = MinWidth;
}
else if (value > MaxWidth)
{
value = MaxWidth;
}
}
return value;
return value;
}
float ViewInfo::GetXOffset() const
{
return XOffset;
return XOffset;
}
float ViewInfo::GetXOrigin() const
{
return XOrigin;
return XOrigin;
}
float ViewInfo::GetYOffset() const
{
return YOffset;
return YOffset;
}
float ViewInfo::GetYOrigin() const
{
return YOrigin;
return YOrigin;
}
float ViewInfo::GetAngle() const
{
return Angle;
return Angle;
}
void ViewInfo::SetAngle(float angle)
{
Angle = angle;
Angle = angle;
}
float ViewInfo::GetImageHeight() const
{
return ImageHeight;
return ImageHeight;
}
void ViewInfo::SetImageHeight(float imageheight)
{
ImageHeight = imageheight;
ImageHeight = imageheight;
}
float ViewInfo::GetImageWidth() const
{
return ImageWidth;
return ImageWidth;
}
void ViewInfo::SetImageWidth(float imagewidth)
{
ImageWidth = imagewidth;
ImageWidth = imagewidth;
}
unsigned int ViewInfo::GetLayer() const
{
return Layer;
return Layer;
}
void ViewInfo::SetLayer(unsigned int layer)
{
Layer = layer;
Layer = layer;
}
float ViewInfo::GetMaxHeight() const
{
return MaxHeight;
return MaxHeight;
}
void ViewInfo::SetMaxHeight(float maxheight)
{
MaxHeight = maxheight;
MaxHeight = maxheight;
}
float ViewInfo::GetMaxWidth() const
{
return MaxWidth;
return MaxWidth;
}
void ViewInfo::SetMaxWidth(float maxwidth)
{
MaxWidth = maxwidth;
MaxWidth = maxwidth;
}
float ViewInfo::GetMinHeight() const
{
return MinHeight;
return MinHeight;
}
void ViewInfo::SetMinHeight(float minheight)
{
MinHeight = minheight;
MinHeight = minheight;
}
float ViewInfo::GetMinWidth() const
{
return MinWidth;
return MinWidth;
}
void ViewInfo::SetMinWidth(float minwidth)
{
MinWidth = minwidth;
MinWidth = minwidth;
}
float ViewInfo::GetTransparency() const
{
return Transparency;
return Transparency;
}
void ViewInfo::SetTransparency(float transparency)
{
Transparency = transparency;
Transparency = transparency;
}
float ViewInfo::GetX() const
{
return X;
return X;
}
void ViewInfo::SetX(float x)
{
X = x;
X = x;
}
void ViewInfo::SetXOffset(float offset)
{
XOffset = offset;
XOffset = offset;
}
void ViewInfo::SetXOrigin(float origin)
{
XOrigin = origin;
XOrigin = origin;
}
float ViewInfo::GetY() const
{
return Y;
return Y;
}
void ViewInfo::SetY(float y)
{
Y = y;
Y = y;
}
void ViewInfo::SetYOffset(float offset)
{
YOffset = offset;
YOffset = offset;
}
void ViewInfo::SetYOrigin(float origin)
{
YOrigin = origin;
YOrigin = origin;
}
float ViewInfo::GetRawYOrigin()
{
return YOrigin;
return YOrigin;
}
float ViewInfo::GetRawXOrigin()
{
return XOrigin;
return XOrigin;
}
float ViewInfo::GetRawWidth()
{
return Width;
return Width;
}
float ViewInfo::GetRawHeight()
{
return Height;
return Height;
}
void ViewInfo::SetHeight(float height)
{
Height = height;
Height = height;
}
void ViewInfo::SetWidth(float width)
{
Width = width;
Width = width;
}
float ViewInfo::GetFontSize() const
{
if(FontSize == -1)
{
return GetHeight();
}
else
{
return FontSize;
}
if(FontSize == -1)
{
return GetHeight();
}
else
{
return FontSize;
}
}
void ViewInfo::SetFontSize(float fontSize)
{
FontSize = fontSize;
FontSize = fontSize;
}

138
Source/Graphics/ViewInfo.h
View File

@ -11,79 +11,79 @@ class ViewInfo
{
public:
ViewInfo();
virtual ~ViewInfo();
ViewInfo();
virtual ~ViewInfo();
float GetXRelativeToOrigin() const;
float GetYRelativeToOrigin() const;
float GetXRelativeToOrigin() const;
float GetYRelativeToOrigin() const;
float GetHeight() const;
float GetWidth() const;
float GetAngle() const;
void SetAngle(float angle);
float GetImageHeight() const;
void SetImageHeight(float imageheight);
float GetImageWidth() const;
void SetImageWidth(float imagewidth);
unsigned int GetLayer() const;
void SetLayer(unsigned int layer);
float GetMaxHeight() const;
void SetMaxHeight(float maxheight);
float GetMaxWidth() const;
void SetMaxWidth(float maxwidth);
float GetMinHeight() const;
void SetMinHeight(float minheight);
float GetMinWidth() const;
void SetMinWidth(float minwidth);
float GetTransparency() const;
void SetTransparency(float transparency);
float GetX() const;
void SetX(float x);
float GetXOffset() const;
void SetXOffset(float offset);
float GetXOrigin() const;
void SetXOrigin(float origin);
float GetY() const;
void SetY(float y);
float GetYOffset() const;
void SetYOffset(float offset);
float GetYOrigin() const;
void SetYOrigin(float origin);
float GetRawYOrigin();
float GetRawXOrigin();
float GetRawWidth();
float GetRawHeight();
float GetHeight() const;
float GetWidth() const;
float GetAngle() const;
void SetAngle(float angle);
float GetImageHeight() const;
void SetImageHeight(float imageheight);
float GetImageWidth() const;
void SetImageWidth(float imagewidth);
unsigned int GetLayer() const;
void SetLayer(unsigned int layer);
float GetMaxHeight() const;
void SetMaxHeight(float maxheight);
float GetMaxWidth() const;
void SetMaxWidth(float maxwidth);
float GetMinHeight() const;
void SetMinHeight(float minheight);
float GetMinWidth() const;
void SetMinWidth(float minwidth);
float GetTransparency() const;
void SetTransparency(float transparency);
float GetX() const;
void SetX(float x);
float GetXOffset() const;
void SetXOffset(float offset);
float GetXOrigin() const;
void SetXOrigin(float origin);
float GetY() const;
void SetY(float y);
float GetYOffset() const;
void SetYOffset(float offset);
float GetYOrigin() const;
void SetYOrigin(float origin);
float GetRawYOrigin();
float GetRawXOrigin();
float GetRawWidth();
float GetRawHeight();
void SetHeight(float height);
void SetWidth(float width);
float GetFontSize() const;
void SetFontSize(float fontSize);
void SetHeight(float height);
void SetWidth(float width);
float GetFontSize() const;
void SetFontSize(float fontSize);
static const int AlignCenter = -1;
static const int AlignLeft = -2;
static const int AlignTop = -3;
static const int AlignRight = -4;
static const int AlignBottom = -5;
static const int AlignCenter = -1;
static const int AlignLeft = -2;
static const int AlignTop = -3;
static const int AlignRight = -4;
static const int AlignBottom = -5;
private:
float X;
float Y;
float XOrigin;
float YOrigin;
float XOffset;
float YOffset;
float Width;
float MinWidth;
float MaxWidth;
float Height;
float MinHeight;
float MaxHeight;
float ImageWidth;
float ImageHeight;
float FontSize;
float Angle;
float Transparency;
unsigned int Layer;
float HorizontalScale;
float VerticalScale;
float X;
float Y;
float XOrigin;
float YOrigin;
float XOffset;
float YOffset;
float Width;
float MinWidth;
float MaxWidth;
float Height;
float MinHeight;
float MaxHeight;
float ImageWidth;
float ImageHeight;
float FontSize;
float Angle;
float Transparency;
unsigned int Layer;
float HorizontalScale;
float VerticalScale;
};

254
Source/Main.cpp
View File

@ -22,171 +22,173 @@ CollectionDatabase *InitializeCollectionDatabase(DB &db, Configuration &config);
int main(int argc, char *argv[])
{
Configuration::Initialize();
Configuration::Initialize();
Configuration config;
Configuration config;
if(!StartLogging()) {
return -1;
}
if(!StartLogging())
{
return -1;
}
if(!ImportConfiguration(&config))
{
return -1;
}
if(!ImportConfiguration(&config))
{
return -1;
}
DB db(Configuration::GetAbsolutePath() + "/cache.db");
DB db(Configuration::GetAbsolutePath() + "/cache.db");
if(!db.Initialize())
{
return -1;
}
if(!db.Initialize())
{
return -1;
}
CollectionDatabase *cdb = InitializeCollectionDatabase(db, config);
if(!cdb) {
return -1;
}
RetroFE p(cdb, &config);
CollectionDatabase *cdb = InitializeCollectionDatabase(db, config);
if(!cdb)
{
return -1;
}
if(p.Initialize())
{
p.Run();
}
RetroFE p(cdb, &config);
p.DeInitialize();
if(p.Initialize())
{
p.Run();
}
Logger::DeInitialize();
p.DeInitialize();
return 0;
Logger::DeInitialize();
return 0;
}
bool ImportConfiguration(Configuration *c)
{
std::string configPath = Configuration::GetAbsolutePath();
std::string launchersPath = Configuration::GetAbsolutePath() + "/Launchers";
std::string collectionsPath = Configuration::GetAbsolutePath() + "/Collections";
DIR *dp;
struct dirent *dirp;
std::string configPath = Configuration::GetAbsolutePath();
std::string launchersPath = Configuration::GetAbsolutePath() + "/Launchers";
std::string collectionsPath = Configuration::GetAbsolutePath() + "/Collections";
DIR *dp;
struct dirent *dirp;
if(!c->Import("", configPath + "/Settings.conf"))
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not import \"" + configPath + "/Settings.conf\"");
return false;
}
if(!c->Import("", configPath + "/Settings.conf"))
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not import \"" + configPath + "/Settings.conf\"");
return false;
}
if(!c->Import("controls", configPath + "/Controls.conf"))
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not import \"" + configPath + "/Settings.conf\"");
return false;
}
if(!c->Import("controls", configPath + "/Controls.conf"))
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not import \"" + configPath + "/Settings.conf\"");
return false;
}
dp = opendir(launchersPath.c_str());
dp = opendir(launchersPath.c_str());
if(dp == NULL)
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not read directory \"" + launchersPath + "\"");
return false;
}
if(dp == NULL)
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not read directory \"" + launchersPath + "\"");
return false;
}
while((dirp = readdir(dp)) != NULL)
{
if (dirp->d_type != DT_DIR && std::string(dirp->d_name) != "." && std::string(dirp->d_name) != "..")
{
std::string basename = dirp->d_name;
// if(basename.length() > 0)
{
std::string extension = basename.substr(basename.find_last_of("."), basename.size()-1);
basename = basename.substr(0, basename.find_last_of("."));
if(extension == ".conf")
{
std::string prefix = "launchers." + basename;
std::string importFile = launchersPath + "/" + std::string(dirp->d_name);
if(!c->Import(prefix, importFile))
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not import \"" + importFile + "\"");
return false;
}
}
}
}
}
dp = opendir(collectionsPath.c_str());
if(dp == NULL)
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not read directory \"" + collectionsPath + "\"");
return false;
}
while((dirp = readdir(dp)) != NULL)
{
if (dirp->d_type == DT_DIR && std::string(dirp->d_name) != "." && std::string(dirp->d_name) != "..")
{
std::string prefix = "collections." + std::string(dirp->d_name);
std::string settingsFile = collectionsPath + "/" + dirp->d_name + "/Settings.conf";
if(!c->Import(prefix, settingsFile))
while((dirp = readdir(dp)) != NULL)
{
if (dirp->d_type != DT_DIR && std::string(dirp->d_name) != "." && std::string(dirp->d_name) != "..")
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not import \"" + settingsFile + "\"");
return false;
std::string basename = dirp->d_name;
// if(basename.length() > 0)
{
std::string extension = basename.substr(basename.find_last_of("."), basename.size()-1);
basename = basename.substr(0, basename.find_last_of("."));
if(extension == ".conf")
{
std::string prefix = "launchers." + basename;
std::string importFile = launchersPath + "/" + std::string(dirp->d_name);
if(!c->Import(prefix, importFile))
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not import \"" + importFile + "\"");
return false;
}
}
}
}
}
}
}
Logger::Write(Logger::ZONE_INFO, "RetroFE", "Imported configuration");
dp = opendir(collectionsPath.c_str());
return true;
if(dp == NULL)
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not read directory \"" + collectionsPath + "\"");
return false;
}
while((dirp = readdir(dp)) != NULL)
{
if (dirp->d_type == DT_DIR && std::string(dirp->d_name) != "." && std::string(dirp->d_name) != "..")
{
std::string prefix = "collections." + std::string(dirp->d_name);
std::string settingsFile = collectionsPath + "/" + dirp->d_name + "/Settings.conf";
if(!c->Import(prefix, settingsFile))
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not import \"" + settingsFile + "\"");
return false;
}
}
}
Logger::Write(Logger::ZONE_INFO, "RetroFE", "Imported configuration");
return true;
}
bool StartLogging()
bool StartLogging()
{
std::string logFile = Configuration::GetAbsolutePath() + "/Log.txt";
std::string logFile = Configuration::GetAbsolutePath() + "/Log.txt";
if(!Logger::Initialize(logFile))
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not open \"" + logFile + "\" for writing");
return false;
}
if(!Logger::Initialize(logFile))
{
Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not open \"" + logFile + "\" for writing");
return false;
}
Logger::Write(Logger::ZONE_INFO, "RetroFE", "Version " + Version::GetString() + " starting");
Logger::Write(Logger::ZONE_INFO, "RetroFE", "Version " + Version::GetString() + " starting");
#ifdef WIN32
Logger::Write(Logger::ZONE_INFO, "RetroFE", "OS: Windows");
Logger::Write(Logger::ZONE_INFO, "RetroFE", "OS: Windows");
#else
Logger::Write(Logger::ZONE_INFO, "RetroFE", "OS: Linux");
Logger::Write(Logger::ZONE_INFO, "RetroFE", "OS: Linux");
#endif
Logger::Write(Logger::ZONE_INFO, "RetroFE", "Absolute path: " + Configuration::GetAbsolutePath());
Logger::Write(Logger::ZONE_INFO, "RetroFE", "Absolute path: " + Configuration::GetAbsolutePath());
return true;
return true;
}
CollectionDatabase *InitializeCollectionDatabase(DB &db, Configuration &config)
CollectionDatabase *InitializeCollectionDatabase(DB &db, Configuration &config)
{
CollectionDatabase *cdb = NULL;
std::string dbFile = (Configuration::GetAbsolutePath() + "/cache.db");
std::ifstream infile(dbFile.c_str());
CollectionDatabase *cdb = NULL;
std::string dbFile = (Configuration::GetAbsolutePath() + "/cache.db");
std::ifstream infile(dbFile.c_str());
cdb = new CollectionDatabase(&db, &config);
cdb = new CollectionDatabase(&db, &config);
if(!cdb->Initialize())
{
delete cdb;
cdb = NULL;
}
else if(!cdb->Import())
{
delete cdb;
cdb = NULL;
}
if(!cdb->Initialize())
{
delete cdb;
cdb = NULL;
}
else if(!cdb->Import())
{
delete cdb;
cdb = NULL;
}
return cdb;
return cdb;
}

686
Source/RetroFE.cpp
View File

@ -26,474 +26,474 @@
Page *page = NULL;
RetroFE::RetroFE(CollectionDatabase *db, Configuration *c)
: Config(c)
, CollectionDB(db)
, Input(Config)
, KeyInputDisable(0)
, InactiveKeyTime(0)
, AttractMode(false)
, CurrentTime(0)
, VideoInst(NULL)
: Config(c)
, CollectionDB(db)
, Input(Config)
, KeyInputDisable(0)
, InactiveKeyTime(0)
, AttractMode(false)
, CurrentTime(0)
, VideoInst(NULL)
{
}
RetroFE::~RetroFE()
{
DeInitialize();
DeInitialize();
}
void RetroFE::Render()
{
SDL_LockMutex(SDL::GetMutex());
SDL_SetRenderDrawColor(SDL::GetRenderer(), 0x0, 0x0, 0x00, 0xFF);
SDL_RenderClear(SDL::GetRenderer());
SDL_LockMutex(SDL::GetMutex());
SDL_SetRenderDrawColor(SDL::GetRenderer(), 0x0, 0x0, 0x00, 0xFF);
SDL_RenderClear(SDL::GetRenderer());
Page *page = PageChain.back();
Page *page = PageChain.back();
if(page)
{
page->Draw();
}
if(page)
{
page->Draw();
}
SDL_RenderPresent(SDL::GetRenderer());
SDL_UnlockMutex(SDL::GetMutex());
SDL_RenderPresent(SDL::GetRenderer());
SDL_UnlockMutex(SDL::GetMutex());
}
bool RetroFE::Initialize()
{
Logger::Write(Logger::ZONE_INFO, "RetroFE", "Initializing");
Logger::Write(Logger::ZONE_INFO, "RetroFE", "Initializing");
if(!Input.Initialize()) return false;
if(!SDL::Initialize(Config)) return false;
FC.Initialize();
if(!Input.Initialize()) return false;
if(!SDL::Initialize(Config)) return false;
FC.Initialize();
bool videoEnable = true;
int videoLoop = 0;
bool videoEnable = true;
int videoLoop = 0;
Config->GetProperty("videoEnable", videoEnable);
Config->GetProperty("videoLoop", videoLoop);
Config->GetProperty("videoEnable", videoEnable);
Config->GetProperty("videoLoop", videoLoop);
VideoFactory::SetEnabled(videoEnable);
VideoFactory::SetNumLoops(videoLoop);
VideoFactory vf;
VideoInst = vf.CreateVideo();
VideoFactory::SetEnabled(videoEnable);
VideoFactory::SetNumLoops(videoLoop);
VideoFactory vf;
VideoInst = vf.CreateVideo();
return true;
return true;
}
void RetroFE::LaunchEnter()
{
if(PageChain.size() > 0)
{
Page *p = PageChain.back();
p->LaunchEnter();
}
SDL_SetWindowGrab(SDL::GetWindow(), SDL_FALSE);
if(PageChain.size() > 0)
{
Page *p = PageChain.back();
p->LaunchEnter();
}
SDL_SetWindowGrab(SDL::GetWindow(), SDL_FALSE);
}
void RetroFE::LaunchExit()
{
SDL_RestoreWindow(SDL::GetWindow());
SDL_SetWindowGrab(SDL::GetWindow(), SDL_TRUE);
SDL_RestoreWindow(SDL::GetWindow());
SDL_SetWindowGrab(SDL::GetWindow(), SDL_TRUE);
if(PageChain.size() > 0)
{
Page *p = PageChain.back();
p->LaunchExit();
}
if(PageChain.size() > 0)
{
Page *p = PageChain.back();
p->LaunchExit();
}
}
void RetroFE::FreeGraphicsMemory()
{
if(PageChain.size() > 0)
{
Page *p = PageChain.back();
p->FreeGraphicsMemory();
}
FC.DeInitialize();
if(PageChain.size() > 0)
{
Page *p = PageChain.back();
p->FreeGraphicsMemory();
}
FC.DeInitialize();
SDL::DeInitialize();
SDL::DeInitialize();
}
void RetroFE::AllocateGraphicsMemory()
{
SDL::Initialize(Config);
SDL::Initialize(Config);
FC.Initialize();
FC.Initialize();
if(PageChain.size() > 0)
{
Page *p = PageChain.back();
p->AllocateGraphicsMemory();
p->Start();
}
if(PageChain.size() > 0)
{
Page *p = PageChain.back();
p->AllocateGraphicsMemory();
p->Start();
}
}
bool RetroFE::DeInitialize()
{
bool retVal = true;
FreeGraphicsMemory();
bool retVal = true;
FreeGraphicsMemory();
bool videoEnable = true;
bool videoEnable = true;
while(PageChain.size() > 0)
{
Page *page = PageChain.back();
delete page;
PageChain.pop_back();
}
while(PageChain.size() > 0)
{
Page *page = PageChain.back();
delete page;
PageChain.pop_back();
}
if(VideoInst)
{
delete VideoInst;
VideoInst = NULL;
}
if(VideoInst)
{
delete VideoInst;
VideoInst = NULL;
}
//todo: handle video deallocation
return retVal;
//todo: handle video deallocation
return retVal;
}
Configuration *RetroFE::GetConfiguration()
{
return Config;
return Config;
}
void RetroFE::Run()
{
int attractModeTime = 0;
bool attractMode = false;
std::string firstCollection = "Main";
int attractModeTime = 0;
bool attractMode = false;
std::string firstCollection = "Main";
Config->GetProperty("attractModeTime", attractModeTime);
Config->GetProperty("firstCollection", firstCollection);
Config->GetProperty("attractModeTime", attractModeTime);
Config->GetProperty("firstCollection", firstCollection);
bool running = true;
Item *nextPageItem = NULL;
bool adminMode = false;
float attractModeRandomTime = 0;
bool selectActive = false;
bool running = true;
Item *nextPageItem = NULL;
bool adminMode = false;
float attractModeRandomTime = 0;
bool selectActive = false;
//todo: break up into helper methods
Logger::Write(Logger::ZONE_INFO, "RetroFE", "Loading first page");
//todo: break up into helper methods
Logger::Write(Logger::ZONE_INFO, "RetroFE", "Loading first page");
page = LoadPage(firstCollection);
page = LoadPage(firstCollection);
float frameCount = 0;
float fpsStartTime = 0;
RETROFE_STATE state = RETROFE_IDLE;
float frameCount = 0;
float fpsStartTime = 0;
RETROFE_STATE state = RETROFE_IDLE;
while (running)
{
float lastTime = 0;
float deltaTime = 0;
page = PageChain.back();
Launcher l(this);
while (running)
{
float lastTime = 0;
float deltaTime = 0;
page = PageChain.back();
Launcher l(this);
if(!page)
{
Logger::Write(Logger::ZONE_WARNING, "RetroFE", "Could not load page");
running = false;
break;
}
if(!page)
{
Logger::Write(Logger::ZONE_WARNING, "RetroFE", "Could not load page");
running = false;
break;
}
// todo: This could be transformed to use the state design pattern.
switch(state)
{
case RETROFE_IDLE:
state = ProcessUserInput();
break;
// todo: This could be transformed to use the state design pattern.
switch(state)
{
case RETROFE_IDLE:
state = ProcessUserInput();
break;
case RETROFE_NEXT_PAGE_REQUEST:
page->Stop();
state = RETROFE_NEXT_PAGE_WAIT;
break;
case RETROFE_NEXT_PAGE_REQUEST:
page->Stop();
state = RETROFE_NEXT_PAGE_WAIT;
break;
case RETROFE_NEXT_PAGE_WAIT:
if(page->IsHidden())
{
page = LoadPage(NextPageItem->GetName());
state = RETROFE_NEW;
}
break;
case RETROFE_NEXT_PAGE_WAIT:
if(page->IsHidden())
{
page = LoadPage(NextPageItem->GetName());
state = RETROFE_NEW;
}
break;
case RETROFE_LAUNCH_REQUEST:
l.Run(page->GetCollectionName(), NextPageItem);
state = RETROFE_IDLE;
break;
case RETROFE_LAUNCH_REQUEST:
l.Run(page->GetCollectionName(), NextPageItem);
state = RETROFE_IDLE;
break;
case RETROFE_BACK_REQUEST:
page->Stop();
state = RETROFE_BACK_WAIT;
break;
case RETROFE_BACK_REQUEST:
page->Stop();
state = RETROFE_BACK_WAIT;
break;
case RETROFE_BACK_WAIT:
if(page->IsHidden())
{
PageChain.pop_back();
delete page;
case RETROFE_BACK_WAIT:
if(page->IsHidden())
{
PageChain.pop_back();
delete page;
page = PageChain.back();
page = PageChain.back();
CurrentTime = (float)SDL_GetTicks() / 1000;
page->AllocateGraphicsMemory();
page->Start();
state = RETROFE_NEW;
}
break;
case RETROFE_NEW:
if(page->IsIdle())
{
state = RETROFE_IDLE;
}
break;
case RETROFE_QUIT_REQUEST:
page->Stop();
state = RETROFE_QUIT;
break;
case RETROFE_QUIT:
if(page->IsHidden())
{
running = false;
}
break;
}
// the logic below could be done in a helper method
if(running)
{
lastTime = CurrentTime;
CurrentTime = (float)SDL_GetTicks() / 1000;
page->AllocateGraphicsMemory();
page->Start();
state = RETROFE_NEW;
}
break;
case RETROFE_NEW:
if(page->IsIdle())
{
state = RETROFE_IDLE;
}
break;
case RETROFE_QUIT_REQUEST:
page->Stop();
state = RETROFE_QUIT;
break;
case RETROFE_QUIT:
if(page->IsHidden())
{
running = false;
}
break;
}
// the logic below could be done in a helper method
if(running)
{
lastTime = CurrentTime;
CurrentTime = (float)SDL_GetTicks() / 1000;
if (CurrentTime < lastTime)
{
CurrentTime = lastTime;
}
deltaTime = CurrentTime - lastTime;
double sleepTime = 1000.0/60.0 - deltaTime*1000;
if(sleepTime > 0)
{
SDL_Delay(static_cast<unsigned int>(sleepTime));
}
++frameCount;
if(CurrentTime - fpsStartTime > 1.0)
{
// don't print the first framerate, it's likely inaccurate
bool logFps = false;
Config->GetProperty("debug.logfps", logFps);
if(fpsStartTime != 0 && logFps)
if (CurrentTime < lastTime)
{
std::stringstream fpsstream;
fpsstream << frameCount/(CurrentTime - fpsStartTime) << " FPS";
Logger::Write(Logger::ZONE_DEBUG, "RetroFE", fpsstream.str());
CurrentTime = lastTime;
}
fpsStartTime = CurrentTime;
frameCount = 0;
}
InactiveKeyTime += deltaTime;
if(!AttractMode && InactiveKeyTime > attractModeTime)
{
AttractMode = true;
InactiveKeyTime = 0;
attractModeRandomTime = ((float)((1000+rand()) % 5000)) / 1000;
}
if(attractMode)
{
page->SetScrolling(Page::ScrollDirectionForward);
if(InactiveKeyTime > attractModeRandomTime)
deltaTime = CurrentTime - lastTime;
double sleepTime = 1000.0/60.0 - deltaTime*1000;
if(sleepTime > 0)
{
InactiveKeyTime = 0;
attractMode = false;
page->SetScrolling(Page::ScrollDirectionIdle);
SDL_Delay(static_cast<unsigned int>(sleepTime));
}
}
page->Update(deltaTime);
Render();
}
}
++frameCount;
if(CurrentTime - fpsStartTime > 1.0)
{
// don't print the first framerate, it's likely inaccurate
bool logFps = false;
Config->GetProperty("debug.logfps", logFps);
if(fpsStartTime != 0 && logFps)
{
std::stringstream fpsstream;
fpsstream << frameCount/(CurrentTime - fpsStartTime) << " FPS";
Logger::Write(Logger::ZONE_DEBUG, "RetroFE", fpsstream.str());
}
fpsStartTime = CurrentTime;
frameCount = 0;
}
InactiveKeyTime += deltaTime;
if(!AttractMode && InactiveKeyTime > attractModeTime)
{
AttractMode = true;
InactiveKeyTime = 0;
attractModeRandomTime = ((float)((1000+rand()) % 5000)) / 1000;
}
if(attractMode)
{
page->SetScrolling(Page::ScrollDirectionForward);
if(InactiveKeyTime > attractModeRandomTime)
{
InactiveKeyTime = 0;
attractMode = false;
page->SetScrolling(Page::ScrollDirectionIdle);
}
}
page->Update(deltaTime);
Render();
}
}
}
bool RetroFE::ItemSelected()
{
Item *item = page->GetSelectedItem();
Item *item = page->GetSelectedItem();
if(!item) return false;
if(!item) return false;
if(item->IsLeaf())
{
Launcher l(this);
if(item->IsLeaf())
{
Launcher l(this);
l.Run(page->GetCollectionName(), item);
}
else
{
NextPageItem = item;
LoadPage(page->GetCollectionName());
page->Stop();
}
l.Run(page->GetCollectionName(), item);
}
else
{
NextPageItem = item;
LoadPage(page->GetCollectionName());
page->Stop();
}
return true;
return true;
}
bool RetroFE::Back(bool &exit)
{
bool canGoBack = false;
bool canGoBack = false;
bool exitOnBack = false;
Config->GetProperty("exitOnFirstPageBack", exitOnBack);
exit = false;
bool exitOnBack = false;
Config->GetProperty("exitOnFirstPageBack", exitOnBack);
exit = false;
if(PageChain.size() > 1)
{
page->Stop();
canGoBack = true;
}
else if(PageChain.size() == 1 && exitOnBack)
{
page->Stop();
exit = true;
canGoBack = true;
}
if(PageChain.size() > 1)
{
page->Stop();
canGoBack = true;
}
else if(PageChain.size() == 1 && exitOnBack)
{
page->Stop();
exit = true;
canGoBack = true;
}
return canGoBack;
return canGoBack;
}
RetroFE::RETROFE_STATE RetroFE::ProcessUserInput()
{
SDL_Event e;
bool exit = false;
RETROFE_STATE state = RETROFE_IDLE;
SDL_Event e;
bool exit = false;
RETROFE_STATE state = RETROFE_IDLE;
if (SDL_PollEvent(&e) == 0) return state;
if (SDL_PollEvent(&e) == 0) return state;
if(e.type == SDL_KEYDOWN || e.type == SDL_KEYUP)
{
const Uint8 *keys = SDL_GetKeyboardState(NULL);
if(e.type == SDL_KEYDOWN || e.type == SDL_KEYUP)
{
const Uint8 *keys = SDL_GetKeyboardState(NULL);
InactiveKeyTime = 0;
AttractMode = false;
InactiveKeyTime = 0;
AttractMode = false;
if (keys[Input.GetScancode(UserInput::KeyCodePreviousItem)])
{
page->SetScrolling(Page::ScrollDirectionBack);
}
if (keys[Input.GetScancode(UserInput::KeyCodeNextItem)])
{
page->SetScrolling(Page::ScrollDirectionForward);
}
if (keys[Input.GetScancode(UserInput::KeyCodePageUp)])
{
page->PageScroll(Page::ScrollDirectionBack);
}
if (keys[Input.GetScancode(UserInput::KeyCodePageDown)])
{
page->PageScroll(Page::ScrollDirectionForward);
}
if (keys[Input.GetScancode(UserInput::KeyCodeAdminMode)])
{
//todo: add admin mode support
}
if (keys[Input.GetScancode(UserInput::KeyCodeSelect)])
{
NextPageItem = page->GetSelectedItem();
if (keys[Input.GetScancode(UserInput::KeyCodePreviousItem)])
{
page->SetScrolling(Page::ScrollDirectionBack);
}
if (keys[Input.GetScancode(UserInput::KeyCodeNextItem)])
{
page->SetScrolling(Page::ScrollDirectionForward);
}
if (keys[Input.GetScancode(UserInput::KeyCodePageUp)])
{
page->PageScroll(Page::ScrollDirectionBack);
}
if (keys[Input.GetScancode(UserInput::KeyCodePageDown)])
{
page->PageScroll(Page::ScrollDirectionForward);
}
if (keys[Input.GetScancode(UserInput::KeyCodeAdminMode)])
{
//todo: add admin mode support
}
if (keys[Input.GetScancode(UserInput::KeyCodeSelect)])
{
NextPageItem = page->GetSelectedItem();
if(NextPageItem)
{
state = (NextPageItem->IsLeaf()) ? RETROFE_LAUNCH_REQUEST : RETROFE_NEXT_PAGE_REQUEST;
}
}
if(NextPageItem)
{
state = (NextPageItem->IsLeaf()) ? RETROFE_LAUNCH_REQUEST : RETROFE_NEXT_PAGE_REQUEST;
}
}
if (keys[Input.GetScancode(UserInput::KeyCodeBack)])
{
if(Back(exit))
{
state = (exit) ? RETROFE_QUIT_REQUEST : RETROFE_BACK_REQUEST;
}
}
if (keys[Input.GetScancode(UserInput::KeyCodeBack)])
{
if(Back(exit))
{
state = (exit) ? RETROFE_QUIT_REQUEST : RETROFE_BACK_REQUEST;
}
}
if (keys[Input.GetScancode(UserInput::KeyCodeQuit)])
{
state = RETROFE_QUIT_REQUEST;
}
if (keys[Input.GetScancode(UserInput::KeyCodeQuit)])
{
state = RETROFE_QUIT_REQUEST;
}
if(!keys[Input.GetScancode(UserInput::KeyCodePreviousItem)] &&
!keys[Input.GetScancode(UserInput::KeyCodeNextItem)] &&
!keys[Input.GetScancode(UserInput::KeyCodePageUp)] &&
!keys[Input.GetScancode(UserInput::KeyCodePageDown)])
{
page->SetScrolling(Page::ScrollDirectionIdle);
}
}
if(!keys[Input.GetScancode(UserInput::KeyCodePreviousItem)] &&
!keys[Input.GetScancode(UserInput::KeyCodeNextItem)] &&
!keys[Input.GetScancode(UserInput::KeyCodePageUp)] &&
!keys[Input.GetScancode(UserInput::KeyCodePageDown)])
{
page->SetScrolling(Page::ScrollDirectionIdle);
}
}
return state;
return state;
}
Page *RetroFE::LoadPage(std::string collectionName)
{
Logger::Write(Logger::ZONE_INFO, "RetroFE", "Creating page for collection " + collectionName);
Logger::Write(Logger::ZONE_INFO, "RetroFE", "Creating page for collection " + collectionName);
Page *page = NULL;
std::vector<Item *> *collection = new std::vector<Item *>(); // the page will deallocate this once its done
MenuParser mp;
Page *page = NULL;
std::vector<Item *> *collection = new std::vector<Item *>(); // the page will deallocate this once its done
MenuParser mp;
mp.GetMenuItems(CollectionDB, collectionName, *collection);
CollectionDB->GetCollection(collectionName, *collection);
mp.GetMenuItems(CollectionDB, collectionName, *collection);
CollectionDB->GetCollection(collectionName, *collection);
//todo: handle this in a more esthetically pleasing way instead of crashing
if(collection->size() == 0)
{
Logger::Write(Logger::ZONE_WARNING, "RetroFE", "No list items found for collection " + collectionName);
}
else
{
std::string layoutKeyName = "collections." + collectionName + ".layout";
std::string layoutName = "Default 16x9";
//todo: handle this in a more esthetically pleasing way instead of crashing
if(collection->size() == 0)
{
Logger::Write(Logger::ZONE_WARNING, "RetroFE", "No list items found for collection " + collectionName);
}
else
{
std::string layoutKeyName = "collections." + collectionName + ".layout";
std::string layoutName = "Default 16x9";
if(!Config->GetProperty(layoutKeyName, layoutName))
{
Config->GetProperty("layout", layoutName);
}
if(!Config->GetProperty(layoutKeyName, layoutName))
{
Config->GetProperty("layout", layoutName);
}
if(PageChain.size() > 0)
{
Page *oldPage = PageChain.back();
if(PageChain.size() > 0)
{
Page *oldPage = PageChain.back();
if(oldPage)
{
oldPage->FreeGraphicsMemory();
}
}
if(oldPage)
{
oldPage->FreeGraphicsMemory();
}
}
PageBuilder pb(layoutName, collectionName, Config, &FC);
page = pb.BuildPage();
page->SetItems(collection);
page->Start();
PageBuilder pb(layoutName, collectionName, Config, &FC);
page = pb.BuildPage();
page->SetItems(collection);
page->Start();
if(page)
{
PageChain.push_back(page);
}
}
if(page)
{
PageChain.push_back(page);
}
}
return page;
return page;
}

80
Source/RetroFE.h
View File

@ -17,49 +17,49 @@ class Page;
class RetroFE
{
public:
RetroFE(CollectionDatabase *db, Configuration *c);
virtual ~RetroFE();
bool Initialize();
bool DeInitialize();
void Run();
Configuration *GetConfiguration();
void FreeGraphicsMemory();
void AllocateGraphicsMemory();
void LaunchEnter();
void LaunchExit();
RetroFE(CollectionDatabase *db, Configuration *c);
virtual ~RetroFE();
bool Initialize();
bool DeInitialize();
void Run();
Configuration *GetConfiguration();
void FreeGraphicsMemory();
void AllocateGraphicsMemory();
void LaunchEnter();
void LaunchExit();
private:
enum RETROFE_STATE
{
RETROFE_IDLE,
RETROFE_NEXT_PAGE_REQUEST,
RETROFE_NEXT_PAGE_WAIT,
RETROFE_LAUNCH_REQUEST,
RETROFE_BACK_REQUEST,
RETROFE_BACK_WAIT,
RETROFE_NEW,
RETROFE_QUIT_REQUEST,
RETROFE_QUIT,
};
enum RETROFE_STATE
{
RETROFE_IDLE,
RETROFE_NEXT_PAGE_REQUEST,
RETROFE_NEXT_PAGE_WAIT,
RETROFE_LAUNCH_REQUEST,
RETROFE_BACK_REQUEST,
RETROFE_BACK_WAIT,
RETROFE_NEW,
RETROFE_QUIT_REQUEST,
RETROFE_QUIT,
};
void Render();
bool ItemSelected();
bool Back(bool &exit);
void Quit();
Page *LoadPage(std::string collectionName);
RETROFE_STATE ProcessUserInput();
void Update(float dt, bool scrollActive);
void Render();
bool ItemSelected();
bool Back(bool &exit);
void Quit();
Page *LoadPage(std::string collectionName);
RETROFE_STATE ProcessUserInput();
void Update(float dt, bool scrollActive);
Configuration *Config;
CollectionDatabase *CollectionDB;
UserInput Input;
std::list<Page *> PageChain;
float KeyInputDisable;
float InactiveKeyTime;
bool AttractMode;
float CurrentTime;
Item *NextPageItem;
FontCache FC;
IVideo *VideoInst;
Configuration *Config;
CollectionDatabase *CollectionDB;
UserInput Input;
std::list<Page *> PageChain;
float KeyInputDisable;
float InactiveKeyTime;
bool AttractMode;
float CurrentTime;
Item *NextPageItem;
FontCache FC;
IVideo *VideoInst;
};

370
Source/SDL.cpp
View File

@ -1,6 +1,6 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
*/
#include "SDL.h"
#include "Database/Configuration.h"
#include "Utility/Log.h"
@ -18,239 +18,239 @@ bool SDL::Fullscreen = false;
bool SDL::Initialize(Configuration *config)
{
bool retVal = true;
std::string hString;
std::string vString;
Uint32 windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_BORDERLESS;
int audioRate = MIX_DEFAULT_FREQUENCY;
Uint16 audioFormat = MIX_DEFAULT_FORMAT; /* 16-bit stereo */
int audioChannels = 1;
int audioBuffers = 4096;
bool hideMouse;
bool retVal = true;
std::string hString;
std::string vString;
Uint32 windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_BORDERLESS;
int audioRate = MIX_DEFAULT_FREQUENCY;
Uint16 audioFormat = MIX_DEFAULT_FORMAT; /* 16-bit stereo */
int audioChannels = 1;
int audioBuffers = 4096;
bool hideMouse;
Logger::Write(Logger::ZONE_DEBUG, "SDL", "Initializing");
if (retVal && SDL_Init(SDL_INIT_EVERYTHING) != 0)
{
std::string error = SDL_GetError();
Logger::Write(Logger::ZONE_ERROR, "SDL", "Initialize failed: " + error);
retVal = false;
}
Logger::Write(Logger::ZONE_DEBUG, "SDL", "Initializing");
if (retVal && SDL_Init(SDL_INIT_EVERYTHING) != 0)
{
std::string error = SDL_GetError();
Logger::Write(Logger::ZONE_ERROR, "SDL", "Initialize failed: " + error);
retVal = false;
}
if(retVal && config->GetProperty("hideMouse", hideMouse))
{
if(hideMouse)
{
SDL_ShowCursor(SDL_FALSE);
}
else
{
SDL_ShowCursor(SDL_TRUE);
}
}
if(retVal && config->GetProperty("hideMouse", hideMouse))
{
if(hideMouse)
{
SDL_ShowCursor(SDL_FALSE);
}
else
{
SDL_ShowCursor(SDL_TRUE);
}
}
// check for a few other necessary Configurations
if(retVal)
{
// Get current display mode of all displays.
for(int i = 0; i < SDL_GetNumVideoDisplays(); ++i)
{
SDL_DisplayMode mode;
if(SDL_GetCurrentDisplayMode(i, &mode) == 0)
{
DisplayWidth = mode.w;
DisplayHeight = mode.h;
break;
}
}
if(!config->GetProperty("horizontal", hString))
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Missing property \"horizontal\"");
retVal = false;
}
else if(hString == "stretch")
{
// Get current display mode of all displays.
for(int i = 0; i < SDL_GetNumVideoDisplays(); ++i)
{
// check for a few other necessary Configurations
if(retVal)
{
// Get current display mode of all displays.
for(int i = 0; i < SDL_GetNumVideoDisplays(); ++i)
{
SDL_DisplayMode mode;
if(SDL_GetCurrentDisplayMode(i, &mode) == 0)
{
WindowWidth = mode.w;
break;
DisplayWidth = mode.w;
DisplayHeight = mode.h;
break;
}
}
}
else if(!config->GetProperty("horizontal", WindowWidth))
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Invalid property value for \"horizontal\"");
}
}
}
// check for a few other necessary Configurations
if(retVal)
{
if(!config->GetProperty("vertical", hString))
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Missing property \"vertical\"");
retVal = false;
}
else if(hString == "stretch")
{
// Get current display mode of all displays.
for(int i = 0; i < SDL_GetNumVideoDisplays(); ++i)
{
SDL_DisplayMode mode;
if(SDL_GetDesktopDisplayMode(i, &mode) == 0)
if(!config->GetProperty("horizontal", hString))
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Missing property \"horizontal\"");
retVal = false;
}
else if(hString == "stretch")
{
// Get current display mode of all displays.
for(int i = 0; i < SDL_GetNumVideoDisplays(); ++i)
{
WindowHeight = mode.h;
break;
SDL_DisplayMode mode;
if(SDL_GetCurrentDisplayMode(i, &mode) == 0)
{
WindowWidth = mode.w;
break;
}
}
}
}
else if(!config->GetProperty("vertical", WindowHeight))
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Invalid property value for \"vertical\"");
}
}
}
else if(!config->GetProperty("horizontal", WindowWidth))
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Invalid property value for \"horizontal\"");
}
}
if(retVal && !config->GetProperty("fullscreen", Fullscreen))
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Missing property: \"fullscreen\"");
retVal = false;
}
// check for a few other necessary Configurations
if(retVal)
{
if(!config->GetProperty("vertical", hString))
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Missing property \"vertical\"");
retVal = false;
}
else if(hString == "stretch")
{
// Get current display mode of all displays.
for(int i = 0; i < SDL_GetNumVideoDisplays(); ++i)
{
SDL_DisplayMode mode;
if(SDL_GetDesktopDisplayMode(i, &mode) == 0)
{
WindowHeight = mode.h;
break;
}
}
}
else if(!config->GetProperty("vertical", WindowHeight))
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Invalid property value for \"vertical\"");
}
}
if (retVal && Fullscreen)
{
windowFlags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
}
if(retVal && !config->GetProperty("fullscreen", Fullscreen))
{
Logger::Write(Logger::ZONE_ERROR, "Configuration", "Missing property: \"fullscreen\"");
retVal = false;
}
if(retVal)
{
std::stringstream ss;
ss << "Creating "<< WindowWidth << "x" << WindowHeight << " window (fullscreen: " << Fullscreen << ")";
Logger::Write(Logger::ZONE_DEBUG, "SDL", ss.str());
if (retVal && Fullscreen)
{
windowFlags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
}
Window = SDL_CreateWindow("RetroFE",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
WindowWidth,
WindowHeight,
windowFlags);
if(retVal)
{
std::stringstream ss;
ss << "Creating "<< WindowWidth << "x" << WindowHeight << " window (fullscreen: " << Fullscreen << ")";
Logger::Write(Logger::ZONE_DEBUG, "SDL", ss.str());
if (Window == NULL)
{
std::string error = SDL_GetError();
Logger::Write(Logger::ZONE_ERROR, "SDL", "Create window failed: " + error);
retVal = false;
}
}
Window = SDL_CreateWindow("RetroFE",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
WindowWidth,
WindowHeight,
windowFlags);
if(retVal)
{
Renderer = SDL_CreateRenderer(Window,
-1,
SDL_RENDERER_ACCELERATED);
if (Window == NULL)
{
std::string error = SDL_GetError();
Logger::Write(Logger::ZONE_ERROR, "SDL", "Create window failed: " + error);
retVal = false;
}
}
if (Renderer == NULL)
{
std::string error = SDL_GetError();
Logger::Write(Logger::ZONE_ERROR, "SDL", "Create renderer failed: " + error);
retVal = false;
}
}
if(retVal)
{
Renderer = SDL_CreateRenderer(Window,
-1,
SDL_RENDERER_ACCELERATED);
if(retVal)
{
Mutex = SDL_CreateMutex();
if (Renderer == NULL)
{
std::string error = SDL_GetError();
Logger::Write(Logger::ZONE_ERROR, "SDL", "Create renderer failed: " + error);
retVal = false;
}
}
if (Mutex == NULL)
{
std::string error = SDL_GetError();
Logger::Write(Logger::ZONE_ERROR, "SDL", "Mutex creation failed: " + error);
retVal = false;
}
}
if(retVal)
{
Mutex = SDL_CreateMutex();
//todo: specify in configuration file
if (retVal && Mix_OpenAudio(audioRate, audioFormat, audioChannels, audioBuffers) == -1)
{
std::string error = Mix_GetError();
Logger::Write(Logger::ZONE_ERROR, "SDL", "Audio initialize failed: " + error);
retVal = false;
}
if (Mutex == NULL)
{
std::string error = SDL_GetError();
Logger::Write(Logger::ZONE_ERROR, "SDL", "Mutex creation failed: " + error);
retVal = false;
}
}
return retVal;
//todo: specify in configuration file
if (retVal && Mix_OpenAudio(audioRate, audioFormat, audioChannels, audioBuffers) == -1)
{
std::string error = Mix_GetError();
Logger::Write(Logger::ZONE_ERROR, "SDL", "Audio initialize failed: " + error);
retVal = false;
}
return retVal;
}
bool SDL::DeInitialize()
{
std::string error = SDL_GetError();
Logger::Write(Logger::ZONE_DEBUG, "SDL", "DeInitializing");
std::string error = SDL_GetError();
Logger::Write(Logger::ZONE_DEBUG, "SDL", "DeInitializing");
Mix_CloseAudio();
Mix_Quit();
if(Mutex)
{
SDL_DestroyMutex(Mutex);
Mutex = NULL;
}
Mix_CloseAudio();
Mix_Quit();
if(Mutex)
{
SDL_DestroyMutex(Mutex);
Mutex = NULL;
}
if(Renderer)
{
SDL_DestroyRenderer(Renderer);
Renderer = NULL;
}
if(Renderer)
{
SDL_DestroyRenderer(Renderer);
Renderer = NULL;
}
if(Window)
{
SDL_DestroyWindow(Window);
Window = NULL;
}
if(Window)
{
SDL_DestroyWindow(Window);
Window = NULL;
}
SDL_ShowCursor(SDL_TRUE);
SDL_ShowCursor(SDL_TRUE);
SDL_Quit();
SDL_Quit();
return true;
return true;
}
SDL_Renderer* SDL::GetRenderer()
{
return Renderer;
return Renderer;
}
SDL_mutex* SDL::GetMutex()
{
return Mutex;
return Mutex;
}
SDL_Window* SDL::GetWindow()
{
return Window;
return Window;
}
bool SDL::RenderCopy(SDL_Texture *texture, unsigned char transparency, SDL_Rect *src, SDL_Rect *dest, double angle)
{
SDL_Rect rotateRect;
rotateRect.w = dest->w;
rotateRect.h = dest->h;
SDL_Rect rotateRect;
rotateRect.w = dest->w;
rotateRect.h = dest->h;
if(Fullscreen)
{
rotateRect.x = dest->x + (DisplayWidth - WindowWidth)/2;
rotateRect.y = dest->y + (DisplayHeight - WindowHeight)/2;
}
else
{
rotateRect.x = dest->x;
rotateRect.y = dest->y;
}
if(Fullscreen)
{
rotateRect.x = dest->x + (DisplayWidth - WindowWidth)/2;
rotateRect.y = dest->y + (DisplayHeight - WindowHeight)/2;
}
else
{
rotateRect.x = dest->x;
rotateRect.y = dest->y;
}
SDL_SetTextureAlphaMod(texture, transparency);
SDL_RenderCopyEx(GetRenderer(), texture, src, &rotateRect, angle, NULL, SDL_FLIP_NONE);
SDL_SetTextureAlphaMod(texture, transparency);
SDL_RenderCopyEx(GetRenderer(), texture, src, &rotateRect, angle, NULL, SDL_FLIP_NONE);
return true;
return true;
}

45
Source/SDL.h
View File

@ -1,6 +1,6 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
*/
#pragma once
#include <SDL2/SDL.h>
@ -10,23 +10,32 @@ class Configuration;
class SDL
{
public:
static bool Initialize(Configuration *config);
static bool DeInitialize();
static SDL_Renderer *GetRenderer();
static SDL_mutex *GetMutex();
static SDL_Window *GetWindow();
static bool RenderCopy(SDL_Texture *texture, unsigned char transparency, SDL_Rect *src, SDL_Rect *dest, double angle);
static int GetWindowWidth() { return WindowWidth; }
static int GetWindowHeight() { return WindowHeight; }
static bool IsFullscreen() { return Fullscreen; }
static bool Initialize(Configuration *config);
static bool DeInitialize();
static SDL_Renderer *GetRenderer();
static SDL_mutex *GetMutex();
static SDL_Window *GetWindow();
static bool RenderCopy(SDL_Texture *texture, unsigned char transparency, SDL_Rect *src, SDL_Rect *dest, double angle);
static int GetWindowWidth()
{
return WindowWidth;
}
static int GetWindowHeight()
{
return WindowHeight;
}
static bool IsFullscreen()
{
return Fullscreen;
}
private:
static SDL_Window *Window;
static SDL_Renderer *Renderer;
static SDL_mutex *Mutex;
static int DisplayWidth;
static int DisplayHeight;
static int WindowWidth;
static int WindowHeight;
static bool Fullscreen;
static SDL_Window *Window;
static SDL_Renderer *Renderer;
static SDL_mutex *Mutex;
static int DisplayWidth;
static int DisplayHeight;
static int WindowWidth;
static int WindowHeight;
static bool Fullscreen;
};

54
Source/Sound/Sound.cpp
View File

@ -1,54 +1,54 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
*/
#include "Sound.h"
#include "../Utility/Log.h"
Sound::Sound(std::string file)
: File(file)
, Chunk(NULL)
: File(file)
, Chunk(NULL)
{
if(!Allocate())
{
Logger::Write(Logger::ZONE_ERROR, "Sound", "Cannot load " + File);
}
if(!Allocate())
{
Logger::Write(Logger::ZONE_ERROR, "Sound", "Cannot load " + File);
}
}
Sound::~Sound()
{
if(Chunk)
{
Mix_FreeChunk(Chunk);
Chunk = NULL;
}
if(Chunk)
{
Mix_FreeChunk(Chunk);
Chunk = NULL;
}
}
void Sound::Play()
{
if(Chunk)
{
(void)Mix_PlayChannel(-1, Chunk, 0);
}
if(Chunk)
{
(void)Mix_PlayChannel(-1, Chunk, 0);
}
}
bool Sound::Free()
{
if(Chunk)
{
Mix_FreeChunk(Chunk);
Chunk = NULL;
}
if(Chunk)
{
Mix_FreeChunk(Chunk);
Chunk = NULL;
}
return true;
return true;
}
bool Sound::Allocate()
{
if(!Chunk)
{
Chunk = Mix_LoadWAV(File.c_str());
}
if(!Chunk)
{
Chunk = Mix_LoadWAV(File.c_str());
}
return (Chunk != NULL);
return (Chunk != NULL);
}

16
Source/Sound/Sound.h
View File

@ -1,6 +1,6 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
*/
#pragma once
#include <string>
@ -8,12 +8,12 @@
class Sound
{
public:
Sound(std::string file);
virtual ~Sound();
void Play();
bool Allocate();
bool Free();
Sound(std::string file);
virtual ~Sound();
void Play();
bool Allocate();
bool Free();
private:
std::string File;
Mix_Chunk *Chunk;
std::string File;
Mix_Chunk *Chunk;
};

70
Source/Utility/Log.cpp
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#include "Log.h"
#include <iostream>
@ -12,53 +12,53 @@ std::streambuf *Logger::CoutStream = NULL;
bool Logger::Initialize(std::string file)
{
WriteFileStream.open(file.c_str());
WriteFileStream.open(file.c_str());
CerrStream = std::cerr.rdbuf(WriteFileStream.rdbuf());
CoutStream = std::cout.rdbuf(WriteFileStream.rdbuf());
CerrStream = std::cerr.rdbuf(WriteFileStream.rdbuf());
CoutStream = std::cout.rdbuf(WriteFileStream.rdbuf());
return WriteFileStream.is_open();
return WriteFileStream.is_open();
}
void Logger::DeInitialize()
{
if(WriteFileStream.is_open())
{
WriteFileStream.close();
if(WriteFileStream.is_open())
{
WriteFileStream.close();
}
}
std::cerr.rdbuf(CerrStream);
std::cout.rdbuf(CoutStream);
std::cerr.rdbuf(CerrStream);
std::cout.rdbuf(CoutStream);
}
void Logger::Write(Zone zone, std::string component, std::string message)
{
std::string zoneStr;
std::string zoneStr;
switch(zone)
{
case ZONE_INFO:
zoneStr = "INFO";
break;
case ZONE_DEBUG:
zoneStr = "DEBUG";
break;
case ZONE_WARNING:
zoneStr = "WARNING";
break;
case ZONE_ERROR:
zoneStr = "ERROR";
break;
}
std::time_t rawtime = std::time(NULL);
struct tm* timeinfo = std::localtime(&rawtime);
switch(zone)
{
case ZONE_INFO:
zoneStr = "INFO";
break;
case ZONE_DEBUG:
zoneStr = "DEBUG";
break;
case ZONE_WARNING:
zoneStr = "WARNING";
break;
case ZONE_ERROR:
zoneStr = "ERROR";
break;
}
std::time_t rawtime = std::time(NULL);
struct tm* timeinfo = std::localtime(&rawtime);
static char timeStr[60];
std::strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", timeinfo);
static char timeStr[60];
std::strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", timeinfo);
std::stringstream ss;
ss << "[" << timeStr << "] [" << zoneStr << "] [" << component << "] " << message << std::endl;
std::cout << ss.str();
std::stringstream ss;
ss << "[" << timeStr << "] [" << zoneStr << "] [" << component << "] " << message << std::endl;
std::cout << ss.str();
}

30
Source/Utility/Log.h
View File

@ -1,5 +1,5 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
#pragma once
@ -12,20 +12,20 @@
class Logger
{
public:
enum Zone
{
ZONE_DEBUG,
ZONE_INFO,
ZONE_WARNING,
ZONE_ERROR
enum Zone
{
ZONE_DEBUG,
ZONE_INFO,
ZONE_WARNING,
ZONE_ERROR
};
static bool Initialize(std::string file);
static void Write(Zone zone, std::string component, std::string message);
static void DeInitialize();
};
static bool Initialize(std::string file);
static void Write(Zone zone, std::string component, std::string message);
static void DeInitialize();
private:
static std::streambuf *CerrStream;
static std::streambuf *CoutStream;
static std::ofstream WriteFileStream;
static std::streambuf *CerrStream;
static std::streambuf *CoutStream;
static std::ofstream WriteFileStream;
};

122
Source/Utility/Utils.cpp
View File

@ -20,112 +20,112 @@ Utils::~Utils()
bool Utils::FindMatchingFile(std::string prefix, std::vector<std::string> &extensions, std::string &file)
{
for(unsigned int i = 0; i < extensions.size(); ++i)
{
std::string temp = prefix + "." + extensions[i];
temp = Configuration::ConvertToAbsolutePath(Configuration::GetAbsolutePath(), temp);
for(unsigned int i = 0; i < extensions.size(); ++i)
{
std::string temp = prefix + "." + extensions[i];
temp = Configuration::ConvertToAbsolutePath(Configuration::GetAbsolutePath(), temp);
std::ifstream f(temp.c_str());
std::ifstream f(temp.c_str());
if (f.good())
{
file = temp;
return true;
}
}
if (f.good())
{
file = temp;
return true;
}
}
return false;
return false;
}
std::string Utils::Replace(
std::string subject,
const std::string& search,
const std::string& replace)
std::string subject,
const std::string& search,
const std::string& replace)
{
size_t pos = 0;
while ((pos = subject.find(search, pos)) != std::string::npos)
{
subject.replace(pos, search.length(), replace);
pos += replace.length();
}
return subject;
size_t pos = 0;
while ((pos = subject.find(search, pos)) != std::string::npos)
{
subject.replace(pos, search.length(), replace);
pos += replace.length();
}
return subject;
}
float Utils::ConvertFloat(std::string content)
{
float retVal = 0;
std::stringstream ss;
ss << content;
ss >> retVal;
float retVal = 0;
std::stringstream ss;
ss << content;
ss >> retVal;
return retVal;
return retVal;
}
int Utils::ConvertInt(std::string content)
{
int retVal = 0;
std::stringstream ss;
ss << content;
ss >> retVal;
int retVal = 0;
std::stringstream ss;
ss << content;
ss >> retVal;
return retVal;
return retVal;
}
void Utils::NormalizeBackSlashes(std::string& content)
{
std::replace(content.begin(), content.end(), '\\', '/');
std::replace(content.begin(), content.end(), '\\', '/');
}
std::string Utils::GetDirectory(std::string filePath)
{
NormalizeBackSlashes(filePath);
std::string directory = filePath;
NormalizeBackSlashes(filePath);
std::string directory = filePath;
const size_t last_slash_idx = filePath.rfind('/');
if (std::string::npos != last_slash_idx)
{
directory = filePath.substr(0, last_slash_idx);
}
const size_t last_slash_idx = filePath.rfind('/');
if (std::string::npos != last_slash_idx)
{
directory = filePath.substr(0, last_slash_idx);
}
return directory;
return directory;
}
std::string Utils::GetParentDirectory(std::string directory)
{
NormalizeBackSlashes(directory);
NormalizeBackSlashes(directory);
size_t last_slash_idx = directory.find_last_of('/');
if(directory.length() - 1 == last_slash_idx)
{
directory = directory.erase(last_slash_idx, directory.length()-1);
last_slash_idx = directory.find_last_of('/');
}
size_t last_slash_idx = directory.find_last_of('/');
if(directory.length() - 1 == last_slash_idx)
{
directory = directory.erase(last_slash_idx, directory.length()-1);
last_slash_idx = directory.find_last_of('/');
}
if (std::string::npos != last_slash_idx)
{
directory = directory.erase(last_slash_idx, directory.length());
}
if (std::string::npos != last_slash_idx)
{
directory = directory.erase(last_slash_idx, directory.length());
}
return directory;
return directory;
}
std::string Utils::GetFileName(std::string filePath)
{
NormalizeBackSlashes(filePath);
std::string filename = filePath;
NormalizeBackSlashes(filePath);
std::string filename = filePath;
const size_t last_slash_idx = filePath.rfind('/');
if (std::string::npos != last_slash_idx)
{
filename = filePath.erase(0, last_slash_idx+1);
}
const size_t last_slash_idx = filePath.rfind('/');
if (std::string::npos != last_slash_idx)
{
filename = filePath.erase(0, last_slash_idx+1);
}
return filename;
return filename;
}

22
Source/Utility/Utils.h
View File

@ -9,18 +9,18 @@
class Utils
{
public:
static std::string Replace(std::string subject, const std::string& search,
const std::string& replace);
static std::string Replace(std::string subject, const std::string& search,
const std::string& replace);
static float ConvertFloat(std::string content);
static int ConvertInt(std::string content);
static void NormalizeBackSlashes(std::string &content);
static std::string GetDirectory(std::string filePath);
static std::string GetParentDirectory(std::string filePath);
static std::string GetFileName(std::string filePath);
static bool FindMatchingFile(std::string prefix, std::vector<std::string> &extensions, std::string &file);
static float ConvertFloat(std::string content);
static int ConvertInt(std::string content);
static void NormalizeBackSlashes(std::string &content);
static std::string GetDirectory(std::string filePath);
static std::string GetParentDirectory(std::string filePath);
static std::string GetFileName(std::string filePath);
static bool FindMatchingFile(std::string prefix, std::vector<std::string> &extensions, std::string &file);
private:
Utils();
virtual ~Utils();
Utils();
virtual ~Utils();
};

16
Source/Version.cpp
View File

@ -22,16 +22,16 @@
std::string Version::GetString()
{
std::stringstream version;
version << RETROFE_VERSION_MAJOR;
version << ".";
version << RETROFE_VERSION_MINOR;
version << ".";
version << RETROFE_VERSION_BUILD;
std::stringstream version;
version << RETROFE_VERSION_MAJOR;
version << ".";
version << RETROFE_VERSION_MINOR;
version << ".";
version << RETROFE_VERSION_BUILD;
#ifdef RETROFE_VERSION_BETA
version << "-beta";
version << "-beta";
#endif
return version.str();
return version.str();
}

4
Source/Version.h
View File

@ -1,6 +1,6 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
*/
#pragma once
#include <string>
@ -8,5 +8,5 @@
class Version
{
public:
static std::string GetString();
static std::string GetString();
};

484
Source/Video/GStreamerVideo.cpp
View File

@ -23,329 +23,329 @@ bool GStreamerVideo::Initialized = false;
// MUST match video size
gboolean GStreamerVideo::BusCallback(GstBus *bus, GstMessage *msg, gpointer data)
{
// this callback only needs to be defined so we can loop the video once it completes
return TRUE;
// this callback only needs to be defined so we can loop the video once it completes
return TRUE;
}
GStreamerVideo::GStreamerVideo()
: Playbin(NULL)
, VideoBin(NULL)
, VideoSink(NULL)
, VideoConvert(NULL)
, VideoConvertCaps(NULL)
, VideoBus(NULL)
, Texture(NULL)
, Height(0)
, Width(0)
, VideoBuffer(NULL)
, FrameReady(false)
, IsPlaying(false)
, PlayCount(0)
, NumLoops(0)
: Playbin(NULL)
, VideoBin(NULL)
, VideoSink(NULL)
, VideoConvert(NULL)
, VideoConvertCaps(NULL)
, VideoBus(NULL)
, Texture(NULL)
, Height(0)
, Width(0)
, VideoBuffer(NULL)
, FrameReady(false)
, IsPlaying(false)
, PlayCount(0)
, NumLoops(0)
{
}
GStreamerVideo::~GStreamerVideo()
{
Stop();
Stop();
}
void GStreamerVideo::SetNumLoops(int n)
{
NumLoops = n;
NumLoops = n;
}
SDL_Texture *GStreamerVideo::GetTexture() const
{
return Texture;
return Texture;
}
void GStreamerVideo::ProcessNewBuffer (GstElement *fakesink, GstBuffer *buf, GstPad *new_pad, gpointer userdata)
{
GStreamerVideo *video = (GStreamerVideo *)userdata;
GstMapInfo map;
SDL_LockMutex(SDL::GetMutex());
GStreamerVideo *video = (GStreamerVideo *)userdata;
GstMapInfo map;
SDL_LockMutex(SDL::GetMutex());
if (!video->FrameReady && video && video->IsPlaying && gst_buffer_map (buf, &map, GST_MAP_READ))
{
if(!video->Width || !video->Height)
{
GstCaps *caps = gst_pad_get_current_caps (new_pad);
GstStructure *s = gst_caps_get_structure(caps, 0);
if (!video->FrameReady && video && video->IsPlaying && gst_buffer_map (buf, &map, GST_MAP_READ))
{
if(!video->Width || !video->Height)
{
GstCaps *caps = gst_pad_get_current_caps (new_pad);
GstStructure *s = gst_caps_get_structure(caps, 0);
gst_structure_get_int(s, "width", &video->Width);
gst_structure_get_int(s, "height", &video->Height);
}
gst_structure_get_int(s, "width", &video->Width);
gst_structure_get_int(s, "height", &video->Height);
}
if(video->Height && video->Width)
{
if(!video->VideoBuffer)
{
video->VideoBuffer = new char[map.size];
}
memcpy(video->VideoBuffer, map.data, map.size);
gst_buffer_unmap(buf, &map);
video->FrameReady = true;
}
}
SDL_UnlockMutex(SDL::GetMutex());
if(video->Height && video->Width)
{
if(!video->VideoBuffer)
{
video->VideoBuffer = new char[map.size];
}
memcpy(video->VideoBuffer, map.data, map.size);
gst_buffer_unmap(buf, &map);
video->FrameReady = true;
}
}
SDL_UnlockMutex(SDL::GetMutex());
}
bool GStreamerVideo::Initialize()
{
bool retVal = true;
bool retVal = true;
std::string path = Configuration::GetAbsolutePath() + "/Core";
gst_init(NULL, NULL);
GstRegistry *registry = gst_registry_get();
gst_registry_scan_path(registry, path.c_str());
std::string path = Configuration::GetAbsolutePath() + "/Core";
gst_init(NULL, NULL);
GstRegistry *registry = gst_registry_get();
gst_registry_scan_path(registry, path.c_str());
Initialized = true;
Initialized = true;
return retVal;
return retVal;
}
bool GStreamerVideo::DeInitialize()
{
gst_deinit();
Initialized = false;
return true;
gst_deinit();
Initialized = false;
return true;
}
bool GStreamerVideo::Stop()
{
if(!Initialized)
{
return false;
}
if(!Initialized)
{
return false;
}
if(VideoSink)
{
g_object_set(G_OBJECT(VideoSink), "signal-handoffs", FALSE, NULL);
}
if(VideoSink)
{
g_object_set(G_OBJECT(VideoSink), "signal-handoffs", FALSE, NULL);
}
if(Playbin)
{
(void)gst_element_set_state(Playbin, GST_STATE_NULL);
}
if(Playbin)
{
(void)gst_element_set_state(Playbin, GST_STATE_NULL);
}
FreeElements();
FreeElements();
IsPlaying = false;
IsPlaying = false;
if(Texture)
{
SDL_DestroyTexture(Texture);
Texture = NULL;
}
IsPlaying = false;
Height = 0;
Width = 0;
FrameReady = false;
if(Texture)
{
SDL_DestroyTexture(Texture);
Texture = NULL;
}
IsPlaying = false;
Height = 0;
Width = 0;
FrameReady = false;
if(VideoBuffer)
{
delete VideoBuffer;
VideoBuffer = NULL;
}
return true;
if(VideoBuffer)
{
delete VideoBuffer;
VideoBuffer = NULL;
}
return true;
}
bool GStreamerVideo::Play(std::string file)
{
PlayCount = 0;
PlayCount = 0;
if(!Initialized)
{
return false;
}
if(!Initialized)
{
return false;
}
CurrentFile = file;
CurrentFile = file;
const gchar *uriFile = gst_filename_to_uri (file.c_str(), NULL);
if(!uriFile)
{
return false;
}
else
{
Configuration::ConvertToAbsolutePath(Configuration::GetAbsolutePath(), file);
file = uriFile;
const gchar *uriFile = gst_filename_to_uri (file.c_str(), NULL);
if(!uriFile)
{
return false;
}
else
{
Configuration::ConvertToAbsolutePath(Configuration::GetAbsolutePath(), file);
file = uriFile;
// Pipeline = gst_pipeline_new("pipeline");
Playbin = gst_element_factory_make("playbin", "player");
VideoBin = gst_bin_new("SinkBin");
VideoSink = gst_element_factory_make("fakesink", "video_sink");
VideoConvert = gst_element_factory_make("capsfilter", "video_convert");
VideoConvertCaps = gst_caps_from_string("video/x-raw,format=(string)YUY2");
Height = 0;
Width = 0;
if(!Playbin)
{
Logger::Write(Logger::ZONE_DEBUG, "Video", "Could not create playbin");
FreeElements();
return false;
}
if(!VideoSink)
{
Logger::Write(Logger::ZONE_DEBUG, "Video", "Could not create video sink");
FreeElements();
return false;
}
if(!VideoConvert)
{
Logger::Write(Logger::ZONE_DEBUG, "Video", "Could not create video converter");
FreeElements();
return false;
}
if(!VideoConvertCaps)
{
Logger::Write(Logger::ZONE_DEBUG, "Video", "Could not create video caps");
FreeElements();
return false;
}
// Pipeline = gst_pipeline_new("pipeline");
Playbin = gst_element_factory_make("playbin", "player");
VideoBin = gst_bin_new("SinkBin");
VideoSink = gst_element_factory_make("fakesink", "video_sink");
VideoConvert = gst_element_factory_make("capsfilter", "video_convert");
VideoConvertCaps = gst_caps_from_string("video/x-raw,format=(string)YUY2");
Height = 0;
Width = 0;
if(!Playbin)
{
Logger::Write(Logger::ZONE_DEBUG, "Video", "Could not create playbin");
FreeElements();
return false;
}
if(!VideoSink)
{
Logger::Write(Logger::ZONE_DEBUG, "Video", "Could not create video sink");
FreeElements();
return false;
}
if(!VideoConvert)
{
Logger::Write(Logger::ZONE_DEBUG, "Video", "Could not create video converter");
FreeElements();
return false;
}
if(!VideoConvertCaps)
{
Logger::Write(Logger::ZONE_DEBUG, "Video", "Could not create video caps");
FreeElements();
return false;
}
gst_bin_add_many(GST_BIN(VideoBin), VideoConvert, VideoSink, NULL);
gst_element_link_filtered(VideoConvert, VideoSink, VideoConvertCaps);
GstPad *videoConvertSinkPad = gst_element_get_static_pad(VideoConvert, "sink");
gst_bin_add_many(GST_BIN(VideoBin), VideoConvert, VideoSink, NULL);
gst_element_link_filtered(VideoConvert, VideoSink, VideoConvertCaps);
GstPad *videoConvertSinkPad = gst_element_get_static_pad(VideoConvert, "sink");
if(!videoConvertSinkPad)
{
Logger::Write(Logger::ZONE_DEBUG, "Video", "Could not get video convert sink pad");
FreeElements();
return false;
}
if(!videoConvertSinkPad)
{
Logger::Write(Logger::ZONE_DEBUG, "Video", "Could not get video convert sink pad");
FreeElements();
return false;
}
g_object_set(G_OBJECT(VideoSink), "sync", TRUE, "qos", TRUE, NULL);
g_object_set(G_OBJECT(VideoSink), "sync", TRUE, "qos", TRUE, NULL);
GstPad *videoSinkPad = gst_ghost_pad_new("sink", videoConvertSinkPad);
if(!videoSinkPad)
{
Logger::Write(Logger::ZONE_DEBUG, "Video", "Could not get video bin sink pad");
FreeElements();
gst_object_unref(videoConvertSinkPad);
videoConvertSinkPad = NULL;
return false;
}
GstPad *videoSinkPad = gst_ghost_pad_new("sink", videoConvertSinkPad);
if(!videoSinkPad)
{
Logger::Write(Logger::ZONE_DEBUG, "Video", "Could not get video bin sink pad");
FreeElements();
gst_object_unref(videoConvertSinkPad);
videoConvertSinkPad = NULL;
return false;
}
gst_element_add_pad(VideoBin, videoSinkPad);
gst_object_unref(videoConvertSinkPad);
videoConvertSinkPad = NULL;
gst_element_add_pad(VideoBin, videoSinkPad);
gst_object_unref(videoConvertSinkPad);
videoConvertSinkPad = NULL;
g_object_set(G_OBJECT(Playbin), "uri", file.c_str(), "video-sink", VideoBin, NULL);
g_object_set(G_OBJECT(Playbin), "uri", file.c_str(), "video-sink", VideoBin, NULL);
IsPlaying = true;
IsPlaying = true;
g_object_set(G_OBJECT(VideoSink), "signal-handoffs", TRUE, NULL);
g_signal_connect(VideoSink, "handoff", G_CALLBACK(ProcessNewBuffer), this);
g_object_set(G_OBJECT(VideoSink), "signal-handoffs", TRUE, NULL);
g_signal_connect(VideoSink, "handoff", G_CALLBACK(ProcessNewBuffer), this);
VideoBus = gst_pipeline_get_bus(GST_PIPELINE(Playbin));
gst_bus_add_watch(VideoBus, &BusCallback, this);
VideoBus = gst_pipeline_get_bus(GST_PIPELINE(Playbin));
gst_bus_add_watch(VideoBus, &BusCallback, this);
/* Start playing */
GstStateChangeReturn playState = gst_element_set_state(GST_ELEMENT(Playbin), GST_STATE_PLAYING);
if (playState != GST_STATE_CHANGE_ASYNC)
{
IsPlaying = false;
std::stringstream ss;
ss << "Unable to set the pipeline to the playing state: ";
ss << playState;
Logger::Write(Logger::ZONE_ERROR, "Video", ss.str());
FreeElements();
return false;
}
}
/* Start playing */
GstStateChangeReturn playState = gst_element_set_state(GST_ELEMENT(Playbin), GST_STATE_PLAYING);
if (playState != GST_STATE_CHANGE_ASYNC)
{
IsPlaying = false;
std::stringstream ss;
ss << "Unable to set the pipeline to the playing state: ";
ss << playState;
Logger::Write(Logger::ZONE_ERROR, "Video", ss.str());
FreeElements();
return false;
}
}
return true;
return true;
}
void GStreamerVideo::FreeElements()
{
if(VideoBin)
{
gst_object_unref(VideoBin);
VideoBin = NULL;
}
if(VideoSink)
{
gst_object_unref(VideoSink);
VideoSink = NULL;
}
if(VideoConvert)
{
gst_object_unref(VideoConvert);
VideoConvert = NULL;
}
if(VideoConvertCaps)
{
gst_object_unref(VideoConvertCaps);
VideoConvertCaps = NULL;
}
if(Playbin)
{
gst_object_unref(Playbin);
Playbin = NULL;
}
if(VideoBin)
{
gst_object_unref(VideoBin);
VideoBin = NULL;
}
if(VideoSink)
{
gst_object_unref(VideoSink);
VideoSink = NULL;
}
if(VideoConvert)
{
gst_object_unref(VideoConvert);
VideoConvert = NULL;
}
if(VideoConvertCaps)
{
gst_object_unref(VideoConvertCaps);
VideoConvertCaps = NULL;
}
if(Playbin)
{
gst_object_unref(Playbin);
Playbin = NULL;
}
}
void GStreamerVideo::Draw()
{
FrameReady = false;
FrameReady = false;
}
void GStreamerVideo::Update(float dt)
{
SDL_LockMutex(SDL::GetMutex());
if(!Texture && Width != 0 && Height != 0)
{
Texture = SDL_CreateTexture(SDL::GetRenderer(), SDL_PIXELFORMAT_YUY2,
SDL_TEXTUREACCESS_STREAMING, Width, Height);
SDL_SetTextureBlendMode(Texture, SDL_BLENDMODE_BLEND);
}
SDL_LockMutex(SDL::GetMutex());
if(!Texture && Width != 0 && Height != 0)
{
Texture = SDL_CreateTexture(SDL::GetRenderer(), SDL_PIXELFORMAT_YUY2,
SDL_TEXTUREACCESS_STREAMING, Width, Height);
SDL_SetTextureBlendMode(Texture, SDL_BLENDMODE_BLEND);
}
if(VideoBuffer && FrameReady && Texture && Width && Height)
{
//todo: change to width of cap
void *pixels;
int pitch;
SDL_LockTexture(Texture, NULL, &pixels, &pitch);
memcpy(pixels, VideoBuffer, Width*Height*2); //todo: magic number
SDL_UnlockTexture(Texture);
}
SDL_UnlockMutex(SDL::GetMutex());
if(VideoBuffer && FrameReady && Texture && Width && Height)
{
//todo: change to width of cap
void *pixels;
int pitch;
SDL_LockTexture(Texture, NULL, &pixels, &pitch);
memcpy(pixels, VideoBuffer, Width*Height*2); //todo: magic number
SDL_UnlockTexture(Texture);
}
SDL_UnlockMutex(SDL::GetMutex());
if(VideoBus)
{
GstMessage *msg = gst_bus_pop(VideoBus);
if(msg)
{
if(GST_MESSAGE_TYPE(msg) == GST_MESSAGE_EOS)
{
Logger::Write(Logger::ZONE_ERROR, "Video", "EOS!");
PlayCount++;
//todo: nesting hazard
// if number of loops is 0, set to infinite (todo: this is misleading, rename variable)
if(!NumLoops || NumLoops > PlayCount)
if(VideoBus)
{
GstMessage *msg = gst_bus_pop(VideoBus);
if(msg)
{
if(GST_MESSAGE_TYPE(msg) == GST_MESSAGE_EOS)
{
gst_element_seek(Playbin,
1.0,
GST_FORMAT_TIME,
GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET,
0,
GST_SEEK_TYPE_NONE,
GST_CLOCK_TIME_NONE);
}
}
Logger::Write(Logger::ZONE_ERROR, "Video", "EOS!");
gst_message_unref(msg);
}
}
PlayCount++;
//todo: nesting hazard
// if number of loops is 0, set to infinite (todo: this is misleading, rename variable)
if(!NumLoops || NumLoops > PlayCount)
{
gst_element_seek(Playbin,
1.0,
GST_FORMAT_TIME,
GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET,
0,
GST_SEEK_TYPE_NONE,
GST_CLOCK_TIME_NONE);
}
}
gst_message_unref(msg);
}
}
}

58
Source/Video/GStreamerVideo.h
View File

@ -15,36 +15,36 @@ extern "C"
class GStreamerVideo : public IVideo
{
public:
GStreamerVideo();
~GStreamerVideo();
bool Initialize();
bool Play(std::string file);
bool Stop();
bool DeInitialize();
SDL_Texture *GetTexture() const;
void Update(float dt);
void Draw();
void SetNumLoops(int n);
void FreeElements();
GStreamerVideo();
~GStreamerVideo();
bool Initialize();
bool Play(std::string file);
bool Stop();
bool DeInitialize();
SDL_Texture *GetTexture() const;
void Update(float dt);
void Draw();
void SetNumLoops(int n);
void FreeElements();
private:
static void ProcessNewBuffer (GstElement *fakesink, GstBuffer *buf, GstPad *pad, gpointer data);
static gboolean BusCallback(GstBus *bus, GstMessage *msg, gpointer data);
static void ProcessNewBuffer (GstElement *fakesink, GstBuffer *buf, GstPad *pad, gpointer data);
static gboolean BusCallback(GstBus *bus, GstMessage *msg, gpointer data);
GstElement *Playbin;
GstElement *VideoBin;
GstElement *VideoSink;
GstElement *VideoConvert;
GstCaps *VideoConvertCaps;
GstBus *VideoBus;
SDL_Texture* Texture;
gint Height;
gint Width;
char *VideoBuffer;
bool FrameReady;
bool IsPlaying;
static bool Initialized;
int PlayCount;
std::string CurrentFile;
int NumLoops;
GstElement *Playbin;
GstElement *VideoBin;
GstElement *VideoSink;
GstElement *VideoConvert;
GstCaps *VideoConvertCaps;
GstBus *VideoBus;
SDL_Texture* Texture;
gint Height;
gint Width;
char *VideoBuffer;
bool FrameReady;
bool IsPlaying;
static bool Initialized;
int PlayCount;
std::string CurrentFile;
int NumLoops;
};

16
Source/Video/IVideo.h
View File

@ -9,12 +9,12 @@
class IVideo
{
public:
virtual ~IVideo() {}
virtual bool Initialize() = 0;
virtual bool Play(std::string file) = 0;
virtual bool Stop() = 0;
virtual bool DeInitialize() = 0;
virtual SDL_Texture *GetTexture() const = 0;
virtual void Update(float dt) = 0;
virtual void Draw() = 0;
virtual ~IVideo() {}
virtual bool Initialize() = 0;
virtual bool Play(std::string file) = 0;
virtual bool Stop() = 0;
virtual bool DeInitialize() = 0;
virtual SDL_Texture *GetTexture() const = 0;
virtual void Update(float dt) = 0;
virtual void Draw() = 0;
};

22
Source/Video/VideoFactory.cpp
View File

@ -1,6 +1,6 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
*/
#include "VideoFactory.h"
#include "IVideo.h"
#include "GStreamerVideo.h"
@ -10,24 +10,24 @@ int VideoFactory::NumLoops = 0;
IVideo *VideoFactory::CreateVideo()
{
IVideo *instance = NULL;
IVideo *instance = NULL;
if(Enabled)
{
instance = new GStreamerVideo();
instance->Initialize();
((GStreamerVideo *)(instance))->SetNumLoops(NumLoops);
}
if(Enabled)
{
instance = new GStreamerVideo();
instance->Initialize();
((GStreamerVideo *)(instance))->SetNumLoops(NumLoops);
}
return instance;
return instance;
}
void VideoFactory::SetEnabled(bool enabled)
{
Enabled = enabled;
Enabled = enabled;
}
void VideoFactory::SetNumLoops(int numLoops)
{
NumLoops = numLoops;
NumLoops = numLoops;
}

12
Source/Video/VideoFactory.h
View File

@ -1,6 +1,6 @@
/* This file is subject to the terms and conditions defined in
* file 'LICENSE.txt', which is part of this source code package.
*/
*/
#pragma once
class IVideo;
@ -8,11 +8,11 @@ class IVideo;
class VideoFactory
{
public:
IVideo *CreateVideo();
static void SetEnabled(bool enabled);
static void SetNumLoops(int numLoops);
IVideo *CreateVideo();
static void SetEnabled(bool enabled);
static void SetNumLoops(int numLoops);
private:
static bool Enabled;
static int NumLoops;
static bool Enabled;
static int NumLoops;
};

6
UnitTest/RetroFE/Utility/Utils_UnitTest.cpp
View File

@ -2,11 +2,11 @@
#include "gmock/gmock.h"
#include <Utility/Utils.h>
class UtilsTest : public ::testing::Test
class UtilsTest : public ::testing::Test
{
};
TEST_F(UtilsTest, ConvertsStringToInt)
TEST_F(UtilsTest, ConvertsStringToInt)
{
ASSERT_EQ(5, Utils::ConvertInt("5"));
ASSERT_EQ(5, Utils::ConvertInt("5"));
}