Port from git

Source/CMakeLists.txt

@@ -0,0 +1,224 @@
+cmake_minimum_required (VERSION 2.8)
+
+project (RetroFE)
+
+set(RETROFE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/..)
+set(RETROFE_THIRD_PARTY_DIR "${RETROFE_DIR}/ThirdParty")
+list(APPEND CMAKE_MODULE_PATH "${RETROFE_DIR}/CMake")
+
+##############################################################
+# Setup some variables to help find external libraries
+##############################################################
+
+set(SQLITE3_ROOT "${RETROFE_THIRD_PARTY_DIR}/sqlite3")
+set(RAPIDXML_ROOT "${RETROFE_THIRD_PARTY_DIR}/rapidxml-1.13")
+
+if(WIN32)
+	set(CMAKE_PREFIX_PATH "${RETROFE_DIR}/ThirdParty/win32")
+	set(SDL2_ROOT "${RETROFE_THIRD_PARTY_DIR}/SDL2-2.0.3")
+	set(SDL2_IMAGE_ROOT "${RETROFE_THIRD_PARTY_DIR}/SDL2_image-2.0.0")
+	set(SDL2_MIXER_ROOT "${RETROFE_THIRD_PARTY_DIR}/SDL2_mixer-2.0.0")
+	set(SDL2_TTF_ROOT "${RETROFE_THIRD_PARTY_DIR}/SDL2_ttf-2.0.12")
+	set(ZLIB_ROOT "${RETROFE_THIRD_PARTY_DIR}/zlib128-dll")
+
+	set(GSTREAMER_ROOT "C:/gstreamer/1.0/x86" CACHE STRING "location of where your gstreamer include and lib folders reside")
+	set(GLIB2_ROOT "${GSTREAMER_ROOT}")
+	set(DIRENT_INCLUDE_DIR "${RETROFE_THIRD_PARTY_DIR}/dirent-1.20.1/include")
+endif()
+
+if(MSVC)
+	find_package(Glib2 REQUIRED)
+	find_package(GStreamer REQUIRED)
+	find_package(SDL2 REQUIRED)
+	find_package(SDL2_image REQUIRED)
+	find_package(SDL2_mixer REQUIRED)
+	find_package(SDL2_ttf REQUIRED)
+	find_package(ZLIB REQUIRED)
+else()
+	include(FindPkgConfig)	
+	pkg_search_module(SDL2 REQUIRED sdl2)
+	pkg_search_module(SDL2_IMAGE REQUIRED SDL2_image)
+	pkg_search_module(SDL2_MIXER REQUIRED SDL2_mixer)
+	pkg_search_module(SDL2_TTF REQUIRED SDL2_ttf)
+	pkg_search_module(ZLIB REQUIRED zlib)
+	pkg_search_module(GSTREAMER REQUIRED gstreamer-1.0 gstbase-1.0)
+	pkg_search_module(Glib2 REQUIRED glib-2.0 gobject-2.0 gthread-2.0 gmodule-2.0)
+	find_package(Threads REQUIRED)
+endif()
+
+set(RETROFE_INCLUDE_DIRS
+	"${GLIB2_INCLUDE_DIRS}"
+	"${GSTREAMER_INCLUDE_DIRS}"
+	"${SDL2_INCLUDE_DIRS}"
+	"${SDL2_IMAGE_INCLUDE_DIRS}"
+	"${SDL2_MIXER_INCLUDE_DIRS}"
+	"${SDL2_TTF_INCLUDE_DIRS}"
+	"${ZLIB_INCLUDE_DIRS}"
+	"${SQLITE3_ROOT}"
+	"${RAPIDXML_ROOT}"
+	"${DIRENT_INCLUDE_DIR}"
+)
+
+set(RETROFE_LIBRARIES
+	${GLIB2_LIBRARIES}
+	${GSTREAMER_LIBRARIES}
+	${SDL2_LIBRARIES}
+	${SDL2_IMAGE_LIBRARIES}
+	${SDL2_MIXER_LIBRARIES}
+	${SDL2_TTF_LIBRARIES}
+	${ZLIB_LIBRARIES}
+)
+
+if(NOT MSVC)
+	LIST(APPEND RETROFE_LIBRARIES ${CMAKE_DL_LIBS} ${CMAKE_THREAD_LIBS_INIT})
+endif()
+
+set(RETROFE_HEADERS
+	"${RETROFE_DIR}/Source/Collection/CollectionInfo.h"
+	"${RETROFE_DIR}/Source/Collection/CollectionInfoBuilder.h"
+	"${RETROFE_DIR}/Source/Collection/Item.h"
+	"${RETROFE_DIR}/Source/Collection/MenuParser.h"
+	"${RETROFE_DIR}/Source/Control/UserInput.h"
+	"${RETROFE_DIR}/Source/Database/CollectionDatabase.h"
+	"${RETROFE_DIR}/Source/Database/Configuration.h"
+	"${RETROFE_DIR}/Source/Database/DB.h"
+	"${RETROFE_DIR}/Source/Database/MamelistMetadata.h"
+	"${RETROFE_DIR}/Source/Execute/Launcher.h"
+	"${RETROFE_DIR}/Source/Graphics/Animate/Tween.h"
+	"${RETROFE_DIR}/Source/Graphics/Animate/TweenTypes.h"
+	"${RETROFE_DIR}/Source/Graphics/ComponentItemBinding.h"
+	"${RETROFE_DIR}/Source/Graphics/Component/Component.h"
+	"${RETROFE_DIR}/Source/Graphics/Font.h"
+	"${RETROFE_DIR}/Source/Graphics/FontCache.h"
+	"${RETROFE_DIR}/Source/Graphics/Component/Image.h"
+	"${RETROFE_DIR}/Source/Graphics/Component/Text.h"
+	"${RETROFE_DIR}/Source/Graphics/PageBuilder.h"
+	"${RETROFE_DIR}/Source/Graphics/MenuNotifierInterface.h"
+	"${RETROFE_DIR}/Source/Graphics/Page.h"
+	"${RETROFE_DIR}/Source/Graphics/Component/ImageBuilder.h"
+	"${RETROFE_DIR}/Source/Graphics/Component/ReloadableMedia.h"
+	"${RETROFE_DIR}/Source/Graphics/Component/ReloadableText.h"
+	"${RETROFE_DIR}/Source/Graphics/Component/ScrollingList.h"
+	"${RETROFE_DIR}/Source/Graphics/Component/VideoComponent.h"
+	"${RETROFE_DIR}/Source/Graphics/Component/VideoBuilder.h"
+	"${RETROFE_DIR}/Source/Sound/Sound.h"
+	"${RETROFE_DIR}/Source/Utility/Log.h"
+	"${RETROFE_DIR}/Source/Utility/Utils.h"
+	"${RETROFE_DIR}/Source/Video/IVideo.h"
+	"${RETROFE_DIR}/Source/Video/GStreamerVideo.h"
+	"${RETROFE_DIR}/Source/Video/VideoFactory.h"
+	"${RETROFE_DIR}/Source/Graphics/ComponentItemBindingBuilder.h"
+	"${RETROFE_DIR}/Source/Graphics/ViewInfo.h"
+	"${RETROFE_DIR}/Source/RetroFE.h"
+	"${RETROFE_DIR}/Source/SDL.h"
+	"${RETROFE_DIR}/Source/Version.h"
+)
+
+set(RETROFE_SOURCES
+	"${RETROFE_DIR}/Source/Collection/CollectionInfo.cpp"
+	"${RETROFE_DIR}/Source/Collection/CollectionInfoBuilder.cpp"
+	"${RETROFE_DIR}/Source/Collection/Item.cpp"
+	"${RETROFE_DIR}/Source/Collection/MenuParser.cpp"
+	"${RETROFE_DIR}/Source/Control/UserInput.cpp"
+	"${RETROFE_DIR}/Source/Database/CollectionDatabase.cpp"
+	"${RETROFE_DIR}/Source/Database/Configuration.cpp"
+	"${RETROFE_DIR}/Source/Database/DB.cpp"
+	"${RETROFE_DIR}/Source/Database/MamelistMetadata.cpp"
+	"${RETROFE_DIR}/Source/Execute/Launcher.cpp"
+	"${RETROFE_DIR}/Source/Graphics/Animate/Tween.cpp"
+	"${RETROFE_DIR}/Source/Graphics/Font.cpp"
+	"${RETROFE_DIR}/Source/Graphics/FontCache.cpp"
+	"${RETROFE_DIR}/Source/Graphics/PageBuilder.cpp"
+	"${RETROFE_DIR}/Source/Graphics/Page.cpp"
+	"${RETROFE_DIR}/Source/Graphics/ViewInfo.cpp"
+	"${RETROFE_DIR}/Source/Graphics/ComponentItemBindingBuilder.cpp"
+	"${RETROFE_DIR}/Source/Graphics/ComponentItemBinding.cpp"
+	"${RETROFE_DIR}/Source/Graphics/Component/Component.cpp"
+	"${RETROFE_DIR}/Source/Graphics/Component/Image.cpp"
+	"${RETROFE_DIR}/Source/Graphics/Component/ImageBuilder.cpp"
+	"${RETROFE_DIR}/Source/Graphics/Component/Text.cpp"
+	"${RETROFE_DIR}/Source/Graphics/Component/ReloadableMedia.cpp"
+	"${RETROFE_DIR}/Source/Graphics/Component/ReloadableText.cpp"
+	"${RETROFE_DIR}/Source/Graphics/Component/ScrollingList.cpp"
+	"${RETROFE_DIR}/Source/Graphics/Component/VideoBuilder.cpp"
+	"${RETROFE_DIR}/Source/Graphics/Component/VideoComponent.cpp"
+	"${RETROFE_DIR}/Source/Sound/Sound.cpp"
+	"${RETROFE_DIR}/Source/Utility/Log.cpp"
+	"${RETROFE_DIR}/Source/Utility/Utils.cpp"
+	"${RETROFE_DIR}/Source/Video/GStreamerVideo.cpp"
+	"${RETROFE_DIR}/Source/Video/VideoFactory.cpp"
+	"${RETROFE_DIR}/Source/Main.cpp"
+	"${RETROFE_DIR}/Source/RetroFE.cpp"
+	"${RETROFE_DIR}/Source/SDL.cpp"
+	"${RETROFE_DIR}/Source/Version.cpp"
+	"${SQLITE3_ROOT}/sqlite3.c"
+)
+
+
+set(EXECUTABLE_OUTPUT_PATH "${RETROFE_DIR}/Build" CACHE PATH "Build directory" FORCE)
+set(LIBRARY_OUTPUT_PATH "${RETROFE_DIR}/Build" CACHE PATH "Build directory" FORCE)
+
+
+include_directories(${RETROFE_INCLUDE_DIRS})
+add_executable(RetroFE  ${RETROFE_SOURCES} ${RETROFE_HEADERS})
+target_link_libraries(RetroFE ${RETROFE_LIBRARIES})
+set_target_properties(RetroFE PROPERTIES LINKER_LANGUAGE CXX)
+
+add_definitions(-DRETROFE_VERSION_MAJOR=${VERSION_MAJOR})
+add_definitions(-DRETROFE_VERSION_MINOR=${VERSION_MINOR})
+add_definitions(-DRETROFE_VERSION_BUILD=${VERSION_BUILD})
+
+if(MSVC)
+	set(CMAKE_DEBUG_POSTFIX "d")
+	add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
+	add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP /WX")
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP /WX")
+	set_target_properties(RetroFE PROPERTIES LINK_FLAGS "/SUBSYSTEM:WINDOWS")
+endif()
+
+
+set(RETROFE_OUTPUT_PATH "../Build/Artifacts/RetroFE")
+
+
+ADD_CUSTOM_COMMAND(TARGET RetroFE POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E make_directory "../Build/Artifacts/RetroFE" )    
+
+ADD_CUSTOM_COMMAND(TARGET RetroFE POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_directory "../Assets/Environment/Common" "${RETROFE_OUTPUT_PATH}" )    
+
+if(WIN32)
+set(RETROFE_OUTPUT_CORE_PATH "${RETROFE_OUTPUT_PATH}/Core")
+    file(GLOB CORE_FILES
+	    "${GSTREAMER_ROOT}/lib/*.dll"
+	    "${GSTREAMER_ROOT}/lib/gstreamer-1.0/*.dll"
+	    "${GSTREAMER_ROOT}/bin/*.dll"
+	    "${SDL2_ROOT}/lib/x86/*.dll" 
+	    "${SDL2_IMAGE_ROOT}/lib/x86/*.dll"
+	    "${SDL2_TTF_ROOT}/lib/x86/*.dll"
+	    "${SDL2_MIXER_ROOT}/lib/x86/*.dll"
+	)
+
+	ADD_CUSTOM_COMMAND(TARGET RetroFE POST_BUILD
+		    COMMAND ${CMAKE_COMMAND} -E make_directory "${RETROFE_OUTPUT_CORE_PATH}" )    
+
+	ADD_CUSTOM_COMMAND(TARGET RetroFE POST_BUILD
+		    COMMAND ${CMAKE_COMMAND} -E copy_directory "../Assets/Environment/Windows" "${RETROFE_OUTPUT_PATH}" )    
+
+
+	foreach(CORE_FILE ${CORE_FILES})    
+		ADD_CUSTOM_COMMAND(TARGET RetroFE POST_BUILD
+	    	COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CORE_FILE}" "${RETROFE_OUTPUT_CORE_PATH}" )    
+	endforeach()
+    
+	ADD_CUSTOM_COMMAND(TARGET RetroFE POST_BUILD
+		    COMMAND ${CMAKE_COMMAND} -E copy "../Build/Debug/RetroFE.exe" "${RETROFE_OUTPUT_CORE_PATH}" )    
+
+else()
+	ADD_CUSTOM_COMMAND(TARGET RetroFE POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_directory "../Assets/Environment/Linux" "${RETROFE_OUTPUT_PATH}" )    
+
+	ADD_CUSTOM_COMMAND(TARGET RetroFE POST_BUILD
+		    COMMAND ${CMAKE_COMMAND} -E copy "../Build/RetroFE" "${RETROFE_OUTPUT_PATH}" )    
+endif()
+

Source/Collection/CollectionInfo.cpp

@@ -0,0 +1,67 @@
+/* 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, 
+                               std::string metadataPath)
+: Name(name)
+, ListPath(listPath)
+, Extensions(extensions)
+, MetadataType(metadataType)
+, MetadataPath(metadataPath)
+{
+}
+
+CollectionInfo::~CollectionInfo()
+{
+}
+
+std::string CollectionInfo::GetName() const
+{
+   return Name;
+}
+
+std::string CollectionInfo::GetSettingsPath() const
+{
+   return Configuration::GetAbsolutePath() + "/Collections/" + GetName();
+}
+
+std::string CollectionInfo::GetListPath() const
+{
+   return ListPath;
+}
+
+std::string CollectionInfo::GetMetadataType() const
+{
+   return MetadataType;
+}
+
+std::string CollectionInfo::GetMetadataPath() const
+{
+   return MetadataPath;
+}
+
+std::string CollectionInfo::GetExtensions() const
+{
+   return Extensions;
+}
+
+void CollectionInfo::GetExtensions(std::vector<std::string> &extensions)
+{
+   std::istringstream ss(Extensions);
+   std::string token;
+
+   while(std::getline(ss, token, ','))
+   {
+      extensions.push_back(token);
+   }
+}
+
+
+

Source/Collection/CollectionInfo.h

@@ -0,0 +1,28 @@
+/* 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>
+#include <vector>
+
+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);
+
+private:
+   std::string Name;
+   std::string ListPath;
+   std::string Extensions;
+   std::string MetadataType;
+   std::string MetadataPath;
+};

Source/Collection/CollectionInfoBuilder.cpp

@@ -0,0 +1,126 @@
+#include "CollectionInfoBuilder.h"
+#include "CollectionInfo.h"
+#include "../Database/Configuration.h"
+#include "../Utility/Log.h"
+#include <sstream>
+#include <vector>
+
+CollectionInfoBuilder::CollectionInfoBuilder(Configuration *c)
+: Conf(c)
+{
+}
+
+CollectionInfoBuilder::~CollectionInfoBuilder()
+{
+   std::map<std::string, CollectionInfo *>::iterator it = InfoMap.begin();
+
+   for(it == InfoMap.begin(); it != InfoMap.end(); ++it)
+   {
+      delete it->second;
+   }
+
+   InfoMap.clear();
+}
+
+bool CollectionInfoBuilder::LoadAllCollections()
+{
+   std::vector<std::string> 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;
+   }
+
+   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;
+         }
+      }
+   }
+
+   return retVal;
+}
+
+void CollectionInfoBuilder::GetCollections(std::vector<CollectionInfo *> &collections)
+{
+   std::map<std::string, CollectionInfo *>::iterator InfoMapIt;
+
+   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";
+
+   //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;
+
+   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;
+   }
+
+   (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.";
+
+      Logger::Write(Logger::ZONE_WARNING, "Collections", ss.str());
+   }
+
+   InfoMap[name] = new CollectionInfo(name, listItemsPath, extensions, metadataType, metadataPath);
+
+   return (InfoMap[name] != NULL);
+}

Source/Collection/CollectionInfoBuilder.h

@@ -0,0 +1,25 @@
+/* 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>
+#include <map>
+#include <vector>
+
+class Configuration;
+class CollectionInfo;
+
+class CollectionInfoBuilder
+{
+public:
+   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;
+};

Source/Collection/Item.cpp

@@ -0,0 +1,160 @@
+/* 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"
+#include <sstream>
+#include <algorithm>
+
+Item::Item()
+: NumberPlayers(0)
+, NumberButtons(0)
+, Leaf(true)
+{
+}
+
+Item::~Item()
+{
+}
+
+const std::string Item::GetFileName() const
+{
+   return Utils::GetFileName(FilePath);
+}
+
+const std::string& Item::GetFilePath() const
+{
+   return FilePath;
+}
+
+void Item::SetFilePath(const std::string& filepath)
+{
+   FilePath = filepath;
+}
+
+const std::string& Item::GetLauncher() const
+{
+   return Launcher;
+}
+
+void Item::SetLauncher(const std::string& launcher)
+{
+   Launcher = launcher;
+}
+
+const std::string& Item::GetManufacturer() const
+{
+   return Manufacturer;
+}
+
+void Item::SetManufacturer(const std::string& manufacturer)
+{
+   Manufacturer = manufacturer;
+}
+
+const std::string& Item::GetName() const
+{
+   return Name;
+}
+
+void Item::SetName(const std::string& name)
+{
+   Name = name;
+}
+
+int Item::GetNumberButtons() const
+{
+   return NumberButtons;
+}
+
+std::string Item::GetNumberButtonsString()
+{
+   std::stringstream ss;
+   ss << NumberButtons;
+   return ss.str();
+}
+
+
+void Item::SetNumberButtons(int numberbuttons)
+{
+   NumberButtons = numberbuttons;
+}
+
+int Item::GetNumberPlayers() const
+{
+   return NumberPlayers;
+}
+
+std::string Item::GetNumberPlayersString()
+{
+   std::stringstream ss;
+   ss << NumberButtons;
+   return ss.str();
+}
+
+
+void Item::SetNumberPlayers(int numberplayers)
+{
+   NumberPlayers = numberplayers;
+}
+
+const std::string& Item::GetTitle() const
+{
+   return Title;
+}
+
+const std::string& Item::GetLCTitle() const
+{
+   return LCTitle;
+}
+
+void Item::SetTitle(const std::string& title)
+{
+   Title = title;
+   LCTitle = Title;
+   std::transform(LCTitle.begin(), LCTitle.end(), LCTitle.begin(), ::tolower);
+}
+
+const std::string& Item::GetYear() const
+{
+   return Year;
+}
+
+void Item::SetYear(const std::string& year)
+{
+   Year = year;
+}
+
+bool Item::IsLeaf() const
+{
+   return Leaf;
+}
+
+void Item::SetIsLeaf(bool leaf)
+{
+   Leaf = leaf;
+}
+
+const std::string& Item::GetFullTitle() const
+{
+   return FullTitle;
+}
+
+void Item::SetFullTitle(const std::string& fulltitle)
+{
+   FullTitle = fulltitle;
+}
+
+const std::string& Item::GetCloneOf() const
+{
+	return CloneOf;
+}
+
+void Item::SetCloneOf(const std::string& cloneOf)
+{
+	CloneOf = cloneOf;
+}
+
+bool Item::operator<(const Item &rhs) { return LCTitle < rhs.LCTitle; }
+bool Item::operator>(const Item &rhs) { return LCTitle > rhs.LCTitle; }
+

Source/Collection/Item.h

@@ -0,0 +1,56 @@
+/* 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>
+
+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);
+
+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;
+};
+

Source/Collection/MenuParser.cpp

@@ -0,0 +1,108 @@
+/* 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"
+#include "../Utility/Log.h"
+#include "../Database/Configuration.h"
+#include "../Database/CollectionDatabase.h"
+#include "../Database/DB.h"
+#include <algorithm>
+#include <rapidxml.hpp>
+#include <fstream>
+#include <sstream>
+
+bool VectorSort(const Item *d1, const Item *d2)
+{
+  return d1->GetLCTitle() < d2->GetLCTitle();
+}
+
+MenuParser::MenuParser()
+{
+}
+
+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;
+
+   Logger::Write(Logger::ZONE_INFO, "Menu", "Checking if menu exists at \"" + menuFilename + "\"");
+
+   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>());
+
+         buffer.push_back('\0');
+
+         doc.parse<0>(&buffer[0]);
+
+         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)
+            {
+               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);
+               }
+            }
+         }
+
+         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());
+   }
+
+   return retVal;
+
+}

Source/Collection/MenuParser.h

@@ -0,0 +1,17 @@
+/* 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"
+#include <vector>
+
+class CollectionDatabase;
+
+class MenuParser
+{
+public:
+   MenuParser();
+   virtual ~MenuParser();
+   bool GetMenuItems(CollectionDatabase *cdb, std::string collectionName, std::vector<Item *> &items);
+
+};

Source/Control/UserInput.cpp

@@ -0,0 +1,78 @@
+/* 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)
+{
+}
+
+UserInput::~UserInput()
+{
+}
+
+bool UserInput::Initialize()
+{
+   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("admin", KeyCodeAdminMode) && retVal;
+//   retVal = MapKey("remove", KeyCodeHideItem) && 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);
+
+   if(it != KeyMap.end())
+   {
+      scancode = it->second;
+   }
+
+   return scancode;
+}
+
+
+bool UserInput::MapKey(std::string keyDescription, KeyCode_E key)
+{
+   bool retVal = false;
+   SDL_Scancode scanCode;
+   std::string description;
+
+   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(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;
+}
+

Source/Control/UserInput.h

@@ -0,0 +1,38 @@
+/* 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>
+#include <SDL2/SDL.h>
+#include <string>
+
+class Configuration;
+
+class UserInput
+{
+public:
+   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);
+
+
+private:
+   bool MapKey(std::string keyDescription, KeyCode_E key);
+   std::map<KeyCode_E, SDL_Scancode> KeyMap;
+
+   Configuration *Config;
+};

Source/Database/CollectionDatabase.cpp

@@ -0,0 +1,750 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "CollectionDatabase.h"
+#include "../Collection/CollectionInfoBuilder.h"
+#include "../Collection/CollectionInfo.h"
+#include "../Collection/Item.h"
+#include "../Utility/Log.h"
+#include "../Utility/Utils.h"
+#include "MamelistMetadata.h"
+#include "Configuration.h"
+#include "DB.h"
+#include <algorithm>
+#include <dirent.h>
+#include <fstream>
+#include <list>
+#include <rapidxml.hpp>
+#include <sstream>
+#include <string>
+#include <map>
+#include <sys/types.h>
+#include <sqlite3.h>
+#include <zlib.h>
+#include <exception>
+
+CollectionDatabase::CollectionDatabase(DB *db, Configuration *c)
+: Config(c)
+, DBInstance(db)
+{
+
+}
+
+CollectionDatabase::~CollectionDatabase()
+{
+}
+
+bool CollectionDatabase::ResetDatabase()
+{
+   bool retVal = true;
+   int rc;
+   char *error = NULL;
+   sqlite3 *handle = DBInstance->GetHandle();
+
+   Logger::Write(Logger::ZONE_INFO, "Database", "Erasing");
+
+   std::string sql;
+   sql.append("DROP TABLE IF EXISTS CollectionItems;");
+   sql.append("DROP TABLE IF EXISTS Meta;");
+   sql.append("DROP TABLE IF EXISTS Collections;");
+
+   rc = sqlite3_exec(handle, sql.c_str(), NULL, 0, &error);
+
+   if(rc != SQLITE_OK)
+   {
+      std::stringstream ss;
+      ss << "Unable to create Configurations table. Error: " << error;
+      Logger::Write(Logger::ZONE_ERROR, "Database", ss.str());
+      retVal = false;
+   }
+
+  //CheckDatabase();
+
+   return retVal;
+}
+
+bool CollectionDatabase::CheckDatabase()
+{
+   bool retVal = true;
+   int rc;
+   char *error = NULL;
+   sqlite3 *handle = DBInstance->GetHandle();
+
+   std::string sql;
+   sql.append("CREATE TABLE IF NOT EXISTS CollectionItems(");
+   sql.append("collectionName TEXT KEY,");
+   sql.append("filePath TEXT NOT NULL DEFAULT '',");
+   sql.append("name TEXT NOT NULL DEFAULT '',");
+   sql.append("hidden INT NOT NULL DEFAULT 0);");
+
+   sql.append("CREATE TABLE IF NOT EXISTS Meta(");
+   sql.append("collectionName TEXT KEY,");
+   sql.append("name TEXT NOT NULL DEFAULT '',");
+   sql.append("title TEXT NOT NULL DEFAULT '',");
+   sql.append("year TEXT NOT NULL DEFAULT '',");
+   sql.append("manufacturer TEXT NOT NULL DEFAULT '',");
+   sql.append("cloneOf TEXT NOT NULL DEFAULT '',");
+   sql.append("players INTEGER,");
+   sql.append("buttons INTEGER);");
+   sql.append("CREATE UNIQUE INDEX IF NOT EXISTS MetaUniqueId ON Meta(collectionName, name);");
+
+   sql.append("CREATE TABLE IF NOT EXISTS Collections(");
+   sql.append("collectionName TEXT KEY,");
+   sql.append("crc32 UNSIGNED INTEGER NOT NULL DEFAULT 0);");
+   sql.append("CREATE UNIQUE INDEX IF NOT EXISTS CollectionsUniqueId ON Collections(collectionName);");
+
+   rc = sqlite3_exec(handle, sql.c_str(), NULL, 0, &error);
+
+   if(rc != SQLITE_OK)
+   {
+      std::stringstream ss;
+      ss << "Unable to create Configurations table. Error: " << error;
+      Logger::Write(Logger::ZONE_ERROR, "Database", ss.str());
+
+      retVal = false;
+   }
+
+   return retVal;
+}
+
+
+bool CollectionDatabase::Import()
+{
+   bool retVal = true;
+
+   // should keep allocation here
+   CollectionInfoBuilder cib(Config);
+
+   (void)cib.LoadAllCollections();
+
+   std::vector<CollectionInfo *> collections;
+   cib.GetCollections(collections);
+
+   std::vector<CollectionInfo *>::iterator it;
+   for(it = collections.begin(); it != collections.end() && retVal; ++it)
+   {
+      CollectionInfo *info = *it;
+      std::string title = info->GetName();
+      unsigned long crc32 = CalculateCollectionCrc32(info);
+
+      std::stringstream crcStr;
+      crcStr << crc32;
+
+      if(title != "Main")
+      {
+		  if(CollectionChanged(info, crc32))
+		  {
+			 std::string msg = "Detected collection \"" + title + "\" has changed (new CRC: " + crcStr.str() + "). Rebuilding database for this collection.";
+			 Logger::Write(Logger::ZONE_INFO, "Database", msg);
+
+			 (void)ImportDirectory(info, crc32);
+			 retVal = true;
+		  }
+		  else
+		  {
+			 std::stringstream ss;
+			 std::string msg = "Collection \"" + title + "\" has not changed (CRC: " + crcStr.str() + "). Using existing database settings.";
+			 Logger::Write(Logger::ZONE_INFO, "Database", msg);
+
+		  }
+      }
+      //std::cout << "Importing collection metadata for " << info->GetFullTitle() << " (collections." << info->GetName() << ")" <<  std::endl;
+      //ImportMetadata(info);
+   }
+   Logger::Write(Logger::ZONE_INFO, "Database", "COMPLETE");
+   Sleep(1000);
+   return retVal;
+}
+
+unsigned long CollectionDatabase::CalculateCollectionCrc32(CollectionInfo *info)
+{
+   unsigned long crc = crc32(0L, Z_NULL, 0);
+
+   // start off by reading all of the contents in the collection configuration folders
+   std::string settingsFile = info->GetSettingsPath() + "/Settings.conf";
+   crc = CrcFile(settingsFile, crc);
+
+
+   std::string includeFile = info->GetSettingsPath() + "/Include.txt";
+   crc = CrcFile(includeFile, crc);
+
+   std::string excludeFile = info->GetSettingsPath() + "/Exclude.txt";
+   crc = CrcFile(excludeFile, crc);
+
+   std::string mamelistFile = info->GetSettingsPath() + "/Mamelist.xml";
+   crc = CrcFile(mamelistFile, crc);
+
+   DIR *dp;
+   struct dirent *dirp;
+   std::string path = info->GetListPath();
+   dp = opendir(path.c_str());
+
+   if(dp == NULL)
+   {
+      Logger::Write(Logger::ZONE_ERROR, "Database", "Could not read directory for caching \"" + info->GetListPath() + "\"");
+      return crc;
+   }
+
+   std::vector<std::string> extensions;
+   info->GetExtensions(extensions);
+   std::vector<std::string>::iterator extensionsIt;
+
+   // md5sum each filename for the matching extension
+   while((dirp = readdir(dp)) != NULL)
+   {
+      std::string file = dirp->d_name;
+      for(extensionsIt = extensions.begin(); extensionsIt != extensions.end(); ++extensionsIt)
+      {
+         std::string comparator = "." + *extensionsIt;
+         int start = file.length() - comparator.length() + 1;
+
+         if(start >= 0 && file.compare(start, comparator.length(), *extensionsIt) == 0)
+         {
+            std::string filename = dirp->d_name;
+            filename.append("\n");
+            crc = crc32(crc, (const unsigned char *)filename.c_str(), (unsigned int)filename.length());
+         }
+      }
+   }
+
+   return crc;
+}
+
+unsigned long CollectionDatabase::CrcFile(std::string file, unsigned long crc)
+{
+   // CRC both the filename and its contents
+   crc = crc32(crc, (const unsigned char *)file.c_str(), (unsigned int)file.length());
+   std::ifstream ifFile(file.c_str());
+   if(ifFile.good())
+   {
+      std::stringstream ss;
+      ss << ifFile.rdbuf();
+
+      crc = crc32(crc, (const unsigned char *)ss.str().c_str(), (unsigned int)ss.str().length());
+      Logger::Write(Logger::ZONE_INFO, "Database", "Crcing \"" + file + "\"");
+      ifFile.close();
+   }
+
+   return crc;
+}
+
+bool CollectionDatabase::CollectionChanged(CollectionInfo *info, unsigned long crc32)
+{
+   bool retVal = true;
+
+   sqlite3 *handle = DBInstance->GetHandle();
+   int rc;
+   sqlite3_stmt *stmt;
+
+   sqlite3_prepare_v2(handle,
+            "SELECT crc32 "
+            "FROM Collections WHERE collectionName=? and crc32=?;",
+               -1, &stmt, 0);
+
+   sqlite3_bind_text(stmt, 1, info->GetName().c_str(), -1, SQLITE_TRANSIENT);
+   sqlite3_bind_int(stmt, 2, crc32);
+
+   rc = sqlite3_step(stmt);
+
+   if(rc == SQLITE_ROW)
+   {
+      retVal = false;
+   }
+
+   return retVal;
+}
+
+bool CollectionDatabase::SetHidden(std::string collectionName, Item *item, bool hidden)
+{
+   bool retVal = true;
+   char *error = NULL;
+   sqlite3 *handle = DBInstance->GetHandle();
+   std::string mode = (hidden) ? "hidden":"visible";
+   int isHidden = (hidden)?1:0;
+
+   Logger::Write(Logger::ZONE_DEBUG, "Database", "Marking  \"" + item->GetFullTitle() + "\" " + mode);
+
+   sqlite3_stmt *stmt;
+   sqlite3_prepare_v2(handle,
+               "UPDATE CollectionItems SET hidden=? WHERE collectionName=? AND name=?;",
+               -1, &stmt, 0);
+
+   sqlite3_bind_int(stmt, 1, isHidden);
+   sqlite3_bind_text(stmt, 2, collectionName.c_str(), -1, SQLITE_TRANSIENT);
+   sqlite3_bind_text(stmt, 3, item->GetFullTitle().c_str(), -1, SQLITE_TRANSIENT);
+
+   sqlite3_step(stmt);
+   sqlite3_finalize(stmt);
+
+   sqlite3_exec(handle, "COMMIT TRANSACTION;", NULL, NULL, &error);
+
+   return retVal;
+}
+
+//todo: This file needs MASSIVE REFACTORING!
+bool CollectionDatabase::ImportDirectory(CollectionInfo *info, unsigned long crc32)
+{
+   DIR *dp;
+   struct dirent *dirp;
+   std::string path = info->GetListPath();
+   std::map<std::string, Item *> includeFilter;
+   std::map<std::string, Item *> excludeFilter;
+   std::map<std::string, Item *> includeList;
+   std::map<std::string, Item *> metaList;
+   bool retVal = true;
+   char *error = NULL;
+   sqlite3 *handle = DBInstance->GetHandle();
+   std::string includeFile = Configuration::GetAbsolutePath() + "/Collections/" + info->GetName() + "/Include.txt";
+   std::string excludeFile = Configuration::GetAbsolutePath() + "/Collections/" + info->GetName() + "/Exclude.txt";
+   std::string includeHyperListFile = Configuration::GetAbsolutePath() + "/Collections/" + info->GetName() + "/Include.xml";
+
+   if(!ImportBasicList(info, includeFile, includeFilter))
+   {
+      ImportHyperList(info, includeHyperListFile, includeFilter);
+
+   }
+   //todo: this shouldn't be read twice, perform a copy
+   ImportHyperList(info, includeHyperListFile, metaList);
+
+   (void)ImportBasicList(info, excludeFile, excludeFilter);
+
+   dp = opendir(path.c_str());
+   std::vector<std::string> extensions;
+   info->GetExtensions(extensions);
+   std::vector<std::string>::iterator extensionsIt;
+
+   if(dp == NULL)
+   {
+      Logger::Write(Logger::ZONE_ERROR, "Database", "Could not read directory \"" + info->GetListPath() + "\"");
+      //todo: store into a database
+   }
+   else
+   {
+      while((dirp = readdir(dp)) != NULL)
+      {
+         std::string file = dirp->d_name;
+
+         Utils::NormalizeBackSlashes(file);
+         size_t position = file.find_last_of(".");
+         std::string basename = (std::string::npos == position)? file : file.substr(0, position);
+
+
+         if((includeFilter.size() == 0 || includeFilter.find(basename) != includeFilter.end()) &&
+            (excludeFilter.size() == 0 || excludeFilter.find(basename) == excludeFilter.end()))
+         {
+            for(extensionsIt = extensions.begin(); extensionsIt != extensions.end(); ++extensionsIt)
+            {
+               std::string comparator = "." + *extensionsIt;
+               int start = file.length() - comparator.length() + 1;
+
+               if(start >= 0)
+               {
+                  if(file.compare(start, comparator.length(), *extensionsIt) == 0)
+                  {
+                     if(includeList.find(basename) == includeList.end())
+                     {
+                        Item *i = new Item();
+                        i->SetFullTitle(file);
+                        includeList[basename] = i;
+                     }
+                     if(metaList.find(basename) == metaList.end())
+                     {
+                        Item *i = new Item();
+                        i->SetFullTitle(file);
+                        metaList[basename] = i;
+                     }
+                  }
+               }
+            }
+         }
+      }
+   }
+
+   while(includeFilter.size() > 0)
+   {
+      std::map<std::string, Item *>::iterator it = includeFilter.begin();
+      delete it->second;
+      includeFilter.erase(it);
+   }
+   while(excludeFilter.size() > 0)
+   {
+      std::map<std::string, Item *>::iterator it = excludeFilter.begin();
+      delete it->second;
+      excludeFilter.erase(it);
+   }
+
+
+   Logger::Write(Logger::ZONE_INFO, "Database", "Scanning to import  \"" + path + "\"");
+   sqlite3_exec(handle, "BEGIN IMMEDIATE TRANSACTION;", NULL, NULL, &error);
+
+   sqlite3_stmt *stmt;
+   sqlite3_prepare_v2(handle,
+               "DELETE FROM Collections WHERE collectionName=?;",
+               -1, &stmt, 0);
+   sqlite3_bind_text(stmt, 1, info->GetName().c_str(), -1, SQLITE_TRANSIENT);
+   sqlite3_step(stmt);
+   sqlite3_finalize(stmt);
+
+   sqlite3_prepare_v2(handle,
+               "DELETE FROM CollectionItems WHERE collectionName=?;",
+               -1, &stmt, 0);
+   sqlite3_bind_text(stmt, 1, info->GetName().c_str(), -1, SQLITE_TRANSIENT);
+   sqlite3_step(stmt);
+   sqlite3_finalize(stmt);
+
+   sqlite3_prepare_v2(handle,
+               "DELETE FROM Meta WHERE collectionName=?;",
+               -1, &stmt, 0);
+   sqlite3_bind_text(stmt, 1, info->GetName().c_str(), -1, SQLITE_TRANSIENT);
+   sqlite3_step(stmt);
+   sqlite3_finalize(stmt);
+
+   if(sqlite3_exec(handle, "COMMIT TRANSACTION;", NULL, NULL, &error) != SQLITE_OK)
+   {
+      std::stringstream ss;
+      ss << "Updating cache collection failure " << error;
+      Logger::Write(Logger::ZONE_ERROR, "Database", ss.str());
+      retVal = false;
+   }
+
+   std::map<std::string, Item *>::iterator it;
+
+   if(sqlite3_exec(handle, "BEGIN IMMEDIATE TRANSACTION;", NULL, NULL, &error) != SQLITE_OK)
+   {
+      std::stringstream ss;
+      ss << "Delete cache collection failure " << error;
+      Logger::Write(Logger::ZONE_ERROR, "Database", ss.str());
+      retVal = false;
+   }
+
+   for(it = includeList.begin(); it != includeList.end(); it++)
+   {
+      std::string basename = it->first;
+      Item *file = it->second;
+
+      std::string name = file->GetFullTitle();
+      Utils::NormalizeBackSlashes(name);
+      file->SetFullTitle(name);
+
+      sqlite3_prepare_v2(handle,
+                  "INSERT OR REPLACE INTO CollectionItems (collectionName, filePath, name) VALUES (?,?,?);",
+                  -1, &stmt, 0);
+
+      sqlite3_bind_text(stmt, 1, info->GetName().c_str(), -1, SQLITE_TRANSIENT);
+      sqlite3_bind_text(stmt, 2, file->GetFullTitle().c_str(), -1, SQLITE_TRANSIENT);
+      sqlite3_bind_text(stmt, 3, basename.c_str(), -1, SQLITE_TRANSIENT);
+
+      //todo: better error handling for all of these messages
+      sqlite3_step(stmt);
+      sqlite3_finalize(stmt);
+   }
+   for(it = metaList.begin(); it != metaList.end(); it++)
+   {
+      std::string basename = it->first;
+      Item *file = it->second;
+
+      sqlite3_prepare_v2(handle,
+                  "INSERT OR REPLACE INTO Meta (collectionName, name, title, year, manufacturer, cloneOf, players, buttons) VALUES (?,?,?,?,?,?,?,?);",
+                  -1, &stmt, 0);
+
+      sqlite3_bind_text(stmt, 1, info->GetName().c_str(), -1, SQLITE_TRANSIENT);
+      sqlite3_bind_text(stmt, 2, basename.c_str(), -1, SQLITE_TRANSIENT);
+      sqlite3_bind_text(stmt, 3, basename.c_str(), -1, SQLITE_TRANSIENT);
+      sqlite3_bind_text(stmt, 4, file->GetYear().c_str(), -1, SQLITE_TRANSIENT);
+      sqlite3_bind_text(stmt, 5, file->GetManufacturer().c_str(), -1, SQLITE_TRANSIENT);
+      sqlite3_bind_text(stmt, 6, file->GetCloneOf().c_str(), -1, SQLITE_TRANSIENT);
+      sqlite3_bind_text(stmt, 7, file->GetNumberPlayersString().c_str(), -1, SQLITE_TRANSIENT);
+      sqlite3_bind_text(stmt, 8, file->GetNumberButtonsString().c_str(), -1, SQLITE_TRANSIENT);
+
+      sqlite3_step(stmt);
+      sqlite3_finalize(stmt);
+   }
+
+   sqlite3_prepare_v2(handle,
+               "INSERT OR REPLACE INTO Collections (collectionName, crc32) VALUES (?,?);",
+               -1, &stmt, 0);
+
+   sqlite3_bind_text(stmt, 1, info->GetName().c_str(), -1, SQLITE_TRANSIENT);
+   sqlite3_bind_int(stmt, 2, crc32);
+
+   sqlite3_step(stmt);
+   sqlite3_finalize(stmt);
+
+
+   if(sqlite3_exec(handle, "COMMIT TRANSACTION;", NULL, NULL, &error) != SQLITE_OK)
+   {
+      std::stringstream ss;
+      ss << "Updating cache collection failure " << error;
+      Logger::Write(Logger::ZONE_ERROR, "Database", ss.str());
+      retVal = false;
+   }
+
+   Logger::Write(Logger::ZONE_INFO, "Database", "Imported files from \"" + path + "\" into database");
+
+   //todo: create a helper method to get this file directly (copy paste hazard)
+   std::string mamelistFile = info->GetSettingsPath() + "/Mamelist.xml";
+   std::ifstream infile(mamelistFile.c_str());
+
+   if(infile.good())
+   {
+      Logger::Write(Logger::ZONE_INFO, "Database", "Updating Mamelist metadata for \"" + info->GetName() + "\" (\"" + mamelistFile + "\") into database. This will take a while...");
+      MamelistMetadata mld(DBInstance);
+      mld.Import(mamelistFile, info->GetName());
+   }
+   infile.close();
+
+
+   while(includeList.size() > 0)
+   {
+      std::map<std::string, Item *>::iterator it = includeList.begin();
+      delete it->second;
+      includeList.erase(it);
+   }
+   while(metaList.size() > 0)
+   {
+      std::map<std::string, Item *>::iterator it = metaList.begin();
+      delete it->second;
+      metaList.erase(it);
+   }
+   return retVal;
+}
+
+bool CollectionDatabase::ImportBasicList(CollectionInfo *info, std::string file, std::map<std::string, Item *> &list)
+{
+   bool retVal = false;
+
+   Logger::Write(Logger::ZONE_DEBUG, "Database", "Checking to see if \"" + file + "\" exists");
+
+   std::ifstream includeStream(file.c_str());
+
+   if (includeStream.good())
+   {
+	  Logger::Write(Logger::ZONE_DEBUG, "Database", "Importing \"" + file + "\"");
+      std::string line;
+
+      while(std::getline(includeStream, line))
+      {
+         if(list.find(line) == list.end())
+         {
+            Item *i = new Item();
+            line.erase( std::remove(line.begin(), line.end(), '\r'), line.end() );
+
+            i->SetFullTitle(line);
+            list[line] = i;
+            Logger::Write(Logger::ZONE_DEBUG, "Database", "Including \"" + line + "\" (if file exists)");
+         }
+      }
+
+      retVal = true;
+   }
+
+   return retVal;
+}
+bool CollectionDatabase::ImportHyperList(CollectionInfo *info, std::string hyperlistFile, std::map<std::string, Item *> &list)
+{
+   bool retVal = false;
+   rapidxml::xml_document<> doc;
+   std::ifstream file(hyperlistFile.c_str());
+   std::vector<char> buffer((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+
+   Logger::Write(Logger::ZONE_DEBUG, "Database", "Checking to see if \"" + hyperlistFile + "\" exists");
+
+   if(!file.good())
+   {
+      Logger::Write(Logger::ZONE_INFO, "Database", "Could not find HyperList file: " + hyperlistFile);
+      return retVal;
+   }
+
+   try
+   {
+	  Logger::Write(Logger::ZONE_INFO, "Database", "Importing: " + hyperlistFile);
+      buffer.push_back('\0');
+
+      doc.parse<0>(&buffer[0]);
+
+      rapidxml::xml_node<> *root = doc.first_node("menu");
+
+
+      if(!root)
+      {
+         Logger::Write(Logger::ZONE_ERROR, "CollectionDatabase", "Does not appear to be a HyperList file (missing <menu> tag)");
+         return NULL;
+      }
+      else
+      {
+         for(rapidxml::xml_node<> *game = root->first_node("game"); game; game = game->next_sibling("game"))
+         {
+            rapidxml::xml_attribute<> *nameXml = game->first_attribute("name");
+            rapidxml::xml_node<> *descriptionXml = game->first_node("description");
+            rapidxml::xml_node<> *cloneofXml = game->first_node("cloneof");
+            rapidxml::xml_node<> *crcXml = game->first_node("crc");
+            rapidxml::xml_node<> *manufacturerXml = game->first_node("manufacturer");
+            rapidxml::xml_node<> *yearXml = game->first_node("year");
+            rapidxml::xml_node<> *genreXml = game->first_node("genre");
+            rapidxml::xml_node<> *ratingXml = game->first_node("rating");
+            rapidxml::xml_node<> *enabledXml = game->first_node("enabled");
+            std::string name = (nameXml) ? nameXml->value() : "";
+            std::string description = (descriptionXml) ? descriptionXml->value() : "";
+            std::string crc = (crcXml) ? crcXml->value() : "";
+            std::string cloneOf = (cloneofXml) ? cloneofXml->value() : "";
+            std::string manufacturer = (manufacturerXml) ? manufacturerXml->value() : "";
+            std::string year = (yearXml) ? yearXml->value() : "";
+            std::string genre = (genreXml) ? genreXml->value() : "";
+            std::string rating = (ratingXml) ? ratingXml->value() : "";
+            std::string enabled = (enabledXml) ? enabledXml->value() : "";
+
+            if(name.length() > 0 && list.find(name) == list.end())
+            {
+               Item *i = new Item();
+               i->SetFullTitle(name);
+               i->SetYear(year);
+               i->SetManufacturer(manufacturer);
+               i->SetCloneOf(cloneOf);
+               list[name] = i;
+               Logger::Write(Logger::ZONE_DEBUG, "Database", "Including \"" + name + "\" (if file exists)");
+            }
+
+         }
+      }
+   }
+   catch(rapidxml::parse_error &e)
+   {
+      std::string what = e.what();
+      long line = static_cast<long>(std::count(&buffer.front(), e.where<char>(), char('\n')) + 1);
+      std::stringstream ss;
+      ss << "Could not parse layout file. [Line: " << line << "] Reason: " << e.what();
+
+      Logger::Write(Logger::ZONE_ERROR, "Layout", ss.str());
+   }
+   catch(std::exception &e)
+   {
+      std::string what = e.what();
+      Logger::Write(Logger::ZONE_ERROR, "Layout", "Could not parse layout file. Reason: " + what);
+   }
+
+
+   return retVal;
+}
+
+/*
+bool CollectionDatabase::ImportMetadata(CollectionInfo *info)
+{
+   bool retVal = true;
+   std::string type = info->GetMetadataType();
+
+   if(type.compare("mamelist") == 0)
+   {
+      MamelistMetadata meta;
+      //todo: pass in collectionName
+      retVal = meta.Import(info->GetMetadataPath(), "arcade");
+   }
+   else if(!type.empty())
+   {
+      std::stringstream ss;
+      ss << "Unsupported metadata type \"" << type << "\" for " << info->GetFullTitle() << " (collections." << info->GetName() << ".metadata.type)" << std::endl;
+   Log::Write(Log::ERROR, "Database", ss.str());
+
+      retVal = false;
+   }
+
+   return retVal;
+}
+*/
+
+bool CollectionDatabase::GetCollection(std::string collectionName, std::vector<Item *> &list)
+{
+   bool retVal = true;
+
+   sqlite3 *handle = DBInstance->GetHandle();
+   int rc;
+   sqlite3_stmt *stmt;
+
+   bool showParenthesis = true;
+   bool showSquareBrackets = true;
+
+   (void)Config->GetProperty("showParenthesis", showParenthesis);
+   (void)Config->GetProperty("showSquareBrackets", showSquareBrackets);
+
+   //todo: program crashes if this query fails
+   sqlite3_prepare_v2(handle,
+            "SELECT DISTINCT CollectionItems.filePath, CollectionItems.name, Meta.title, Meta.year, Meta.manufacturer, Meta.players, Meta.buttons, Meta.cloneOf "
+            "FROM CollectionItems, Meta WHERE CollectionItems.collectionName=? AND Meta.collectionName=? AND CollectionItems.name=Meta.name  AND CollectionItems.hidden=0 ORDER BY title ASC;",
+               -1, &stmt, 0);
+
+   sqlite3_bind_text(stmt, 1, collectionName.c_str(), -1, SQLITE_TRANSIENT);
+   sqlite3_bind_text(stmt, 2, collectionName.c_str(), -1, SQLITE_TRANSIENT);
+
+   rc = sqlite3_step(stmt);
+
+   while(rc == SQLITE_ROW)
+   {
+      std::string filePath = (char *)sqlite3_column_text(stmt, 0);
+      std::string name = (char *)sqlite3_column_text(stmt, 1);
+      std::string fullTitle = (char *)sqlite3_column_text(stmt, 2);
+      std::string year = (char *)sqlite3_column_text(stmt, 3);
+      std::string manufacturer = (char *)sqlite3_column_text(stmt, 4);
+      int numberPlayers = (int)sqlite3_column_int(stmt, 5);
+      int numberButtons = (int)sqlite3_column_int(stmt, 6);
+      std::string cloneOf = (char *)sqlite3_column_text(stmt, 7);
+      std::string launcher;
+      std::string title = fullTitle;
+
+      if(!showParenthesis)
+      {
+         std::string::size_type firstPos  = title.find_first_of("(");
+         std::string::size_type secondPos = title.find_first_of(")", firstPos);
+
+         while(firstPos != std::string::npos && secondPos != std::string::npos)
+         {
+            firstPos  = title.find_first_of("(");
+            secondPos = title.find_first_of(")", firstPos);
+
+            if (firstPos != std::string::npos)
+            {
+                title.erase(firstPos, (secondPos - firstPos) + 1);
+            }
+         }
+      }
+      if(!showSquareBrackets)
+      {
+         std::string::size_type firstPos  = title.find_first_of("[");
+         std::string::size_type secondPos = title.find_first_of("]", firstPos);
+
+         while(firstPos != std::string::npos && secondPos != std::string::npos)
+         {
+            firstPos  = title.find_first_of("[");
+            secondPos = title.find_first_of("]", firstPos);
+
+            if (firstPos != std::string::npos && secondPos != std::string::npos)
+            {
+                title.erase(firstPos, (secondPos - firstPos) + 1);
+            }
+         }
+      }
+
+      Item *item = new Item();
+      item->SetFilePath(filePath);
+      item->SetName(name);
+      item->SetTitle(title);
+      item->SetFullTitle(fullTitle);
+      item->SetYear(year);
+      item->SetManufacturer(manufacturer);
+      item->SetNumberPlayers(numberPlayers);
+      item->SetNumberButtons(numberButtons);
+      item->SetCloneOf(cloneOf);
+
+      //std::cout << "loading " << title << std::endl;
+      if(Config->GetProperty("collections." + collectionName + ".launcher", launcher))
+      {
+    	  item->SetLauncher(launcher);
+      }
+
+      list.push_back(item);
+
+      rc = sqlite3_step(stmt);
+   }
+
+   //todo: query the metadata table to populate each item
+
+   return retVal;
+}

Source/Database/CollectionDatabase.h

@@ -0,0 +1,44 @@
+/* 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>
+#include <vector>
+#include <map>
+
+class DB;
+class Configuration;
+class CollectionInfo;
+class Item;
+
+class CollectionDatabase
+{
+public:
+   CollectionDatabase(DB *db, Configuration *c);
+   virtual ~CollectionDatabase();
+   bool Import();
+   bool ResetDatabase();
+   bool CheckDatabase();
+
+
+   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);
+
+//   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;
+};

Source/Database/Configuration.cpp

@@ -0,0 +1,295 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "Configuration.h"
+#include "../Utility/Log.h"
+#include "../Utility/Utils.h"
+#include <algorithm>
+#include <locale>
+#include <fstream>
+#include <sstream>
+
+std::string Configuration::AbsolutePath;
+
+Configuration::Configuration()
+: Verbose(false)
+{
+}
+
+Configuration::~Configuration()
+{
+}
+
+bool Configuration::Import(std::string keyPrefix, std::string file)
+{
+   bool retVal = true;
+   int lineCount = 0;
+   std::string line;
+
+   Logger::Write(Logger::ZONE_INFO, "Configuration", "Importing " + file);
+
+   std::ifstream ifs(file.c_str());
+
+   if (!ifs.is_open())
+   {
+      Logger::Write(Logger::ZONE_ERROR, "Configuration", "Could not open " + file);
+
+      return false;
+   }
+
+   while (std::getline (ifs, line))
+   {
+      lineCount++;
+      retVal = retVal && ParseLine(keyPrefix, line, lineCount);
+   }
+
+   ifs.close();
+
+   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 = "=";
+
+   // 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 = TrimEnds(key);
+
+
+      value = line.substr(position + delimiter.length(), line.length());
+      value = TrimEnds(value);
+
+
+      Properties.insert(PropertiesPair(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());
+   }
+
+   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");
+
+   if(trimStart != std::string::npos)
+   {
+      size_t trimEnd = str.find_last_not_of(" \t");
+
+      str = str.substr(trimStart, trimEnd - trimStart + 1);
+   }
+
+   return str;
+}
+
+bool Configuration::GetProperty(std::string key, std::string &value)
+{
+   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);
+   }
+
+
+   return retVal;
+}
+
+bool Configuration::GetProperty(std::string key, int &value)
+{
+   std::string strValue;
+
+   bool retVal = GetProperty(key, strValue);
+
+   if(retVal)
+   {
+      std::stringstream ss;
+      ss << strValue;
+      ss >> value;
+   }
+
+   return retVal;
+}
+
+bool Configuration::GetProperty(std::string key, bool &value)
+{
+   std::string strValue;
+
+   bool retVal = GetProperty(key, 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);
+      }
+
+      if(!strValue.compare("yes") || !strValue.compare("true"))
+      {
+         value = true;
+      }
+      else
+      {
+         value = false;
+      }
+   }
+
+   return retVal;
+}
+
+void Configuration::SetProperty(std::string key, std::string value)
+{
+   Properties[key] = value;
+}
+
+bool Configuration::PropertyExists(std::string key)
+{
+   return (Properties.find(key) != Properties.end());
+}
+
+bool Configuration::PropertyPrefixExists(std::string key)
+{
+   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;
+      }
+   }
+
+   return false;
+}
+
+void Configuration::GetChildKeyCrumbs(std::string parent, std::vector<std::string> &children)
+{
+   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, "");
+
+         std::size_t end = crumb.find_first_of(".");
+
+         if(end != std::string::npos)
+         {
+            crumb = crumb.substr(0, end);
+         }
+
+         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 = ' ';
+
+   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;
+   }
+
+   return path;
+}
+
+bool Configuration::GetPropertyAbsolutePath(std::string key, std::string &value)
+{
+   bool retVal = GetProperty(key, value);
+
+   if(retVal)
+   {
+      value = ConvertToAbsolutePath(GetAbsolutePath(), value);
+   }
+
+   return retVal;
+}
+
+void Configuration::SetAbsolutePath(std::string absolutePath)
+{
+   AbsolutePath = absolutePath;
+}
+
+std::string Configuration::GetAbsolutePath()
+{
+   return AbsolutePath;
+}
+
+bool Configuration::IsVerbose() const
+{
+   return Verbose;
+}
+
+void Configuration::SetVerbose(bool verbose)
+{
+   this->Verbose = verbose;
+}
+
+

Source/Database/Configuration.h

@@ -0,0 +1,43 @@
+/* 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>
+#include <map>
+#include <vector>
+
+class Configuration
+{
+public:
+   Configuration();
+   virtual ~Configuration();
+
+   // 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);
+	static void SetAbsolutePath(std::string absolutePath);
+	static std::string GetAbsolutePath();
+	static std::string ConvertToAbsolutePath(std::string prefix, std::string path);
+	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;
+
+	static std::string AbsolutePath;
+	PropertiesType Properties;
+};

Source/Database/DB.cpp

@@ -0,0 +1,50 @@
+/* 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 "Configuration.h"
+#include "../Utility/Log.h"
+
+#include <sstream>
+#include <fstream>
+
+DB::DB()
+: Path(Configuration::GetAbsolutePath() + "/cache.db")
+, Handle(NULL)
+{
+}
+
+DB::~DB()
+{
+   DeInitialize();
+}
+
+bool DB::Initialize()
+{
+   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;
+   }
+
+   return retVal;
+}
+
+
+void DB::DeInitialize()
+{
+   if(Handle != NULL)
+   {
+      sqlite3_close(Handle);
+      Handle = NULL;
+   }
+}
+

Source/Database/DB.h

@@ -0,0 +1,21 @@
+/* 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 <sqlite3.h>
+#include <string>
+class DB
+{
+public:
+   DB();
+   bool Initialize();
+   void DeInitialize();
+   virtual ~DB();
+   sqlite3 *GetHandle() { return Handle; }
+
+private:
+   sqlite3 *Handle;
+   std::string Path;
+};
+

Source/Database/MamelistMetadata.cpp

@@ -0,0 +1,119 @@
+/* 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"
+#include "../Utility/Log.h"
+#include "Metadata.h"
+#include <rapidxml.hpp>
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <sqlite3.h>
+
+
+MamelistMetadata::MamelistMetadata(DB *dbInstance)
+: DBInstance(dbInstance)
+{
+}
+
+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();
+
+   std::ifstream f(filename.c_str());
+
+   if (!f.good())
+   {
+      Logger::Write(Logger::ZONE_ERROR, "Mamelist", "Could not find mamelist metadata file at \"" + filename + "\"");
+
+      retVal = false;
+   }
+
+   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>());
+
+      buffer.push_back('\0');
+
+      doc.parse<0>(&buffer[0]);
+
+      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");
+
+         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;
+
+           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(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_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_exec(handle, "COMMIT TRANSACTION;", NULL, NULL, &error);
+
+   }
+
+
+
+   return retVal;
+}

Source/Database/MamelistMetadata.h

@@ -0,0 +1,18 @@
+/* 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 "Metadata.h"
+
+class DB;
+
+class MamelistMetadata : Metadata
+{
+public:
+   MamelistMetadata(DB *dbInstance);
+   virtual ~MamelistMetadata();
+   bool Import(std::string file, std::string collectionName);
+private:
+   DB *DBInstance;
+};

Source/Database/Metadata.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <string>
+
+class Metadata
+{
+public:
+   virtual ~Metadata() {}
+   virtual bool Import(std::string file, std::string collectionName) = 0;
+};

Source/Execute/Launcher.cpp

@@ -0,0 +1,326 @@
+/* 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"
+#include "../Utility/Log.h"
+#include "../Database/Configuration.h"
+#include "../Utility/Utils.h"
+#include "../RetroFE.h"
+#include "../SDL.h"
+#include <cstdlib>
+#include <locale>
+#include <sstream>
+#include <fstream>
+#ifdef WIN32
+#include <windows.h>
+#include <cstring>
+#endif
+
+Launcher::Launcher(RetroFE *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;
+
+   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);
+
+   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;
+   }
+
+   return true;
+}
+
+std::string Launcher::ReplaceVariables(std::string str,
+         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());
+#ifdef WIN32
+   str = Utils::Replace(str, "%RETROFE_EXEC_PATH%", Configuration::GetAbsolutePath() + "/RetroFE.exe");
+#else
+   str = Utils::Replace(str, "%RETROFE_EXEC_PATH%", Configuration::GetAbsolutePath() + "/RetroFE");
+#endif
+
+   return str;
+}
+
+bool Launcher::ExecuteCommand(std::string executable, std::string args, std::string currentDirectory)
+{
+	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);
+
+   //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;
+
+   if(!CreateProcess(NULL, applicationName, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &startupInfo, &processInfo))
+#else
+   if(system(executionString.c_str()) != 0)
+#endif
+   {
+      Logger::Write(Logger::ZONE_ERROR, "Launcher", "Failed to run: " + executable);
+   }
+
+   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);
+         }
+      }
+
+      // result = GetExitCodeProcess(processInfo.hProcess, &exitCode);
+      CloseHandle(processInfo.hProcess);
+#endif
+	   retVal = true;
+   }
+
+   Logger::Write(Logger::ZONE_INFO, "Launcher", "Completed");
+   RetroFEInst->LaunchExit();
+
+   return retVal;
+}
+
+bool Launcher::GetLauncherName(std::string &launcherName, std::string collection)
+{
+   std::string launcherKey = "collections." + collection + ".launcher";
+
+   // 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
+            << "\")";
+
+      Logger::Write(Logger::ZONE_ERROR, "Launcher", ss.str());
+
+      return false;
+   }
+
+   std::stringstream ss;
+   ss        << "collections."
+             << collection
+             << " is configured to use launchers."
+             << launcherName
+             << "\"";
+
+   Logger::Write(Logger::ZONE_DEBUG, "Launcher", ss.str());
+
+   return true;
+}
+
+
+
+bool Launcher::GetLauncherExecutable(std::string &executable, std::string &currentDirectory, std::string launcherName)
+{
+   std::string executableKey = "launchers." + launcherName + ".executable";
+
+   if(!Config->GetProperty(executableKey, executable))
+   {
+      return false;
+   }
+
+   std::string currentDirectoryKey = "launchers." + launcherName + ".currentDirectory";
+   currentDirectory = Utils::GetDirectory(executable);
+
+   Config->GetProperty(currentDirectoryKey, currentDirectory);
+
+   return true;
+}
+
+bool Launcher::GetLauncherArgs(std::string &args, std::string launcherName)
+{
+   std::string argsKey = "launchers." + launcherName + ".arguments";
+
+   if(!Config->GetProperty(argsKey, args))
+   {
+      Logger::Write(Logger::ZONE_ERROR, "Launcher", "No arguments specified for: " + argsKey);
+
+      return false;
+   }
+   return true;
+}
+
+bool Launcher::GetExtensions(std::string &extensions, std::string collection)
+{
+   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;
+   }
+
+   extensions = Utils::Replace(extensions, " ", "");
+   extensions = Utils::Replace(extensions, ".", "");
+
+   return true;
+}
+
+bool Launcher::GetCollectionDirectory(std::string &directory, std::string collection)
+{
+   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 + "/";
+   }
+
+   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;
+
+   while(!fileFound && std::getline(ss, extension, ',') )
+   {
+      std::string selectedItemsPath = directory + filenameWithoutExtension + "." + extension;
+      std::ifstream f(selectedItemsPath.c_str());
+
+      if (f.good())
+      {
+         std::stringstream ss;
+
+         ss        <<"Checking to see if \""
+                   << selectedItemsPath << "\" exists  [Yes]";
+
+          fileFound = true;
+
+          Logger::Write(Logger::ZONE_INFO, "Launcher", ss.str());
+
+          foundFilePath = selectedItemsPath;
+          foundFilename = extension;
+      }
+      else
+      {
+         std::stringstream ss;
+
+         ss        << "Checking to see if \""
+                   << selectedItemsPath << "\" exists  [No]";
+
+         Logger::Write(Logger::ZONE_WARNING, "Launcher", ss.str());
+      }
+
+      f.close();
+   }
+
+   // get the launchers executable
+
+   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());
+
+   }
+
+   return fileFound;
+}
+
+

Source/Execute/Launcher.h

@@ -0,0 +1,40 @@
+/* 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>
+
+class Configuration;
+class Item;
+class RetroFE;
+
+class Launcher
+{
+public:
+	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);
+
+   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;
+};

Source/Graphics/Animate/Tween.cpp

@@ -0,0 +1,370 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "Tween.h"
+#include <algorithm>
+#define _USE_MATH_DEFINES
+#include <math.h>
+#include <string>
+
+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)
+{
+}
+
+TweenProperty Tween::GetProperty() const
+{
+   return Property;
+}
+
+
+bool Tween::GetTweenProperty(std::string name, TweenProperty &property)
+{
+   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;
+   }
+
+   std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+
+   if(TweenPropertyMap.find(name) != TweenPropertyMap.end())
+   {
+      property = TweenPropertyMap[name];
+      retVal = true;
+   }
+
+   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;
+	}
+
+	std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+
+	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);
+}
+
+//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;
+
+   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_INOUT_QUADRATIC:
+         result = EaseInOutQuadratic(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_INOUT_CUBIC:
+         result = EaseInOutCubic(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_INOUT_QUARTIC:
+         result = EaseInOutQuartic(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_INOUT_QUINTIC:
+         result = EaseInOutQuintic(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_INOUT_SINE:
+         result = EaseInOutSine(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_INOUT_EXPONENTIAL:
+         result = EaseInOutExponential(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_INOUT_CIRCULAR:
+         result = EaseInOutCircular(elapsedTime, duration, a, b);
+         break;
+
+      case LINEAR:
+      default:
+         result = Linear(elapsedTime, duration, a, b);
+         break;
+   }
+
+   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;
+};
+
+double Tween::EaseInQuadratic(double t, double d, double b, double c)
+{
+	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;
+};
+
+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;
+};
+
+double Tween::EaseInCubic(double t, double d, double b, double c)
+{
+	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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+
+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;
+};
+
+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;
+};
+
+double Tween::EaseInSine(double t, double d, double b, double c)
+{
+	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;
+};
+
+double Tween::EaseInOutSine(double t, double d, double b, double c)
+{
+	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;
+};
+
+double Tween::EaseOutExponential(double t, double d, double b, double c)
+{
+	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;
+};
+
+double Tween::EaseInCircular(double t, double d, double b, double c)
+{
+	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;
+};
+
+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;
+}
+;
+
+//todo: sdl requires floats, should the casting be done at this layer?
+float Tween::GetDuration() const
+{
+   return static_cast<float>(Duration);
+}

Source/Graphics/Animate/Tween.h

@@ -0,0 +1,55 @@
+/* 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 "TweenTypes.h"
+#include <string>
+#include <map>
+
+class ViewInfo;
+
+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;
+
+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 std::map<std::string, TweenAlgorithm> TweenTypeMap;
+   static std::map<std::string, TweenProperty> TweenPropertyMap;
+   TweenProperty Property;
+   TweenAlgorithm Type;
+   double Start;
+   double End;
+   double Duration;
+};

Source/Graphics/Animate/TweenTypes.h

@@ -0,0 +1,45 @@
+/* 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,
+};
+
+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
+};

Source/Graphics/Component/Component.cpp

@@ -0,0 +1,282 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "Component.h"
+#include "../Animate/Tween.h"
+#include "../../Graphics/ViewInfo.h"
+#include "../../Utility/Log.h"
+
+Component::Component()
+{
+   OnEnterTweens = NULL;
+   OnExitTweens = NULL;
+   OnIdleTweens = NULL;
+   OnHighlightEnterTweens = NULL;
+   OnHighlightExitTweens = NULL;
+   SelectedItem = NULL;
+   NewItemSelectedSinceEnter = false;
+   FreeGraphicsMemory();
+
+}
+
+Component::~Component()
+{
+   FreeGraphicsMemory();
+}
+
+void Component::FreeGraphicsMemory()
+{
+   CurrentAnimationState = HIDDEN;
+   EnterRequested = false;
+   ExitRequested = false;
+   NewItemSelected = false;
+   HighlightExitComplete = false;
+   CurrentTweens = NULL;
+   CurrentTweenIndex = 0;
+   CurrentTweenComplete = false;
+   ElapsedTweenTime =0;
+   ScrollActive = false;
+}
+void Component::AllocateGraphicsMemory()
+{
+}
+
+void Component::TriggerEnterEvent()
+{
+   EnterRequested = true;
+}
+
+void Component::TriggerExitEvent()
+{
+   ExitRequested = true;
+}
+
+void Component::TriggerHighlightEvent(Item *selectedItem)
+{
+   NewItemSelected = true;
+   this->SelectedItem = selectedItem;
+}
+
+
+bool Component::IsIdle()
+{
+	return (CurrentAnimationState == IDLE);
+}
+
+bool Component::IsHidden()
+{
+   return (CurrentAnimationState == HIDDEN);
+}
+bool Component::IsWaiting()
+{
+   return (CurrentAnimationState == HIGHLIGHT_WAIT);
+}
+
+
+
+void Component::Update(float dt)
+{
+	ElapsedTweenTime += dt;
+	HighlightExitComplete = false;
+   if(IsHidden() || IsWaiting() || (IsIdle() && ExitRequested))
+   {
+      CurrentTweenComplete = true;
+   }
+
+   if(CurrentTweenComplete)
+   {
+	   CurrentTweens = NULL;
+
+      // 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:
+            CurrentTweens = NULL;
+            CurrentAnimationState = HIDDEN;
+
+            break;
+
+         case HIGHLIGHT_ENTER:
+            CurrentTweens = OnIdleTweens;
+            CurrentAnimationState = IDLE;
+            break;
+
+         case IDLE:
+            // prevent us from automatically jumping to the exit tween upon enter
+            if(EnterRequested)
+            {
+               EnterRequested = false;
+               NewItemSelected = false;
+            }
+            else if(IsScrollActive() || NewItemSelected || ExitRequested)
+            {
+               CurrentTweens = OnHighlightExitTweens;
+               CurrentAnimationState = HIGHLIGHT_EXIT;
+            }
+            else
+            {
+               CurrentTweens = OnIdleTweens;
+               CurrentAnimationState = IDLE;
+            }
+            break;
+
+         case HIGHLIGHT_EXIT:
+
+            // intentionally break down
+         case HIGHLIGHT_WAIT:
+
+            if(ExitRequested && (CurrentAnimationState == HIGHLIGHT_WAIT))
+            {
+               CurrentTweens = OnHighlightExitTweens;
+               CurrentAnimationState = HIGHLIGHT_EXIT;
+
+            }
+            else if(ExitRequested && (CurrentAnimationState == HIGHLIGHT_EXIT))
+            {
+
+               CurrentTweens = OnExitTweens;
+               CurrentAnimationState = EXIT;
+               ExitRequested = false;
+            }
+            else if(IsScrollActive())
+            {
+               CurrentTweens = NULL;
+               CurrentAnimationState = HIGHLIGHT_WAIT;
+            }
+            else if(NewItemSelected)
+            {
+               CurrentTweens = OnHighlightEnterTweens;
+               CurrentAnimationState = HIGHLIGHT_ENTER;
+               HighlightExitComplete = true;
+               NewItemSelected = false;
+            }
+            else
+            {
+               CurrentTweens = NULL;
+               CurrentAnimationState = HIGHLIGHT_WAIT;
+            }
+            break;
+
+         case HIDDEN:
+            if(EnterRequested || ExitRequested)
+            {
+               CurrentTweens = OnEnterTweens;
+               CurrentAnimationState = ENTER;
+            }
+            else
+            {
+               CurrentTweens = NULL;
+               CurrentAnimationState = HIDDEN;
+            }
+      }
+
+	   CurrentTweenIndex = 0;
+      CurrentTweenComplete = false;
+
+      ElapsedTweenTime = 0;
+	}
+
+   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);
+
+	   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();
+	      }
+
+	      float value = tween->Animate(elapsedTime);
+
+	      switch(tween->GetProperty())
+	      {
+         case TWEEN_PROPERTY_X:
+            GetBaseViewInfo()->SetX(value);
+            break;
+
+         case TWEEN_PROPERTY_Y:
+            GetBaseViewInfo()->SetY(value);
+            break;
+
+         case TWEEN_PROPERTY_HEIGHT:
+            GetBaseViewInfo()->SetHeight(value);
+            break;
+
+         case TWEEN_PROPERTY_WIDTH:
+            GetBaseViewInfo()->SetWidth(value);
+            break;
+
+         case TWEEN_PROPERTY_ANGLE:
+            GetBaseViewInfo()->SetAngle(value);
+            break;
+
+         case TWEEN_PROPERTY_TRANSPARENCY:
+            GetBaseViewInfo()->SetTransparency(value);
+            break;
+
+         case TWEEN_PROPERTY_X_ORIGIN:
+            GetBaseViewInfo()->SetXOrigin(value);
+            break;
+
+         case TWEEN_PROPERTY_Y_ORIGIN:
+            GetBaseViewInfo()->SetYOrigin(value);
+            break;
+
+         case TWEEN_PROPERTY_X_OFFSET:
+            GetBaseViewInfo()->SetXOffset(value);
+            break;
+
+         case TWEEN_PROPERTY_Y_OFFSET:
+            GetBaseViewInfo()->SetYOffset(value);
+            break;
+
+         case TWEEN_PROPERTY_FONT_SIZE:
+            GetBaseViewInfo()->SetFontSize(value);
+            break;
+         }
+	   }
+
+	   if(currentDone)
+	   {
+	      CurrentTweenIndex++;
+	      ElapsedTweenTime = 0;
+	   }
+	}
+
+	if(!CurrentTweens || CurrentTweenIndex >= CurrentTweens->size())
+	{
+	   if(loop)
+	   {
+	      CurrentTweenIndex = 0;
+	   }
+      completeDone = true;
+	}
+
+	return completeDone;
+}

Source/Graphics/Component/Component.h

@@ -0,0 +1,122 @@
+/* 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 <vector>
+
+#include "../MenuNotifierInterface.h"
+#include "../ViewInfo.h"
+#include "../Animate/Tween.h"
+#include "../../Collection/Item.h"
+
+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;
+
+	void SetOnEnterTweens(TweenSets *tweens)
+	{
+		this->OnEnterTweens = tweens;
+	}
+
+	void SetOnExitTweens(TweenSets *tweens)
+	{
+		this->OnExitTweens = tweens;
+	}
+
+	void SetOnIdleTweens(TweenSets *tweens)
+	{
+		this->OnIdleTweens = tweens;
+	}
+
+	void SetOnHighlightEnterTweens(TweenSets *tweens)
+	{
+		this->OnHighlightEnterTweens = tweens;
+	}
+
+	void SetOnHighlightExitTweens(TweenSets *tweens)
+	{
+		this->OnHighlightExitTweens = tweens;
+	}
+	virtual void Update(float dt);
+
+	virtual void Draw() = 0;
+
+   ViewInfo *GetBaseViewInfo()
+   {
+      return &BaseViewInfo;
+   }
+   void UpdateBaseViewInfo(ViewInfo &info)
+   {
+     BaseViewInfo = info;
+   }
+
+   bool IsScrollActive() const
+   {
+      return ScrollActive;
+   }
+
+   void SetScrollActive(bool scrollActive)
+   {
+      ScrollActive = scrollActive;
+   }
+
+
+
+protected:
+	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;
+private:
+	bool Animate(bool loop);
+	bool IsTweenSequencingComplete();
+	void ResetTweenSequence(std::vector<ViewInfo *> *tweens);
+
+	TweenSets *OnEnterTweens;
+	TweenSets *OnExitTweens;
+	TweenSets *OnIdleTweens;
+	TweenSets *OnHighlightEnterTweens;
+	TweenSets *OnHighlightExitTweens;
+
+	TweenSets *CurrentTweens;
+   unsigned int CurrentTweenIndex;
+
+	bool CurrentTweenComplete;
+	ViewInfo BaseViewInfo;
+
+	float ElapsedTweenTime;
+	Tween *TweenInst;
+	Item *SelectedItem;
+   bool ScrollActive;
+};

Source/Graphics/Component/Image.cpp

@@ -0,0 +1,75 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "Image.h"
+#include "../ViewInfo.h"
+#include "../../SDL.h"
+#include "../../Utility/Log.h"
+#include <SDL2/SDL_image.h>
+
+Image::Image(std::string file, float scaleX, float scaleY)
+: Texture(NULL)
+, File(file)
+, ScaleX(scaleX)
+, ScaleY(scaleY)
+{
+   AllocateGraphicsMemory();
+}
+
+Image::~Image()
+{
+   FreeGraphicsMemory();
+}
+
+void Image::FreeGraphicsMemory()
+{
+   Component::FreeGraphicsMemory();
+
+   SDL_LockMutex(SDL::GetMutex());
+   if (Texture != NULL)
+   {
+      SDL_DestroyTexture(Texture);
+      Texture = NULL;
+   }
+   SDL_UnlockMutex(SDL::GetMutex());
+}
+
+void Image::AllocateGraphicsMemory()
+{
+   int width;
+   int height;
+
+   Component::AllocateGraphicsMemory();
+
+   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());
+
+   }
+}
+
+void Image::Draw()
+{
+   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());
+
+      SDL::RenderCopy(Texture, static_cast<char>((info->GetTransparency() * 255)), NULL, &rect, info->GetAngle());
+   }
+}

Source/Graphics/Component/Image.h

@@ -0,0 +1,24 @@
+/* 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 "Component.h"
+#include <SDL2/SDL.h>
+#include <string>
+
+class Image : public Component
+{
+public:
+   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;
+};

Source/Graphics/Component/ImageBuilder.cpp

@@ -0,0 +1,30 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "ImageBuilder.h"
+#include "../../Utility/Utils.h"
+#include "../../Utility/Log.h"
+#include <fstream>
+
+Image * ImageBuilder::CreateImage(std::string path, std::string name, float scaleX, float scaleY)
+{
+   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");
+
+   std::string prefix = path + "/" + name;
+   std::string file;
+
+   if(Utils::FindMatchingFile(prefix, extensions, file))
+   {
+      image = new Image(file, scaleX, scaleY);
+   }
+
+   return image;
+}

Source/Graphics/Component/ImageBuilder.h

@@ -0,0 +1,15 @@
+/* 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 "Image.h"
+#include "VideoComponent.h"
+#include "../../Video/VideoFactory.h"
+
+//todo: this is more of a factory than a builder
+class ImageBuilder
+{
+public:
+   Image * CreateImage(std::string path, std::string name, float scaleX, float scaleY);
+};

Source/Graphics/Component/ReloadableMedia.cpp

@@ -0,0 +1,172 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "ReloadableMedia.h"
+#include "ImageBuilder.h"
+#include "VideoBuilder.h"
+#include "../ViewInfo.h"
+#include "../../Video/VideoFactory.h"
+#include "../../Database/Configuration.h"
+#include "../../Utility/Log.h"
+#include "../../Utility/Utils.h"
+#include "../../SDL.h"
+#include <fstream>
+#include <vector>
+#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)
+{
+   AllocateGraphicsMemory();
+}
+
+ReloadableMedia::~ReloadableMedia()
+{
+   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(LoadedComponent)
+   {
+      LoadedComponent->Update(dt);
+   }
+
+    // needs to be ran at the end to prevent the NewItemSelected flag from being detected
+   Component::Update(dt);
+
+}
+
+void ReloadableMedia::AllocateGraphicsMemory()
+{
+   FirstLoad = true;
+
+   if(LoadedComponent)
+   {
+      LoadedComponent->AllocateGraphicsMemory();
+   }
+
+   // NOTICE! needs to be done last to prevent flags from being missed
+   Component::AllocateGraphicsMemory();
+}
+
+void ReloadableMedia::LaunchEnter()
+{
+   if(LoadedComponent)
+   {
+      LoadedComponent->LaunchEnter();
+   }
+}
+
+void ReloadableMedia::LaunchExit()
+{
+   if(LoadedComponent)
+   {
+      LoadedComponent->LaunchExit();
+   }
+}
+
+void ReloadableMedia::FreeGraphicsMemory()
+{
+   Component::FreeGraphicsMemory();
+
+   if(LoadedComponent)
+   {
+      LoadedComponent->FreeGraphicsMemory();
+   }
+}
+void ReloadableMedia::ReloadTexture()
+{
+   bool found = false;
+
+   if(LoadedComponent)
+   {
+      delete LoadedComponent;
+      LoadedComponent = NULL;
+   }
+
+   Item *selectedItem = GetSelectedItem();
+
+   if (selectedItem != NULL)
+   {
+      if(IsVideo)
+      {
+         std::vector<std::string> names;
+
+         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)
+            {
+               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();
+
+   if(LoadedComponent)
+   {
+      info->SetImageHeight(LoadedComponent->GetBaseViewInfo()->GetImageHeight());
+      info->SetImageWidth(LoadedComponent->GetBaseViewInfo()->GetImageWidth());
+      LoadedComponent->UpdateBaseViewInfo(*info);
+      LoadedComponent->Draw();
+   }
+}

Source/Graphics/Component/ReloadableMedia.h

@@ -0,0 +1,38 @@
+/* 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 "Component.h"
+#include "../../Video/IVideo.h"
+#include "../../Collection/Item.h"
+#include <SDL2/SDL.h>
+#include <string>
+
+class Image;
+
+//todo: this class should aggregate Image, Text, and Video component classes
+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();
+
+private:
+	void ReloadTexture();
+	Component *LoadedComponent;
+   std::string ImagePath;
+   std::string VideoPath;
+   bool ReloadRequested;
+   bool FirstLoad;
+   IVideo *VideoInst;
+
+	bool IsVideo;
+	float ScaleX;
+	float ScaleY;
+};

Source/Graphics/Component/ReloadableText.cpp

@@ -0,0 +1,157 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "ReloadableText.h"
+#include "../ViewInfo.h"
+#include "../../Database/Configuration.h"
+#include "../../Utility/Log.h"
+#include "../../SDL.h"
+#include <fstream>
+#include <vector>
+#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)
+{
+
+   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;
+   }
+
+   AllocateGraphicsMemory();
+}
+
+
+
+ReloadableText::~ReloadableText()
+{
+   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;
+   }
+
+   // needs to be ran at the end to prevent the NewItemSelected flag from being detected
+   Component::Update(dt);
+
+}
+
+void ReloadableText::AllocateGraphicsMemory()
+{
+   FirstLoad = true;
+
+   ReloadTexture();
+
+   // NOTICE! needs to be done last to prevent flags from being missed
+   Component::AllocateGraphicsMemory();
+}
+
+void ReloadableText::LaunchEnter()
+{
+}
+
+void ReloadableText::LaunchExit()
+{
+}
+
+void ReloadableText::FreeGraphicsMemory()
+{
+   Component::FreeGraphicsMemory();
+
+   if (ImageInst != NULL)
+   {
+      delete ImageInst;
+      ImageInst = NULL;
+   }
+}
+void ReloadableText::ReloadTexture()
+{
+   if (ImageInst != NULL)
+   {
+      delete ImageInst;
+      ImageInst = NULL;
+   }
+
+   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;
+      }
+
+      ImageInst = new Text(ss.str(), FontInst, FontColor, ScaleX, ScaleY);
+   }
+}
+
+
+void ReloadableText::Draw()
+{
+   ViewInfo *info = GetBaseViewInfo();
+
+   if(ImageInst)
+   {
+      ImageInst->UpdateBaseViewInfo(*info);
+      ImageInst->Draw();
+   }
+}

Source/Graphics/Component/ReloadableText.h

@@ -0,0 +1,48 @@
+/* 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 "Component.h"
+#include "Text.h"
+#include "../Font.h"
+#include "../../Collection/Item.h"
+#include <SDL2/SDL.h>
+#include <string>
+
+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();
+
+private:
+   enum TextType
+   {
+      TextTypeUnknown = 0,
+      TextTypeNumberButtons,
+      TextTypeNumberPlayers,
+      TextTypeYear,
+      TextTypeTitle,
+      TextTypeManufacturer,
+   };
+
+   void ReloadTexture();
+
+   Text *ImageInst;
+   TextType Type;
+   std::string LayoutKey;
+   std::string Collection;
+   bool ReloadRequested;
+   bool FirstLoad;
+   Font *FontInst;
+   SDL_Color FontColor;
+
+   float ScaleX;
+   float ScaleY;
+};

Source/Graphics/Component/ScrollingList.cpp

@@ -0,0 +1,654 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "../Animate/Tween.h"
+#include "../Animate/TweenTypes.h"
+#include "../ComponentItemBinding.h"
+#include "../Font.h"
+#include "ScrollingList.h"
+#include "ImageBuilder.h"
+#include "VideoBuilder.h"
+#include "VideoComponent.h"
+#include "ReloadableMedia.h"
+#include "Text.h"
+#include "../../Database/Configuration.h" // todo: decouple the GUI from the data
+#include "../../Collection/Item.h"
+#include "../../Utility/Log.h"
+#include "../../SDL.h"
+#include "../ViewInfo.h"
+#include <math.h>
+#include <SDL2/SDL_image.h>
+#include <sstream>
+
+
+//todo: remove coupling from configuration data (if possible)
+ScrollingList::ScrollingList(Configuration *c, 
+                             float scaleX, 
+                             float scaleY, 
+                             Font *font, 
+                             SDL_Color fontColor, 
+                             std::string layoutKey, 
+                             std::string collectionName, 
+                             std::string imageType)
+: IsScrollChangedStarted(true)
+, IsScrollChangedSignalled(false)
+, IsScrollChangedComplete(false)
+, SpriteList(NULL)
+, ScrollPoints(NULL)
+, TweenEnterTime(0)
+, FirstSpriteIndex(0)
+, SelectedSpriteListIndex(0)
+, CurrentAnimateTime(0) // in seconds
+, ScrollTime(0)         // in seconds
+, CurrentScrollDirection(ScrollDirectionIdle)
+, RequestedScrollDirection(ScrollDirectionIdle)
+, CurrentScrollState(ScrollStateIdle)
+, ScrollAcceleration(6)  // todo: make configurable
+, ScrollVelocity(0)
+, Config(c)
+, ScaleX(scaleX)
+, ScaleY(scaleY)
+, FontInst(font)
+, FontColor(fontColor)
+, LayoutKey(layoutKey)
+, CollectionName(collectionName)
+, ImageType(imageType)
+, MaxLayer(0)
+{
+}
+
+ScrollingList::~ScrollingList()
+{
+}
+
+void ScrollingList::SetItems(std::vector<ComponentItemBinding *> *spriteList)
+{
+   SpriteList = spriteList;
+   FirstSpriteIndex = 0;
+
+   // loop the scroll points if there are not enough
+   unsigned int originalSize = SpriteList->size();
+
+   while(ScrollPoints && ScrollPoints->size()+4 > SpriteList->size())
+   {
+      for(unsigned int i = 0; i < originalSize; ++i)
+      {
+         Item *newItem = new Item();
+         Item *originalItem = SpriteList->at(i)->GetCollectionItem();
+
+         *newItem = *originalItem;
+         ComponentItemBinding *newSprite = new ComponentItemBinding(newItem);
+         SpriteList->push_back(newSprite);
+      }
+   }
+   for(unsigned int i = 0; SpriteList && ScrollPoints && i < SelectedSpriteListIndex; ++i)
+   {
+      CircularDecrement(FirstSpriteIndex, SpriteList);
+   }
+
+   IsScrollChangedComplete = true;
+}
+
+void ScrollingList::SetPoints(std::vector<ViewInfo *> *scrollPoints)
+{
+   ScrollPoints = scrollPoints;
+   for(unsigned int i = 0; i != scrollPoints->size(); ++i)
+   {
+      ViewInfo *info = scrollPoints->at(i);
+      MaxLayer = (MaxLayer < info->GetLayer()) ? MaxLayer : info->GetLayer();
+   }
+
+}
+
+void ScrollingList::SetSelectedIndex(int selectedIndex)
+{
+   SelectedSpriteListIndex = selectedIndex;
+
+   for(unsigned int i = 0; SpriteList && ScrollPoints && i < SelectedSpriteListIndex; ++i)
+   {
+      CircularDecrement(FirstSpriteIndex, SpriteList);
+   }
+
+}
+
+void ScrollingList::Click()
+{
+   if(CurrentScrollDirection == ScrollDirectionBack)
+   {
+      CircularDecrement(FirstSpriteIndex, SpriteList);
+      IsScrollChangedComplete = true;
+   }
+   if(CurrentScrollDirection == ScrollDirectionForward)
+   {
+      CircularIncrement(FirstSpriteIndex, SpriteList);
+      IsScrollChangedComplete = true;
+   }
+}
+
+unsigned int ScrollingList::GetNextTween(unsigned int currentIndex, std::vector<ViewInfo *> *list)
+{
+   if(CurrentScrollDirection == ScrollDirectionForward)
+   {
+      CircularDecrement(currentIndex, list);
+   }
+   else if(CurrentScrollDirection == ScrollDirectionBack)
+   {
+      CircularIncrement(currentIndex, list);
+   }
+
+   return currentIndex;
+}
+
+void ScrollingList::PageUp()
+{
+   if(ScrollPoints && ScrollPoints->size() > 4)
+   {
+      ScrollVelocity = 0;
+      unsigned int counts = ScrollPoints->size() - 4;
+
+      for(unsigned int i = 0; i < counts; i++)
+      {
+         CircularDecrement(FirstSpriteIndex, SpriteList);
+      }
+   }
+
+   CurrentScrollState = ScrollStatePageChange;
+   IsScrollChangedStarted = true;
+   IsScrollChangedSignalled = false;
+   IsScrollChangedComplete = false;
+}
+
+void ScrollingList::PageDown()
+{
+   if(ScrollPoints && ScrollPoints->size() > 4)
+   {
+      unsigned int counts = ScrollPoints->size() - 4;
+
+      ScrollVelocity = 0;
+      for(unsigned int i = 0; i < counts; i++)
+      {
+         CircularIncrement(FirstSpriteIndex, SpriteList);
+      }
+   }
+
+   CurrentScrollState = ScrollStatePageChange;
+   IsScrollChangedStarted = true;
+   IsScrollChangedSignalled = false;
+   IsScrollChangedComplete = false;
+}
+
+void ScrollingList::FreeGraphicsMemory()
+{
+   Component::FreeGraphicsMemory();
+   TweenEnterTime = 0;
+   CurrentAnimateTime = 0;
+   ScrollTime = 0;
+   CurrentScrollDirection = ScrollDirectionIdle;
+   RequestedScrollDirection = ScrollDirectionIdle;
+   CurrentScrollState = ScrollStateIdle;
+   ScrollAcceleration = 6;  // todo: make configurable
+   ScrollVelocity = 0;
+
+   for(unsigned int i = 0; i < SpriteList->size(); i++)
+   {
+      ComponentItemBinding *s = SpriteList->at(i);
+
+      DeallocateTexture(s);
+   }
+}
+
+
+void ScrollingList::Update(float dt)
+{
+   float scrollPeriod = 0;
+   Component::Update(dt);
+
+   if(!ScrollPoints)
+   {
+      return;
+   }
+
+   switch(CurrentScrollState)
+   {
+      case ScrollStateActive:
+         if(RequestedScrollDirection != CurrentScrollDirection)
+         {
+            CurrentScrollState = ScrollStateStopping;
+
+         }
+
+         break;
+
+      case ScrollStateIdle:
+         ScrollTime = 0;
+         CurrentAnimateTime = 0;
+         ScrollVelocity = 0;
+
+         if(RequestedScrollDirection != ScrollDirectionIdle)
+         {
+            CurrentScrollState = ScrollStateActive;
+            CurrentScrollDirection = RequestedScrollDirection;
+         }
+         break;
+      default:
+         break;
+
+   };
+
+   if(CurrentScrollState != ScrollStatePageChange && CurrentScrollState != ScrollStateIdle)
+   {
+      IsScrollChangedStarted = true;
+      ScrollTime += dt;
+      CurrentAnimateTime += dt;
+      ScrollVelocity = ScrollTime * ScrollAcceleration;
+
+      // clip at 5 items scrolled per second
+      if(ScrollVelocity > 30)
+      {
+         ScrollVelocity = 30;
+      }
+      if(ScrollVelocity > 0)
+      {
+         scrollPeriod = 1 / ScrollVelocity;
+      }
+
+      // have we exceeded the time of when to stop on the next item in the list?
+      if(CurrentScrollState == ScrollStateStopping && CurrentAnimateTime >= scrollPeriod)
+      {
+         Click();
+         CurrentAnimateTime = 0;
+         ScrollVelocity = 0;
+         CurrentScrollState = ScrollStateIdle;
+      }
+   }
+
+   while(CurrentScrollState != ScrollStatePageChange && ScrollVelocity > 0 && CurrentAnimateTime >= scrollPeriod)
+   {
+      Click();
+      CurrentAnimateTime -= scrollPeriod;
+   }
+
+
+   if(ScrollPoints && SpriteList->size() > 0 && FirstSpriteIndex < SpriteList->size())
+   {
+      unsigned int spriteIndex = FirstSpriteIndex;
+      unsigned int numIterations = (ScrollPoints->size() > SpriteList->size()) ? SpriteList->size() : ScrollPoints->size();
+      unsigned int start = (ScrollPoints->size() > SpriteList->size()) ? SelectedSpriteListIndex : 0;
+
+      for(unsigned int i = start; i < start+numIterations; i++)
+      {
+         ComponentItemBinding *s = SpriteList->at(spriteIndex);
+         unsigned int nextI = GetNextTween(i, ScrollPoints);
+
+         ViewInfo *currentViewInfo = ScrollPoints->at(i);
+         ViewInfo *nextViewInfo = ScrollPoints->at(nextI);
+
+         AllocateTexture(s);
+
+         Component *c = s->GetComponent();
+         if(c)
+         {
+            currentViewInfo->SetImageHeight(c->GetBaseViewInfo()->GetImageHeight());
+            currentViewInfo->SetImageWidth(c->GetBaseViewInfo()->GetImageWidth());
+            nextViewInfo->SetImageHeight(c->GetBaseViewInfo()->GetImageHeight());
+            nextViewInfo->SetImageWidth(c->GetBaseViewInfo()->GetImageWidth());
+
+            //todo: 30 is a magic number
+            ViewInfo *spriteViewInfo = c->GetBaseViewInfo();
+
+            spriteViewInfo->SetX(Tween::AnimateSingle(LINEAR, currentViewInfo->GetX(), nextViewInfo->GetX(), scrollPeriod, CurrentAnimateTime));
+            spriteViewInfo->SetY(Tween::AnimateSingle(LINEAR, currentViewInfo->GetY(), nextViewInfo->GetY(), scrollPeriod, CurrentAnimateTime));
+            spriteViewInfo->SetXOrigin(Tween::AnimateSingle(LINEAR, currentViewInfo->GetXOrigin(), nextViewInfo->GetXOrigin(), scrollPeriod, CurrentAnimateTime));
+            spriteViewInfo->SetYOrigin(Tween::AnimateSingle(LINEAR, currentViewInfo->GetYOrigin(), nextViewInfo->GetYOrigin(), scrollPeriod, CurrentAnimateTime));
+            spriteViewInfo->SetXOffset(Tween::AnimateSingle(LINEAR, currentViewInfo->GetXOffset(), nextViewInfo->GetXOffset(), scrollPeriod, CurrentAnimateTime));
+            spriteViewInfo->SetYOffset(Tween::AnimateSingle(LINEAR, currentViewInfo->GetYOffset(), nextViewInfo->GetYOffset(), scrollPeriod, CurrentAnimateTime));
+            spriteViewInfo->SetHeight(Tween::AnimateSingle(LINEAR, currentViewInfo->GetHeight(), nextViewInfo->GetHeight(), scrollPeriod, CurrentAnimateTime));
+            spriteViewInfo->SetWidth(Tween::AnimateSingle(LINEAR, currentViewInfo->GetWidth(), nextViewInfo->GetWidth(), scrollPeriod, CurrentAnimateTime));
+            spriteViewInfo->SetTransparency(Tween::AnimateSingle(LINEAR, currentViewInfo->GetTransparency(), nextViewInfo->GetTransparency(), scrollPeriod, CurrentAnimateTime));
+            spriteViewInfo->SetAngle(Tween::AnimateSingle(LINEAR, currentViewInfo->GetAngle(), nextViewInfo->GetAngle(), scrollPeriod, CurrentAnimateTime));
+            spriteViewInfo->SetFontSize(Tween::AnimateSingle(LINEAR, currentViewInfo->GetFontSize(), nextViewInfo->GetFontSize(), scrollPeriod, CurrentAnimateTime));
+            c->Update(dt);
+
+         }
+
+         CircularIncrement(spriteIndex, SpriteList);
+       }
+
+      // start freeing up memory if the list is too large
+      if(SpriteList->size() + 4 > ScrollPoints->size())
+      {
+         spriteIndex = FirstSpriteIndex;
+
+         CircularDecrement(spriteIndex, SpriteList);
+         DeallocateTexture(SpriteList->at(spriteIndex));
+
+         CircularDecrement(spriteIndex, SpriteList);
+         DeallocateTexture(SpriteList->at(spriteIndex));
+
+
+         // point to the end of the list to start deallocating..
+         // It's not fast, but it's easy to read
+         spriteIndex = FirstSpriteIndex;
+         for(unsigned int i = 0; i < ScrollPoints->size(); i++)
+         {
+            CircularIncrement(spriteIndex, SpriteList);
+         }
+
+         CircularIncrement(spriteIndex, SpriteList);
+         DeallocateTexture(SpriteList->at(spriteIndex));
+
+         CircularIncrement(spriteIndex, SpriteList);
+         DeallocateTexture(SpriteList->at(spriteIndex));
+      }
+   }
+
+   if(IsScrollChangedStarted && !IsScrollChangedSignalled)
+   {
+      IsScrollChangedSignalled = true;
+      ComponentItemBinding *sprite = GetPendingCollectionItemSprite();
+      Item *item = NULL;
+
+      if(sprite)
+      {
+         item = sprite->GetCollectionItem();
+      }
+
+      for(std::vector<MenuNotifierInterface *>::iterator it = NotificationComponents.begin();
+          it != NotificationComponents.end();
+          it++)
+      {
+         MenuNotifierInterface *c = *it;
+         if(c && item)
+         {
+            c->OnNewItemSelected(item);
+         }
+      }
+
+      if(CurrentScrollState == ScrollStatePageChange)
+      {
+         IsScrollChangedComplete = true;
+         CurrentScrollState = ScrollStateIdle;
+      }
+   }
+
+   if(IsScrollChangedStarted && IsScrollChangedSignalled && IsScrollChangedComplete)
+   {
+      IsScrollChangedStarted = false;
+      IsScrollChangedComplete = false;
+      IsScrollChangedSignalled = false;
+   }
+
+}
+
+void ScrollingList::AllocateTexture(ComponentItemBinding *s)
+{
+   //todo: move this outside of the Draw routine
+   if(s && s->GetComponent() == NULL)
+   {
+      const Item *item = s->GetCollectionItem();
+      //todo: will create a runtime fault if not of the right type
+      //todo: remove coupling from knowing the collection name
+
+      std::string collectionKey ="collections." + CollectionName + ".media." + ImageType;
+      std::string videoKey ="collections." + CollectionName + ".media.video";
+      std::string imagePath;
+      std::string videoPath;
+
+      Component *t = NULL;
+
+      /*
+       // todo: to be supported at a later date
+      if(c->GetProperty(videoKey, videoPath))
+      {
+         t = new VideoComponent(videoPath, item->GetFullTitle(), ScaleX, ScaleY);
+      }
+*/
+      if(!t && Config->GetPropertyAbsolutePath(collectionKey, imagePath))
+      {
+         ImageBuilder imageBuild;
+         t = imageBuild.CreateImage(imagePath, item->GetName(), ScaleX, ScaleY);
+
+         if(!t && item->GetTitle() != item->GetFullTitle())
+         {
+            t = imageBuild.CreateImage(imagePath, item->GetFullTitle(), ScaleX, ScaleY);
+         }
+      }
+      if (!t)
+      {
+         t = new Text(item->GetTitle(), FontInst, FontColor, ScaleX, ScaleY);
+      }
+
+      if(t)
+      {
+         s->SetComponent(t);
+      }
+   }
+
+}
+
+void ScrollingList::DeallocateTexture(ComponentItemBinding *s)
+{
+   if(s && s->GetComponent() != NULL)
+   {
+      delete s->GetComponent();
+   }
+   s->SetComponent(NULL);
+}
+
+void ScrollingList::Draw()
+{
+   //todo: Poor design implementation.
+   // caller should instead call ScrollingList::Draw(unsigned int layer)
+}
+
+//todo: this is kind of a hack. Aggregation needs to happen differently
+void ScrollingList::Draw(unsigned int layer)
+{
+   if(ScrollPoints && SpriteList && SpriteList->size() > 0 && FirstSpriteIndex < SpriteList->size())
+   {
+      unsigned int spriteIndex = FirstSpriteIndex;
+
+      for(unsigned int i = 0; i < ScrollPoints->size(); i++)
+      {
+         std::vector<ComponentItemBinding *>::iterator it = SpriteList->begin() + spriteIndex;
+         Component *c = (*it)->GetComponent();
+         ViewInfo *currentViewInfo = ScrollPoints->at(i);
+
+         if(currentViewInfo && currentViewInfo->GetLayer() == layer)
+         {
+            c->Draw();
+         }
+         CircularIncrement(spriteIndex, SpriteList);
+      }
+   }
+}
+
+
+void ScrollingList::SetScrollDirection(ScrollDirection direction)
+{
+   RequestedScrollDirection = direction;
+}
+
+void ScrollingList::RemoveSelectedItem()
+{
+   ComponentItemBinding *sprite = GetSelectedCollectionItemSprite();
+   if(sprite)
+   {
+      Item *item = sprite->GetCollectionItem();
+      DeallocateTexture(sprite);
+      int index = (FirstSpriteIndex + SelectedSpriteListIndex) % SpriteList->size();
+
+      std::vector<ComponentItemBinding *>::iterator it = SpriteList->begin() + index;
+
+      SpriteList->erase(it);
+      delete sprite;
+
+      if(item)
+      {
+         delete item;
+      }
+
+      if(SelectedSpriteListIndex >= SpriteList->size())
+      {
+         SelectedSpriteListIndex = 0;
+      }
+      if(FirstSpriteIndex >= SpriteList->size())
+      {
+         FirstSpriteIndex = 0;
+      }
+   }
+   IsScrollChangedComplete = true;
+}
+
+
+std::vector<ComponentItemBinding *> *ScrollingList::GetCollectionItemSprites()
+{
+   return SpriteList;
+}
+
+ComponentItemBinding* ScrollingList::GetSelectedCollectionItemSprite()
+{
+   ComponentItemBinding *item = NULL;
+
+   if(SpriteList && SpriteList->size() > 0)
+   {
+      int index = (FirstSpriteIndex + SelectedSpriteListIndex) % SpriteList->size();
+
+      item = SpriteList->at(index);
+   }
+
+   return item;
+}
+
+ComponentItemBinding* ScrollingList::GetPendingCollectionItemSprite()
+{
+   ComponentItemBinding *item = NULL;
+   unsigned int index = FirstSpriteIndex;
+   if(CurrentScrollState != ScrollStatePageChange)
+   {
+      if(CurrentScrollDirection == ScrollDirectionBack)
+      {
+         CircularDecrement(index, SpriteList);
+      }
+      if(CurrentScrollDirection == ScrollDirectionForward)
+      {
+         CircularIncrement(index, SpriteList);
+      }
+   }
+   if(SpriteList && SpriteList->size() > 0)
+   {
+      index = (index + SelectedSpriteListIndex) % SpriteList->size();
+
+      item = SpriteList->at(index);
+   }
+
+   return item;
+}
+
+void ScrollingList::AddComponentForNotifications(MenuNotifierInterface *c)
+{
+   NotificationComponents.push_back(c);
+}
+void ScrollingList::RemoveComponentForNotifications(MenuNotifierInterface *c)
+{
+   for(std::vector<MenuNotifierInterface *>::iterator it = NotificationComponents.begin();
+       it != NotificationComponents.end();
+       it++)
+   {
+      if(c == *it)
+      {
+         NotificationComponents.erase(it);
+         break;
+      }
+   }
+}
+
+
+ComponentItemBinding* ScrollingList::GetPendingSelectedCollectionItemSprite()
+{
+   ComponentItemBinding *item = NULL;
+
+   unsigned int index = SelectedSpriteListIndex;
+
+   if(CurrentScrollDirection == ScrollDirectionBack)
+   {
+      CircularDecrement(index, SpriteList);
+   }
+   if(CurrentScrollDirection == ScrollDirectionForward)
+   {
+      CircularIncrement(index, SpriteList);
+   }
+
+   if(SpriteList && SpriteList->size() > 0)
+   {
+      index = (index + SelectedSpriteListIndex) % SpriteList->size();
+
+      item = SpriteList->at(index);
+   }
+
+   return item;
+}
+
+bool ScrollingList::IsIdle()
+{
+   return (Component::IsIdle() && CurrentScrollState == ScrollStateIdle);
+}
+
+void ScrollingList::CircularIncrement(unsigned int &index, std::vector<ViewInfo*>* list)
+{
+   index++;
+
+   if(index >= list->size())
+   {
+      index = 0;
+   }
+}
+
+void ScrollingList::CircularDecrement(unsigned int &index, std::vector<ViewInfo*>* list)
+{
+   if(index > 0)
+   {
+      index--;
+   }
+   else
+   {
+      if(list->size() > 0)
+      {
+         index = list->size() - 1;
+      }
+      else
+      {
+         index = 0;
+      }
+   }
+}
+
+
+void ScrollingList::CircularIncrement(unsigned int &index, std::vector<ComponentItemBinding*> *list)
+{
+   index++;
+
+   if(index >= list->size())
+   {
+      index = 0;
+   }
+}
+void ScrollingList::CircularDecrement(unsigned int &index, std::vector<ComponentItemBinding*> *list)
+{
+   if(index > 0)
+   {
+      index--;
+   }
+   else
+   {
+      if(list && list->size() > 0)
+      {
+         index = list->size() - 1;
+      }
+      else
+      {
+         index = 0;
+      }
+   }
+}
+

Source/Graphics/Component/ScrollingList.h

@@ -0,0 +1,105 @@
+/* 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 <vector>
+#include "Component.h"
+#include "../Animate/Tween.h"
+#include "../ComponentItemBinding.h"
+#include "../MenuNotifierInterface.h"
+#include "../ViewInfo.h"
+#include "../../Database/Configuration.h"
+#include <SDL2/SDL.h>
+
+
+//todo: This scrolling implementation needs to be overhauled
+//      It needs to have a common interface to support different menu types
+//      (It was originally sandbox code that creeped into here)
+
+class Configuration;
+class Font;
+
+class ScrollingList : public Component
+{
+public:
+   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);
+
+private:
+   void Click();
+   unsigned int GetNextTween(unsigned int currentIndex, std::vector<ViewInfo *> *list);
+   bool IsScrollChangedStarted;
+   bool IsScrollChangedSignalled;
+   bool IsScrollChangedComplete;
+
+enum ScrollState
+   {
+      ScrollStateActive,
+      ScrollStatePageChange,
+      ScrollStateStopping,
+      ScrollStateIdle
+   };
+
+   std::vector<ComponentItemBinding *> *SpriteList;
+   std::vector<ViewInfo *> *ScrollPoints;
+   std::vector<MenuNotifierInterface *> NotificationComponents;
+   float TweenEnterTime;
+
+   unsigned int FirstSpriteIndex;
+   unsigned int SelectedSpriteListIndex;
+   float CurrentAnimateTime;
+   float ScrollTime;
+
+   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);
+
+   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;
+};
+

Source/Graphics/Component/Text.cpp

@@ -0,0 +1,103 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "Text.h"
+#include "../../Utility/Log.h"
+#include "../../SDL.h"
+#include "../Font.h"
+#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)
+{
+   AllocateGraphicsMemory();
+}
+
+Text::~Text()
+{
+   FreeGraphicsMemory();
+}
+
+
+void Text::FreeGraphicsMemory()
+{
+   Component::FreeGraphicsMemory();
+}
+
+void Text::AllocateGraphicsMemory()
+{
+   //todo: make the font blend color a parameter that is passed in
+   Component::AllocateGraphicsMemory();
+}
+
+void Text::Draw()
+{
+   SDL_Texture *t = FontInst->GetTexture();
+
+   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;
+      }
+   }
+
+   float scale = (float)info->GetFontSize() / (float)imageHeight;
+
+
+   float width = info->GetRawWidth();
+   float height = info->GetRawHeight();
+
+   info->SetWidth(imageWidth*scale);
+   info->SetHeight(imageHeight*scale);
+
+   float xOrigin = info->GetXRelativeToOrigin();
+   float yOrigin = info->GetYRelativeToOrigin();
+
+   info->SetWidth(width);
+   info->SetHeight(height);
+
+
+   SDL_Rect rect;
+   rect.x = static_cast<int>(xOrigin);
+
+   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());
+          */
+
+         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);
+      }
+   }
+}
+

Source/Graphics/Component/Text.h

@@ -0,0 +1,29 @@
+/* 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 "Component.h"
+
+#include <SDL2/SDL.h>
+#include <vector>
+
+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();
+
+private:
+   std::string TextData;
+   Font *FontInst;
+   SDL_Color FontColor;
+   float ScaleX;
+   float ScaleY;
+};

Source/Graphics/Component/VideoBuilder.cpp

@@ -0,0 +1,36 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "VideoBuilder.h"
+#include "../../Utility/Utils.h"
+#include "../../Utility/Log.h"
+#include "../../Video/VideoFactory.h"
+#include <fstream>
+
+
+VideoComponent * VideoBuilder::CreateVideo(std::string path, std::string name, float scaleX, float scaleY)
+{
+   VideoComponent *component = NULL;
+   std::vector<std::string> extensions;
+
+   extensions.push_back("mp4");
+   extensions.push_back("MP4");
+   extensions.push_back("avi");
+   extensions.push_back("AVI");
+
+   std::string prefix = path + "/" + name;
+   std::string file;
+
+   if(Utils::FindMatchingFile(prefix, extensions, file))
+   {
+      IVideo *video = Factory.CreateVideo();
+
+      if(video)
+      {
+         component = new VideoComponent(video, file, scaleX, scaleY);
+      }
+   }
+
+   return component;
+}
+

Source/Graphics/Component/VideoBuilder.h

@@ -0,0 +1,18 @@
+/* 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 "Image.h"
+#include "VideoComponent.h"
+#include "../../Video/VideoFactory.h"
+
+//todo: this is more of a factory than a builder
+class VideoBuilder
+{
+public:
+   VideoComponent * CreateVideo(std::string path, std::string name, float scaleX, float scaleY);
+
+private:
+   VideoFactory Factory;
+};

Source/Graphics/Component/VideoComponent.cpp

@@ -0,0 +1,84 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "VideoComponent.h"
+#include "../ViewInfo.h"
+#include "../../Database/Configuration.h"
+#include "../../Utility/Log.h"
+#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)
+{
+//   AllocateGraphicsMemory();
+}
+
+VideoComponent::~VideoComponent()
+{
+   FreeGraphicsMemory();
+
+   if(VideoInst)
+   {
+      VideoInst->Stop();
+   }
+}
+
+void VideoComponent::Update(float dt)
+{
+   if(IsPlaying)
+   {
+      VideoInst->Update(dt);
+   }
+
+   Component::Update(dt);
+
+}
+
+void VideoComponent::AllocateGraphicsMemory()
+{
+   Component::AllocateGraphicsMemory();
+
+   if(!IsPlaying)
+   {
+      IsPlaying = VideoInst->Play(VideoFile);
+   }
+}
+
+void VideoComponent::FreeGraphicsMemory()
+{
+   VideoInst->Stop();
+   IsPlaying = false;
+
+   if (VideoTexture != NULL)
+   {
+      SDL_LockMutex(SDL::GetMutex());
+      SDL_DestroyTexture(VideoTexture);
+      SDL_UnlockMutex(SDL::GetMutex());
+   }
+
+   Component::FreeGraphicsMemory();
+}
+
+void VideoComponent::Draw()
+{
+   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());
+
+   VideoInst->Draw();
+   SDL_Texture *texture = VideoInst->GetTexture();
+
+   if(texture)
+   {
+      SDL::RenderCopy(texture, static_cast<int>(info->GetTransparency() * 255), NULL, &rect, info->GetAngle());
+   }
+}

Source/Graphics/Component/VideoComponent.h

@@ -0,0 +1,32 @@
+/* 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 "Component.h"
+#include "Image.h"
+#include "../../Collection/Item.h"
+#include "../../Video/IVideo.h"
+#include <SDL2/SDL.h>
+#include <string>
+
+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(); }
+
+private:
+   SDL_Texture *VideoTexture;
+   std::string VideoFile;
+   std::string Name;
+   IVideo *VideoInst;
+	float ScaleX;
+	float ScaleY;
+	bool IsPlaying;
+};

Source/Graphics/ComponentItemBinding.cpp

@@ -0,0 +1,35 @@
+/* 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)
+{
+}
+
+ComponentItemBinding::ComponentItemBinding(Item *item)
+: CollectionComponent(NULL)
+, CollectionItem(item)
+{
+}
+
+ComponentItemBinding::~ComponentItemBinding()
+{
+}
+
+Item* ComponentItemBinding::GetCollectionItem() const
+{
+   return CollectionItem;
+}
+
+void ComponentItemBinding::SetComponent(Component *c)
+{
+   CollectionComponent = c;
+}
+
+Component* ComponentItemBinding::GetComponent() const
+{
+   return CollectionComponent;
+}

Source/Graphics/ComponentItemBinding.h

@@ -0,0 +1,23 @@
+/* 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 "Component/Component.h"
+#include "../Collection/Item.h"
+
+class ComponentItemBinding
+{
+public:
+   ComponentItemBinding(Component *c, Item *item);
+   ComponentItemBinding(Item *item);
+   virtual ~ComponentItemBinding();
+   Item* GetCollectionItem() const;
+
+   void SetComponent(Component *c);
+   Component* GetComponent() const;
+
+private:
+   Component *CollectionComponent;
+   Item *CollectionItem;
+};

Source/Graphics/ComponentItemBindingBuilder.cpp

@@ -0,0 +1,29 @@
+/* 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"
+#include "../Database/CollectionDatabase.h"
+#include "../Collection/Item.h"
+
+ComponentItemBindingBuilder::ComponentItemBindingBuilder()
+{
+}
+
+ComponentItemBindingBuilder::~ComponentItemBindingBuilder()
+{
+}
+
+std::vector<ComponentItemBinding *> *ComponentItemBindingBuilder::BuildCollectionItems(std::vector<Item *> *infoList)
+{
+   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);
+   }
+
+   return sprites;
+}

Source/Graphics/ComponentItemBindingBuilder.h

@@ -0,0 +1,18 @@
+/* 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 <vector>
+#include <string>
+
+class Item;
+class ComponentItemBinding;
+
+class ComponentItemBindingBuilder
+{
+public:
+   ComponentItemBindingBuilder();
+   virtual ~ComponentItemBindingBuilder();
+   static std::vector<ComponentItemBinding *> *BuildCollectionItems(std::vector<Item *> *infoList);
+};

Source/Graphics/Font.cpp

@@ -0,0 +1,145 @@
+/* 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"
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_ttf.h>
+
+Font::Font()
+: Texture(NULL)
+{
+}
+
+Font::~Font()
+{
+   DeInitialize();
+}
+
+SDL_Texture *Font::GetTexture()
+{
+   return Texture;
+}
+
+bool Font::GetRect(unsigned int charCode, GlyphInfo &glyph)
+{
+   std::map<unsigned int, GlyphInfoBuild *>::iterator it = Atlas.find(charCode);
+
+   if(it != Atlas.end())
+   {
+      GlyphInfoBuild *info = it->second;
+
+      glyph = info->Glyph;
+
+      return true;
+   }
+
+   return false;
+}
+
+bool Font::Initialize(std::string fontPath, SDL_Color color)
+{
+   TTF_Font *font = TTF_OpenFont(fontPath.c_str(), 128);
+
+   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;
+
+   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);
+
+      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;
+
+      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;
+
+   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;
+#else
+   rmask = 0x000000ff;
+   gmask = 0x0000ff00;
+   bmask = 0x00ff0000;
+   amask = 0xff000000;
+#endif
+   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;
+   }
+
+   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);
+
+   return true;
+}
+
+void Font::DeInitialize()
+{
+   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();
+   }
+
+}

Source/Graphics/Font.h

@@ -0,0 +1,42 @@
+/* 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>
+#include <map>
+#include <string>
+
+class Font
+{
+public:
+   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);
+
+
+private:
+   struct GlyphInfoBuild
+   {
+      Font::GlyphInfo Glyph;
+      SDL_Surface *Surface;
+   };
+
+   std::map<unsigned int, GlyphInfoBuild *> Atlas;
+   SDL_Texture *Texture;
+};
+
+

Source/Graphics/FontCache.cpp

@@ -0,0 +1,72 @@
+/* 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"
+#include "../SDL.h"
+#include <SDL2/SDL_ttf.h>
+#include <sstream>
+
+//todo: memory leak when launching games
+FontCache::FontCache()
+: IsInitialized(false)
+{
+}
+
+FontCache::~FontCache()
+{
+   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();
+   }
+
+   SDL_LockMutex(SDL::GetMutex());
+   TTF_Quit();
+   SDL_UnlockMutex(SDL::GetMutex());
+}
+
+
+void FontCache::Initialize()
+{
+   //todo: make bool
+   TTF_Init();
+   IsInitialized = true;
+}
+Font *FontCache::GetFont(std::string fontPath)
+{
+   Font *t = NULL;
+
+   std::map<std::string, Font *>::iterator it = FontFaceMap.find(fontPath);
+
+   if(it != FontFaceMap.end())
+   {
+      t = it->second;
+   }
+
+   return t;
+}
+
+bool FontCache::LoadFont(std::string fontPath, SDL_Color color)
+{
+   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;
+   }
+
+   return true;
+}
+

Source/Graphics/FontCache.h

@@ -0,0 +1,26 @@
+/* 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"
+#include <string>
+#include <map>
+
+class FontCache
+{
+public:
+   void Initialize();
+   void DeInitialize();
+   FontCache();
+   bool LoadFont(std::string font, SDL_Color color);
+   Font *GetFont(std::string font);
+
+   virtual ~FontCache();
+private:
+   bool IsInitialized;
+
+   std::map<std::string, Font *> FontFaceMap;
+
+};
+

Source/Graphics/MenuNotifierInterface.h

@@ -0,0 +1,14 @@
+/* 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"
+
+class MenuNotifierInterface
+{
+public:
+   virtual ~MenuNotifierInterface() {}
+   virtual void OnNewItemSelected(Item *) = 0;
+};
+

Source/Graphics/Page.cpp

@@ -0,0 +1,406 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "Page.h"
+#include "ComponentItemBinding.h"
+#include "Component/Component.h"
+#include "../Utility/Log.h"
+#include "Component/ScrollingList.h"
+#include "../Sound/Sound.h"
+#include "ComponentItemBindingBuilder.h"
+#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)
+{
+}
+
+Page::~Page()
+{
+   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;
+      }
+
+      LayerComponents[i].clear();
+   }
+
+   if(Menu)
+   {
+      delete Menu;
+   }
+
+   if(LoadSoundChunk)
+   {
+      delete LoadSoundChunk;
+      LoadSoundChunk = NULL;
+   }
+
+   if(UnloadSoundChunk)
+   {
+      delete UnloadSoundChunk;
+      UnloadSoundChunk = NULL;
+   }
+
+
+   if(HighlightSoundChunk)
+   {
+      delete HighlightSoundChunk;
+      HighlightSoundChunk = NULL;
+   }
+
+   if(SelectSoundChunk)
+   {
+      delete SelectSoundChunk;
+      SelectSoundChunk = NULL;
+   }
+}
+
+void Page::OnNewItemSelected(Item *item)
+{
+   SelectedItem = item;
+   SelectedItemChanged = true;
+}
+
+void Page::SetMenu(ScrollingList *s)
+{
+   // todo: delete the old menu
+   Menu = s;
+
+   if(Menu)
+   {
+      Menu->AddComponentForNotifications(this);
+   }
+}
+
+bool Page::AddComponent(Component *c)
+{
+   bool retVal = false;
+
+   unsigned int layer = c->GetBaseViewInfo()->GetLayer();
+
+
+   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());
+   }
+
+   return retVal;
+}
+
+bool Page::IsIdle()
+{
+   bool idle = true;
+
+   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();
+      }
+   }
+
+   return idle;
+}
+
+
+bool Page::IsHidden()
+{
+   bool hidden = true;
+
+    if(Menu != NULL)
+    {
+      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();
+       }
+    }
+
+    return hidden;
+}
+
+void Page::Start()
+{
+   Menu->TriggerEnterEvent();
+
+   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();
+      }
+   }
+}
+
+void Page::Stop()
+{
+   Menu->TriggerExitEvent();
+
+   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();
+      }
+   }
+}
+
+
+Item *Page::GetSelectedItem()
+{
+   return SelectedItem;
+}
+
+void Page::RemoveSelectedItem()
+{
+   if(Menu)
+   {
+      //todo: change method to RemoveItem() and pass in SelectedItem
+      Menu->RemoveSelectedItem();
+      SelectedItem = NULL;
+   }
+
+}
+
+
+void Page::Highlight()
+{
+   Item *item = SelectedItem;
+
+   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);
+         }
+      }
+   }
+}
+
+
+void Page::SetScrolling(ScrollDirection direction)
+{
+   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);
+   }
+}
+
+void Page::PageScroll(ScrollDirection direction)
+{
+   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);
+
+   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(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);
+      }
+   }
+}
+
+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();
+      }
+
+      Menu->Draw(i);
+   }
+}
+
+const std::string& Page::GetCollectionName() const
+{
+   return CollectionName;
+}
+
+void Page::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();
+
+   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();
+
+   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");
+}
+
+void Page::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();
+      }
+   }
+}
+
+void Page::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();
+      }
+   }
+}
+

Source/Graphics/Page.h

@@ -0,0 +1,71 @@
+/* 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 "MenuNotifierInterface.h"
+
+#include <vector>
+#include <string>
+
+class Component;
+class ScrollingList;
+class Item;
+class Sound;
+
+class Page : public MenuNotifierInterface
+{
+public:
+   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;
+
+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;
+
+};

Source/Graphics/PageBuilder.cpp

@@ -0,0 +1,674 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "PageBuilder.h"
+#include "Page.h"
+#include "ViewInfo.h"
+#include "Component/Image.h"
+#include "Component/Text.h"
+#include "Component/ReloadableText.h"
+#include "Component/ReloadableMedia.h"
+#include "Component/ScrollingList.h"
+#include "Animate/TweenTypes.h"
+#include "../Sound/Sound.h"
+#include "../Collection/Item.h"
+#include "../SDL.h"
+#include "../Utility/Log.h"
+#include "../Utility/Utils.h"
+#include <algorithm>
+#include <cfloat>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+#include <vector>
+
+using namespace rapidxml;
+
+
+PageBuilder::PageBuilder(std::string layoutKey, std::string collection, Configuration *c, FontCache *fc)
+: LayoutKey(layoutKey)
+, Collection(collection)
+, Config(c)
+, ScaleX(1)
+, ScaleY(1)
+, ScreenHeight(0)
+, ScreenWidth(0)
+, FC(fc)
+{
+   ScreenWidth = SDL::GetWindowWidth();
+   ScreenHeight = SDL::GetWindowHeight();
+   FontColor.a = 255;
+   FontColor.r = 255;
+   FontColor.g = 0;
+   FontColor.b = 0;
+}
+
+PageBuilder::~PageBuilder()
+{
+}
+
+Page *PageBuilder::BuildPage()
+{
+   Page *page = NULL;
+
+	std::string layoutFile;
+	std::string layoutName = LayoutKey;
+
+   LayoutPath = Configuration::GetAbsolutePath() + "/Layouts/" + layoutName;
+   layoutFile = LayoutPath + "/Layout.xml";
+
+   Logger::Write(Logger::ZONE_INFO, "Layout", "Initializing " + layoutFile);
+
+   rapidxml::xml_document<> doc;
+   std::ifstream file(layoutFile.c_str());
+   std::vector<char> buffer((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+
+   if(!file.good())
+   {
+      Logger::Write(Logger::ZONE_INFO, "Layout", "could not find layout file: " + layoutFile);
+      return NULL;
+   }
+
+	try
+   {
+      buffer.push_back('\0');
+
+      doc.parse<0>(&buffer[0]);
+
+      xml_node<> *root = doc.first_node("layout");
+
+
+      if(!root)
+      {
+         Logger::Write(Logger::ZONE_ERROR, "Layout", "Missing <layout> tag");
+         return NULL;
+      }
+      else
+      {
+         xml_attribute<> *layoutWidthXml = root->first_attribute("width");
+         xml_attribute<> *layoutHeightXml = root->first_attribute("height");
+         xml_attribute<> *fontXml = root->first_attribute("font");
+         xml_attribute<> *fontColorXml = root->first_attribute("fontColor");
+         int layoutHeight;
+         int layoutWidth;
+         if(!layoutWidthXml || !layoutHeightXml)
+         {
+            Logger::Write(Logger::ZONE_ERROR, "Layout", "<layout> tag must specify a width and height");
+            return NULL;
+         }
+         if(fontXml)
+         {
+            //todo: reuse from ComponentBuilder. Not sure how since it relies on knowing the collection
+            std::string fontPropertyKey  = "layouts." + LayoutKey + ".font";
+            Config->SetProperty(fontPropertyKey, fontXml->value());
+
+            Font = Config->ConvertToAbsolutePath(
+                     Config->GetAbsolutePath() + "/Layouts/" + LayoutKey + "/",
+                     fontXml->value());
+
+            Logger::Write(Logger::ZONE_DEBUG, "Layout", "Layout font set to " + Font);
+
+         }
+
+         if(fontColorXml)
+         {
+            int intColor = 0;
+            std::stringstream ss;
+            ss << std::hex << fontColorXml->value();
+            ss >> intColor;
+
+            FontColor.b = intColor & 0xFF;
+            intColor >>= 8;
+            FontColor.g = intColor & 0xFF;
+            intColor >>= 8;
+            FontColor.r = intColor & 0xFF;
+         }
+
+         layoutWidth = Utils::ConvertInt(layoutWidthXml->value());
+         layoutHeight = Utils::ConvertInt(layoutHeightXml->value());
+
+         if(layoutWidth == 0 || layoutHeight == 0)
+         {
+            Logger::Write(Logger::ZONE_ERROR, "Layout", "Layout width and height cannot be set to 0");
+            return NULL;
+         }
+
+         ScaleX = (float)ScreenWidth / (float)layoutWidth;
+         ScaleY = (float)ScreenHeight / (float)layoutHeight;
+
+         std::stringstream ss;
+         ss << layoutWidth << "x" << layoutHeight << " (scale " << ScaleX << "x" << ScaleY << ")";
+         Logger::Write(Logger::ZONE_DEBUG, "Layout", "Layout resolution " + ss.str());
+
+         page = new Page(Collection);
+
+         // load sounds
+         for(xml_node<> *sound = root->first_node("sound"); sound; sound = sound->next_sibling("sound"))
+         {
+            xml_attribute<> *src = sound->first_attribute("src");
+            xml_attribute<> *type = sound->first_attribute("type");
+            std::string file = Configuration::ConvertToAbsolutePath(LayoutPath, src->value());
+            if(!type)
+            {
+               Logger::Write(Logger::ZONE_ERROR, "Layout", "Sound tag missing type attribute");
+            }
+            else
+            {
+               Sound *sound = new Sound(file);
+               std::string soundType = type->value();
+
+               if(!soundType.compare("load"))
+               {
+                  page->SetLoadSound(sound);
+               }
+               else if(!soundType.compare("unload"))
+               {
+                  page->SetUnloadSound(sound);
+               }
+               else if(!soundType.compare("highlight"))
+               {
+                  page->SetHighlightSound(sound);
+               }
+               else if(!soundType.compare("select"))
+               {
+                  page->SetSelectSound(sound);
+               }
+               else
+               {
+                  Logger::Write(Logger::ZONE_WARNING, "Layout", "Unsupported sound effect type \"" + soundType + "\"");
+               }
+            }
+         }
+         if(!BuildComponents(root, page))
+         {
+            delete page;
+            page = NULL;
+         }
+
+      }
+
+   }
+	catch(rapidxml::parse_error &e)
+	{
+      std::string what = e.what();
+      long line = static_cast<long>(std::count(&buffer.front(), e.where<char>(), char('\n')) + 1);
+      std::stringstream ss;
+      ss << "Could not parse layout file. [Line: " << line << "] Reason: " << e.what();
+
+      Logger::Write(Logger::ZONE_ERROR, "Layout", ss.str());
+	}
+	catch(std::exception &e)
+	{
+	   std::string what = e.what();
+      Logger::Write(Logger::ZONE_ERROR, "Layout", "Could not parse layout file. Reason: " + what);
+	}
+
+	if(page)
+	{
+	   Logger::Write(Logger::ZONE_DEBUG, "Layout", "Created page");
+	}
+
+	return page;
+}
+
+
+
+float PageBuilder::GetHorizontalAlignment(xml_attribute<> *attribute, float valueIfNull)
+{
+   float value;
+   std::string str;
+
+   if(!attribute)
+   {
+      value = valueIfNull;
+   }
+   else
+   {
+      str = attribute->value();
+
+      if(!str.compare("left"))
+      {
+         value = 0;
+      }
+      else if(!str.compare("center"))
+      {
+         value = static_cast<float>(ScreenWidth) / 2;
+      }
+      else if(!str.compare("right") || !str.compare("stretch"))
+      {
+         value = static_cast<float>(ScreenWidth);
+      }
+      else
+      {
+         value = Utils::ConvertFloat(str) * ScaleX;
+      }
+   }
+
+   return value;
+}
+
+float PageBuilder::GetVerticalAlignment(xml_attribute<> *attribute, float valueIfNull)
+{
+   float value;
+   std::string str;
+   if(!attribute)
+   {
+      value = valueIfNull;
+   }
+   else
+   {
+      str = attribute->value();
+
+      if(!str.compare("top"))
+      {
+         value = 0;
+      }
+      else if(!str.compare("center"))
+      {
+         value = static_cast<float>(ScreenHeight / 2);
+      }
+      else if(!str.compare("bottom") || !str.compare("stretch"))
+      {
+         value = static_cast<float>(ScreenHeight);
+      }
+      else
+      {
+         value = Utils::ConvertFloat(str) * ScaleY;
+      }
+   }
+   return value;
+}
+
+
+
+
+bool PageBuilder::BuildComponents(xml_node<> *layout, Page *page)
+{
+   bool retVal = true;
+   xml_node<> *menuXml = layout->first_node("menu");
+   if(!menuXml)
+   {
+      Logger::Write(Logger::ZONE_ERROR, "Layout", "Missing menu tag");
+      retVal = false;
+   }
+   else if(menuXml)
+   {
+      ScrollingList *scrollingList = BuildCustomMenu(menuXml);
+      page->SetMenu(scrollingList);
+
+      for(xml_node<> *componentXml = layout->first_node("image"); componentXml; componentXml = componentXml->next_sibling("image"))
+      {
+         xml_attribute<> *src = componentXml->first_attribute("src");
+
+         if (!src)
+         {
+            Logger::Write(Logger::ZONE_ERROR, "Layout", "Image component in layout does not specify a source image file");
+         }
+         else
+         {
+            std::string imagePath;
+            imagePath = Configuration::ConvertToAbsolutePath(LayoutPath, imagePath);
+
+            imagePath.append("/");
+            imagePath.append(src->value());
+
+
+
+            Image *c = new Image(imagePath, ScaleX, ScaleY);
+            ViewInfo *v = c->GetBaseViewInfo();
+            BuildViewInfo(componentXml, v);
+            LoadTweens(c, componentXml);
+            page->AddComponent(c);
+         }
+      }
+
+      for(xml_node<> *componentXml = layout->first_node("text"); componentXml; componentXml = componentXml->next_sibling("text"))
+      {
+         xml_attribute<> *value = componentXml->first_attribute("value");
+
+         if (!value)
+         {
+            Logger::Write(Logger::ZONE_WARNING, "Layout", "Text component in layout does not specify a value");
+         }
+         else
+         {
+        	FC->LoadFont(Font, FontColor);
+            Text *c = new Text(value->value(), FC->GetFont(Font), FontColor, ScaleX, ScaleY);
+            ViewInfo *v = c->GetBaseViewInfo();
+
+            BuildViewInfo(componentXml, v);
+
+            LoadTweens(c, componentXml);
+            page->AddComponent(c);
+         }
+      }
+
+      LoadReloadableImages(layout, "reloadableImage", page);
+      LoadReloadableImages(layout, "reloadableVideo", page);
+      LoadReloadableImages(layout, "reloadableText", page);
+   }
+
+   return retVal;
+}
+
+void PageBuilder::LoadReloadableImages(xml_node<> *layout, std::string tagName, Page *page)
+{
+   for(xml_node<> *componentXml = layout->first_node(tagName.c_str()); componentXml; componentXml = componentXml->next_sibling(tagName.c_str()))
+   {
+      std::string reloadableImagePath;
+      std::string reloadableVideoPath;
+      xml_attribute<> *type = componentXml->first_attribute("type");
+
+      if(tagName == "reloadableVideo")
+      {
+         type = componentXml->first_attribute("imageType");
+      }
+
+
+      if(!type && tagName == "reloadableVideo")
+      {
+         Logger::Write(Logger::ZONE_WARNING, "Layout", "<reloadableImage> component in layout does not specify an imageType for when the video does not exist");
+      }
+      if(!type && (tagName == "reloadableImage" || tagName == "reloadableText"))
+      {
+         Logger::Write(Logger::ZONE_ERROR, "Layout", "Image component in layout does not specify a source image file");
+      }
+
+      if(type && (tagName == "reloadableVideo" || tagName == "reloadableImage"))
+      {
+         std::string configImagePath = "collections." + Collection + ".media." + type->value();
+         if(!Config->GetPropertyAbsolutePath(configImagePath, reloadableImagePath))
+         {
+            Logger::Write(Logger::ZONE_ERROR, "Layout", "Cannot process reloadable images because property \"" + configImagePath + "\" does not exist");
+         }
+
+         std::string configVideoPath = "collections." + Collection + ".media.video";
+
+         if(!Config->GetPropertyAbsolutePath(configVideoPath, reloadableVideoPath))
+         {
+            Logger::Write(Logger::ZONE_WARNING, "Layout", "Could not find videos folder as \"" + configVideoPath + "\" does not exist");
+         }
+      }
+
+
+      Component *c = NULL;
+
+      if(tagName == "reloadableText")
+      {
+         if(type)
+         {
+            FC->LoadFont(Font, FontColor);
+            c = new ReloadableText(type->value(), FC->GetFont(Font), FontColor, LayoutKey, Collection, ScaleX, ScaleY);
+         }
+      }
+      else
+      {
+         c = new ReloadableMedia(reloadableImagePath, reloadableVideoPath, (tagName == "reloadableVideo"), ScaleX, ScaleY);
+      }
+
+      if(c)
+      {
+         LoadTweens(c, componentXml);
+
+         page->AddComponent(c);
+      }
+   }
+}
+void PageBuilder::LoadTweens(Component *c, xml_node<> *componentXml)
+{
+   ViewInfo *v = c->GetBaseViewInfo();
+
+   BuildViewInfo(componentXml, v);
+
+   Component::TweenSets *tweenSets;
+   tweenSets = new std::vector<std::vector<Tween *> *>();
+   GetTweenSets(componentXml->first_node("onEnter"), tweenSets);
+   c->SetOnEnterTweens(tweenSets);
+
+   tweenSets = new std::vector<std::vector<Tween *> *>();
+   GetTweenSets(componentXml->first_node("onExit"), tweenSets);
+   c->SetOnExitTweens(tweenSets);
+
+   tweenSets = new std::vector<std::vector<Tween *> *>();
+   GetTweenSets(componentXml->first_node("onIdle"), tweenSets);
+   c->SetOnIdleTweens(tweenSets);
+
+   tweenSets = new std::vector<std::vector<Tween *> *>();
+   GetTweenSets(componentXml->first_node("onHighlightEnter"), tweenSets);
+   c->SetOnHighlightEnterTweens(tweenSets);
+
+   tweenSets = new std::vector<std::vector<Tween *> *>();
+   GetTweenSets(componentXml->first_node("onHighlightExit"), tweenSets);
+   c->SetOnHighlightExitTweens(tweenSets);
+}
+
+
+ScrollingList * PageBuilder::BuildCustomMenu(xml_node<> *menuXml)
+{
+   ScrollingList *menu = NULL;
+   std::string imageType="null";
+
+   xml_attribute<> *imageTypeXml = menuXml->first_attribute("imageType");
+
+   if(imageTypeXml)
+   {
+      imageType = imageTypeXml->value();
+   }
+
+   FC->LoadFont(Font, FontColor);
+   menu = new ScrollingList(Config, ScaleX, ScaleY, FC->GetFont(Font), FontColor, LayoutKey, Collection, imageType);
+
+   ViewInfo *v = menu->GetBaseViewInfo();
+   BuildViewInfo(menuXml, v);
+
+   std::vector<ViewInfo *> *points = new std::vector<ViewInfo *>();
+
+   int i = 0;
+   for(xml_node<> *componentXml = menuXml->first_node("item"); componentXml; componentXml = componentXml->next_sibling("item"))
+   {
+      ViewInfo *viewInfo = new ViewInfo();
+      BuildViewInfo(componentXml, viewInfo);
+
+      points->push_back(viewInfo);
+
+      xml_attribute<> *selected = componentXml->first_attribute("selected");
+
+      if(selected)
+      {
+         menu->SetSelectedIndex(i);
+      }
+
+      i++;
+   }
+
+   menu->SetPoints(points);
+
+
+   return menu;
+}
+
+
+xml_attribute<> *PageBuilder::FindRecursiveAttribute(xml_node<> *componentXml, std::string attribute)
+{
+
+   xml_attribute<> *attributeXml = NULL;
+   xml_node<> *parent = componentXml->parent();
+
+   // root xml node height and width attributes are to define the layout size itself, not the elements
+   if(parent && parent->parent())
+   {
+      attributeXml = componentXml->first_attribute(attribute.c_str());
+
+      if(!attributeXml)
+      {
+          attributeXml = FindRecursiveAttribute(parent, attribute);
+      }
+   }
+
+   return attributeXml;
+}
+
+void PageBuilder::BuildViewInfo(xml_node<> *componentXml, ViewInfo *info)
+{
+   xml_attribute<> *x = FindRecursiveAttribute(componentXml, "x");
+   xml_attribute<> *y = FindRecursiveAttribute(componentXml, "y");
+   xml_attribute<> *xOffset = FindRecursiveAttribute(componentXml, "xOffset");
+   xml_attribute<> *yOffset = FindRecursiveAttribute(componentXml, "yOffset");
+   xml_attribute<> *xOrigin = FindRecursiveAttribute(componentXml, "xOrigin");
+   xml_attribute<> *yOrigin = FindRecursiveAttribute(componentXml, "yOrigin");
+   xml_attribute<> *height = FindRecursiveAttribute(componentXml, "height");
+   xml_attribute<> *width = FindRecursiveAttribute(componentXml, "width");
+   xml_attribute<> *fontSize = FindRecursiveAttribute(componentXml, "fontSize");
+   xml_attribute<> *minHeight = FindRecursiveAttribute(componentXml, "minHeight");
+   xml_attribute<> *minWidth = FindRecursiveAttribute(componentXml, "minWidth");
+   xml_attribute<> *maxHeight = FindRecursiveAttribute(componentXml, "maxHeight");
+   xml_attribute<> *maxWidth = FindRecursiveAttribute(componentXml, "maxWidth");
+   xml_attribute<> *transparency = FindRecursiveAttribute(componentXml, "transparency");
+   xml_attribute<> *angle = FindRecursiveAttribute(componentXml, "angle");
+   xml_attribute<> *layer = FindRecursiveAttribute(componentXml, "layer");
+
+   info->SetX(GetHorizontalAlignment(x, 0));
+   info->SetY(GetVerticalAlignment(y, 0));
+
+
+   info->SetXOffset( GetHorizontalAlignment(xOffset, 0));
+   info->SetYOffset( GetVerticalAlignment(yOffset, 0));
+   float xOriginRelative = GetHorizontalAlignment(xOrigin, 0);
+   float yOriginRelative = GetVerticalAlignment(yOrigin, 0);
+
+   // the origins need to be saved as a percent since the heights and widths can be scaled
+   info->SetXOrigin(xOriginRelative / ScreenWidth);
+   info->SetYOrigin(yOriginRelative / ScreenHeight);
+
+
+   if(!height && !width)
+   {
+      info->SetHeight(-1);
+      info->SetWidth(-1);
+   }
+   else
+   {
+      info->SetHeight(GetVerticalAlignment(height, -1));
+      info->SetWidth(GetHorizontalAlignment(width, -1));
+   }
+   info->SetFontSize(GetVerticalAlignment(fontSize, -1));
+   /*
+   std::stringstream ss;
+   ss << "font size is \"" << info->GetFontSize() << "\"";
+   Logger::Write(Logger::ZONE_ERROR, "Layout", ss.str());
+   */
+   info->SetMinHeight(GetVerticalAlignment(minHeight, 0));
+   info->SetMinWidth(GetHorizontalAlignment(minWidth, 0));
+   info->SetMaxHeight(GetVerticalAlignment(maxHeight, FLT_MAX));
+   info->SetMaxWidth(GetVerticalAlignment(maxWidth, FLT_MAX));
+   info->SetTransparency( transparency ? Utils::ConvertFloat(transparency->value()) : 1);
+   info->SetAngle( angle ? Utils::ConvertFloat(angle->value()) : 0);
+   info->SetLayer( layer ? Utils::ConvertInt(layer->value()) : 0);
+}
+
+
+void PageBuilder::GetTweenSets(xml_node<> *node, std::vector<std::vector<Tween *> *> *tweenSets)
+{
+   if(node)
+   {
+      for(xml_node<> *set = node->first_node("set"); set; set = set->next_sibling("set"))
+      {
+         std::vector<Tween *> *tweens = new std::vector<Tween *>();
+         GetTweenSet(set, *tweens);
+         tweenSets->push_back(tweens);
+      }
+   }
+}
+
+void PageBuilder::GetTweenSet(xml_node<> *node, std::vector<Tween *> &tweens)
+{
+   xml_attribute<> *durationXml = node->first_attribute("duration");
+
+   if(!durationXml)
+   {
+      Logger::Write(Logger::ZONE_ERROR, "Layout", "Animation set tag missing \"duration\" attribute");
+   }
+   else
+   {
+      for(xml_node<> *animate = node->first_node("animate"); animate; animate = animate->next_sibling("animate"))
+      {
+         xml_attribute<> *type = animate->first_attribute("type");
+         xml_attribute<> *from = animate->first_attribute("from");
+         xml_attribute<> *to = animate->first_attribute("to");
+         xml_attribute<> *algorithmXml = animate->first_attribute("algorithm");
+
+         if(!type)
+         {
+            Logger::Write(Logger::ZONE_ERROR, "Layout", "Animate tag missing \"type\" attribute");
+         }
+         else if(!from)
+         {
+            Logger::Write(Logger::ZONE_ERROR, "Layout", "Animate tag missing \"from\" attribute");
+         }
+         else if(!to)
+         {
+            Logger::Write(Logger::ZONE_ERROR, "Layout", "Animate tag missing \"to\" attribute");
+         }
+         else
+         {
+            float fromValue = Utils::ConvertFloat(from->value());
+            float toValue = Utils::ConvertFloat(to->value());
+            float durationValue = Utils::ConvertFloat(durationXml->value());
+
+            TweenAlgorithm algorithm = LINEAR;
+            TweenProperty property;
+
+            if(algorithmXml)
+            {
+               algorithm = Tween::GetTweenType(algorithmXml->value());
+
+            }
+
+            if(Tween::GetTweenProperty(type->value(), property))
+            {
+               switch(property)
+               {
+                  case TWEEN_PROPERTY_WIDTH:
+                  case TWEEN_PROPERTY_X:
+                  case TWEEN_PROPERTY_X_OFFSET:
+                     fromValue = GetHorizontalAlignment(from, 0);
+                     toValue = GetHorizontalAlignment(to, 0);
+                     break;
+
+                     // x origin gets translated to a percent
+                  case TWEEN_PROPERTY_X_ORIGIN:
+                     fromValue = GetHorizontalAlignment(from, 0) / ScreenWidth;
+                     toValue = GetHorizontalAlignment(to, 0) / ScreenWidth;
+                     break;
+
+                  case TWEEN_PROPERTY_HEIGHT:
+                  case TWEEN_PROPERTY_Y:
+                  case TWEEN_PROPERTY_Y_OFFSET:
+                  case TWEEN_PROPERTY_FONT_SIZE:
+                     fromValue = GetVerticalAlignment(from, 0);
+                     toValue = GetVerticalAlignment(to, 0);
+                     break;
+
+                  // y origin gets translated to a percent
+                  case TWEEN_PROPERTY_Y_ORIGIN:
+                     fromValue = GetVerticalAlignment(from, 0) / ScreenHeight;
+                     toValue = GetVerticalAlignment(to, 0) / ScreenHeight;
+                     break;
+
+                  default:
+                     break;
+               }
+
+               Tween *t = new Tween(property, algorithm, fromValue, toValue, durationValue);
+               tweens.push_back(t);
+            }
+            else
+            {
+               std::stringstream ss;
+               ss << "Unsupported tween type attribute \"" << type->value() << "\"";
+               Logger::Write(Logger::ZONE_ERROR, "Layout", ss.str());
+            }
+         }
+      }
+   }
+}

Source/Graphics/PageBuilder.h

@@ -0,0 +1,59 @@
+/* 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 "Component/Image.h"
+#include "FontCache.h"
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_mixer.h>
+#include <rapidxml.hpp>
+#include <vector>
+
+class ScrollingList;
+class Page;
+class ViewInfo;
+class Configuration;
+
+class PageBuilder
+{
+public:
+	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);
+
+	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 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);
+};

Source/Graphics/ViewInfo.cpp

@@ -0,0 +1,300 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "ViewInfo.h"
+#include "../Database/Configuration.h"
+#include "Animate/TweenTypes.h"
+#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)
+{
+}
+
+
+ViewInfo::~ViewInfo()
+{
+}
+
+float ViewInfo::GetXRelativeToOrigin() const
+{
+   return X + XOffset - XOrigin*GetWidth();
+}
+
+float ViewInfo::GetYRelativeToOrigin() const
+{
+   return Y + YOffset - YOrigin*GetHeight();
+}
+
+float ViewInfo::GetHeight() const
+{
+   float value = Height;
+
+   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;
+      }
+   }
+
+   return value;
+}
+
+float ViewInfo::GetWidth() const
+{
+   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;
+      }
+   }
+
+   return value;
+}
+
+float ViewInfo::GetXOffset() const
+{
+   return XOffset;
+}
+
+
+float ViewInfo::GetXOrigin() const
+{
+   return XOrigin;
+}
+
+
+float ViewInfo::GetYOffset() const
+{
+   return YOffset;
+}
+
+
+float ViewInfo::GetYOrigin() const
+{
+   return YOrigin;
+}
+
+float ViewInfo::GetAngle() const
+{
+   return Angle;
+}
+
+void ViewInfo::SetAngle(float angle)
+{
+   Angle = angle;
+}
+
+float ViewInfo::GetImageHeight() const
+{
+   return ImageHeight;
+}
+
+void ViewInfo::SetImageHeight(float imageheight)
+{
+   ImageHeight = imageheight;
+}
+
+float ViewInfo::GetImageWidth() const
+{
+   return ImageWidth;
+}
+
+void ViewInfo::SetImageWidth(float imagewidth)
+{
+   ImageWidth = imagewidth;
+}
+
+unsigned int ViewInfo::GetLayer() const
+{
+   return Layer;
+}
+
+void ViewInfo::SetLayer(unsigned int layer)
+{
+   Layer = layer;
+}
+
+float ViewInfo::GetMaxHeight() const
+{
+   return MaxHeight;
+}
+
+void ViewInfo::SetMaxHeight(float maxheight)
+{
+   MaxHeight = maxheight;
+}
+
+float ViewInfo::GetMaxWidth() const
+{
+   return MaxWidth;
+}
+
+void ViewInfo::SetMaxWidth(float maxwidth)
+{
+   MaxWidth = maxwidth;
+}
+
+float ViewInfo::GetMinHeight() const
+{
+   return MinHeight;
+}
+
+void ViewInfo::SetMinHeight(float minheight)
+{
+   MinHeight = minheight;
+}
+
+float ViewInfo::GetMinWidth() const
+{
+   return MinWidth;
+}
+
+void ViewInfo::SetMinWidth(float minwidth)
+{
+   MinWidth = minwidth;
+}
+
+float ViewInfo::GetTransparency() const
+{
+   return Transparency;
+}
+
+void ViewInfo::SetTransparency(float transparency)
+{
+   Transparency = transparency;
+}
+
+float ViewInfo::GetX() const
+{
+   return X;
+}
+
+void ViewInfo::SetX(float x)
+{
+   X = x;
+}
+
+void ViewInfo::SetXOffset(float offset)
+{
+   XOffset = offset;
+}
+
+
+void ViewInfo::SetXOrigin(float origin)
+{
+   XOrigin = origin;
+}
+
+float ViewInfo::GetY() const
+{
+   return Y;
+}
+
+void ViewInfo::SetY(float y)
+{
+   Y = y;
+}
+
+void ViewInfo::SetYOffset(float offset)
+{
+   YOffset = offset;
+}
+
+
+void ViewInfo::SetYOrigin(float origin)
+{
+   YOrigin = origin;
+}
+
+float ViewInfo::GetRawYOrigin()
+{
+   return YOrigin;
+}
+float ViewInfo::GetRawXOrigin()
+{
+   return XOrigin;
+}
+
+float ViewInfo::GetRawWidth()
+{
+   return Width;
+}
+
+float ViewInfo::GetRawHeight()
+{
+   return Height;
+}
+
+void ViewInfo::SetHeight(float height)
+{
+   Height = height;
+}
+
+void ViewInfo::SetWidth(float width)
+{
+   Width = width;
+}
+
+float ViewInfo::GetFontSize() const
+{
+   if(FontSize == -1)
+   {
+      return GetHeight();
+   }
+   else
+   {
+      return FontSize;
+   }
+}
+
+void ViewInfo::SetFontSize(float fontSize)
+{
+   FontSize = fontSize;
+}

Source/Graphics/ViewInfo.h

@@ -0,0 +1,89 @@
+/* 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 "Animate/TweenTypes.h"
+#include <string>
+#include <map>
+
+class ViewInfo
+{
+public:
+
+   ViewInfo();
+   virtual ~ViewInfo();
+
+   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();
+
+   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;
+
+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;
+};

Source/Main.cpp

@@ -0,0 +1,198 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "Database/Configuration.h"
+#include "Database/CollectionDatabase.h"
+#include "Collection/CollectionInfoBuilder.h"
+#include "Collection/CollectionInfo.h"
+#include "Database/DB.h"
+#include "Database/MamelistMetadata.h"
+#include "Execute/Launcher.h"
+#include "Utility/Log.h"
+#include "Utility/Utils.h"
+#include "RetroFE.h"
+#include "Version.h"
+#include <cstdlib>
+#include <fstream>
+#include <dirent.h>
+
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
+static bool ImportConfiguration(Configuration *c);
+
+int main(int argc, char *argv[])
+{
+   Configuration config;
+   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);
+#else
+      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);
+   }
+
+   // set the log file to write to
+   std::string logFile = Configuration::GetAbsolutePath() + "/Log.txt";
+
+   if(!Logger::StartLogFile(logFile))
+   {
+      Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not open \"" + logFile + "\" for writing");
+   }
+
+   Logger::Write(Logger::ZONE_INFO, "RetroFE", "Version " + Version::GetString() + " starting");
+#ifdef WIN32
+   Logger::Write(Logger::ZONE_INFO, "RetroFE", "OS: Windows");
+#else
+   Logger::Write(Logger::ZONE_INFO, "RetroFE", "OS: Linux");
+#endif
+
+   if(environment)
+   {
+      Logger::Write(Logger::ZONE_INFO, "RetroFE", "Environment variable set: RetroFE_PATH=" + environmentStr);
+   }
+
+   Logger::Write(Logger::ZONE_INFO, "RetroFE", "Absolute path: " + Configuration::GetAbsolutePath());
+
+   if(!ImportConfiguration(&config))
+   {
+	   return -1;
+   }
+
+   Logger::Write(Logger::ZONE_INFO, "RetroFE", "Imported configuration");
+
+   std::string dbFile = (Configuration::GetAbsolutePath() + "/cache.db");
+   std::ifstream infile(dbFile.c_str());
+   DB db;
+   if(!db.Initialize())
+   {
+	   return -1;
+   }
+
+   CollectionDatabase cdb(&db, &config);
+
+   cdb.CheckDatabase();
+
+   if(cdb.Import())
+   {
+      RetroFE p(&cdb, &config);
+
+      if(p.Initialize())
+      {
+         p.Run();
+      }
+
+      p.DeInitialize();
+   }
+
+   Logger::CloseLogFile();
+	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;
+
+   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;
+   }
+
+   dp = opendir(launchersPath.c_str());
+
+   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))
+        {
+          Logger::Write(Logger::ZONE_ERROR, "RetroFE", "Could not import \"" + settingsFile + "\"");
+          return false;
+        }
+      }
+   }
+
+   return true;
+}

Source/RetroFE.cpp

@@ -0,0 +1,499 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "RetroFE.h"
+#include "Database/CollectionDatabase.h"
+#include "Database/Configuration.h"
+#include "Collection/Item.h"
+#include "Execute/Launcher.h"
+#include "Utility/Log.h"
+#include "Collection/MenuParser.h"
+#include "SDL.h"
+#include "Control/UserInput.h"
+#include "Graphics/PageBuilder.h"
+#include "Graphics/Page.h"
+#include "Graphics/Component/ScrollingList.h"
+#include "Video/VideoFactory.h"
+#include <vector>
+#include <string>
+#include <sstream>
+#ifdef WIN32
+#include <Windows.h>
+#include <SDL2/SDL_syswm.h>
+#endif
+
+
+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)
+{
+}
+
+RetroFE::~RetroFE()
+{
+   DeInitialize();
+}
+
+void RetroFE::Render()
+{
+   SDL_LockMutex(SDL::GetMutex());
+   SDL_SetRenderDrawColor(SDL::GetRenderer(), 0x0, 0x0, 0x00, 0xFF);
+   SDL_RenderClear(SDL::GetRenderer());
+
+   Page *page = PageChain.back();
+
+   if(page)
+   {
+      page->Draw();
+   }
+
+   SDL_RenderPresent(SDL::GetRenderer());
+   SDL_UnlockMutex(SDL::GetMutex());
+}
+
+bool RetroFE::Initialize()
+{
+   Logger::Write(Logger::ZONE_INFO, "RetroFE", "Initializing");
+
+   if(!Input.Initialize()) return false;
+   if(!SDL::Initialize(Config)) return false;
+   FC.Initialize();
+
+   bool videoEnable = true;
+   int videoLoop = 0;
+
+   Config->GetProperty("videoEnable", videoEnable);
+   Config->GetProperty("videoLoop", videoLoop);
+
+   VideoFactory::SetEnabled(videoEnable);
+   VideoFactory::SetNumLoops(videoLoop);
+   VideoFactory vf;
+   VideoInst = vf.CreateVideo();
+
+   return true;
+}
+
+void RetroFE::LaunchEnter()
+{
+   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);
+
+   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();
+
+   SDL::DeInitialize();
+}
+
+void RetroFE::AllocateGraphicsMemory()
+{
+   SDL::Initialize(Config);
+
+   FC.Initialize();
+
+   if(PageChain.size() > 0)
+   {
+      Page *p = PageChain.back();
+      p->AllocateGraphicsMemory();
+      p->Start();
+   }
+}
+
+bool RetroFE::DeInitialize()
+{
+   bool retVal = true;
+   FreeGraphicsMemory();
+
+   bool videoEnable = true;
+
+   while(PageChain.size() > 0)
+   {
+      Page *page = PageChain.back();
+      delete page;
+      PageChain.pop_back();
+   }
+
+   if(VideoInst)
+   {
+      delete VideoInst;
+      VideoInst = NULL;
+   }
+
+   //todo: handle video deallocation
+   return retVal;
+}
+
+Configuration *RetroFE::GetConfiguration()
+{
+	return Config;
+}
+
+
+void RetroFE::Run()
+{
+   int attractModeTime = 0;
+   bool attractMode = false;
+   std::string firstCollection = "Main";
+
+   Config->GetProperty("attractModeTime", attractModeTime);
+   Config->GetProperty("firstCollection", firstCollection);
+
+   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");
+
+   page = LoadPage(firstCollection);
+
+   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);
+
+      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;
+
+      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_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_WAIT:
+         if(page->IsHidden())
+         {
+            PageChain.pop_back();
+            delete page;
+
+            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;
+
+         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)
+            {
+               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();
+
+   if(!item) return false;
+
+   if(item->IsLeaf())
+   {
+      Launcher l(this);
+
+      l.Run(page->GetCollectionName(), item);
+   }
+   else
+   {
+      NextPageItem = item;
+      LoadPage(page->GetCollectionName());
+      page->Stop();
+   }
+
+   return true;
+}
+
+bool RetroFE::Back(bool &exit)
+{
+   bool canGoBack = 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;
+   }
+
+   return canGoBack;
+}
+
+
+RetroFE::RETROFE_STATE RetroFE::ProcessUserInput()
+{
+   SDL_Event e;
+   bool exit = false;
+   RETROFE_STATE state = RETROFE_IDLE;
+
+   if (SDL_PollEvent(&e) == 0) return state;
+
+   if(e.type == SDL_KEYDOWN || e.type == SDL_KEYUP)
+   {
+      const Uint8 *keys = SDL_GetKeyboardState(NULL);
+
+      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(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::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);
+      }
+   }
+
+   return state;
+}
+
+
+
+Page *RetroFE::LoadPage(std::string 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;
+
+   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";
+
+      if(!Config->GetProperty(layoutKeyName, layoutName))
+      {
+         Config->GetProperty("layout", layoutName);
+      }
+
+
+      if(PageChain.size() > 0)
+      {
+         Page *oldPage = PageChain.back();
+
+         if(oldPage)
+         {
+            oldPage->FreeGraphicsMemory();
+         }
+      }
+
+      PageBuilder pb(layoutName, collectionName, Config, &FC);
+      page = pb.BuildPage();
+      page->SetItems(collection);
+      page->Start();
+
+      if(page)
+      {
+         PageChain.push_back(page);
+      }
+   }
+
+   return page;
+}

Source/RetroFE.h

@@ -0,0 +1,65 @@
+/* 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"
+#include "Control/UserInput.h"
+#include "Graphics/FontCache.h"
+#include "Video/IVideo.h"
+#include <SDL2/SDL.h>
+#include <list>
+
+class CollectionDatabase;
+class Configuration;
+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();
+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,
+   };
+
+   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;
+
+};

Source/SDL.cpp

@@ -0,0 +1,256 @@
+/* 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"
+#include <SDL2/SDL_mixer.h>
+
+SDL_Window *SDL::Window = NULL;
+SDL_Renderer *SDL::Renderer = NULL;
+SDL_mutex *SDL::Mutex = NULL;
+int SDL::DisplayWidth = 0;
+int SDL::DisplayHeight = 0;
+int SDL::WindowWidth = 0;
+int SDL::WindowHeight = 0;
+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;
+
+   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);
+      }
+   }
+
+   // 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)
+         {
+            SDL_DisplayMode mode;
+            if(SDL_GetCurrentDisplayMode(i, &mode) == 0)
+            {
+               WindowWidth = mode.w;
+               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)
+            {
+               WindowHeight = mode.h;
+               break;
+            }
+         }
+      }
+      else if(!config->GetProperty("vertical", WindowHeight))
+      {
+         Logger::Write(Logger::ZONE_ERROR, "Configuration", "Invalid property value for \"vertical\"");
+      }
+   }
+
+   if(retVal && !config->GetProperty("fullscreen", Fullscreen))
+   {
+      Logger::Write(Logger::ZONE_ERROR, "Configuration", "Missing property: \"fullscreen\"");
+      retVal = false;
+   }
+
+   if (retVal && Fullscreen)
+   {
+      windowFlags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
+   }
+
+   if(retVal)
+   {
+      std::stringstream ss;
+      ss << "Creating "<< WindowWidth << "x" << WindowHeight << " window (fullscreen: " << Fullscreen << ")";
+      Logger::Write(Logger::ZONE_DEBUG, "SDL", ss.str());
+
+      Window = SDL_CreateWindow("RetroFE",
+                               SDL_WINDOWPOS_CENTERED,
+                               SDL_WINDOWPOS_CENTERED,
+                               WindowWidth,
+                               WindowHeight,
+                               windowFlags);
+
+      if (Window == NULL)
+      {
+         std::string error = SDL_GetError();
+         Logger::Write(Logger::ZONE_ERROR, "SDL", "Create window failed: " + error);
+         retVal = false;
+      }
+   }
+
+   if(retVal)
+   {
+      Renderer = SDL_CreateRenderer(Window,
+                             -1,
+                             SDL_RENDERER_ACCELERATED);
+
+      if (Renderer == NULL)
+      {
+         std::string error = SDL_GetError();
+         Logger::Write(Logger::ZONE_ERROR, "SDL", "Create renderer failed: " + error);
+         retVal = false;
+      }
+   }
+
+   if(retVal)
+   {
+      Mutex = SDL_CreateMutex();
+
+      if (Mutex == NULL)
+      {
+         std::string error = SDL_GetError();
+         Logger::Write(Logger::ZONE_ERROR, "SDL", "Mutex creation failed: " + error);
+         retVal = false;
+      }
+   }
+
+   //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");
+
+   Mix_CloseAudio();
+   Mix_Quit();
+   if(Mutex)
+   {
+      SDL_DestroyMutex(Mutex);
+      Mutex = NULL;
+   }
+
+   if(Renderer)
+   {
+      SDL_DestroyRenderer(Renderer);
+      Renderer = NULL;
+   }
+
+   if(Window)
+   {
+      SDL_DestroyWindow(Window);
+      Window = NULL;
+   }
+
+   SDL_ShowCursor(SDL_TRUE);
+
+   SDL_Quit();
+
+   return true;
+}
+
+SDL_Renderer* SDL::GetRenderer()
+{
+   return Renderer;
+}
+
+SDL_mutex* SDL::GetMutex()
+{
+   return Mutex;
+}
+
+SDL_Window* SDL::GetWindow()
+{
+   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;
+
+   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);
+
+   return true;
+}

Source/SDL.h

@@ -0,0 +1,32 @@
+/* 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>
+
+// todo: this wrapper could be cleaned up
+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; }
+
+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;
+};

Source/Sound/Sound.cpp

@@ -0,0 +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)
+{
+   if(!Allocate())
+   {
+      Logger::Write(Logger::ZONE_ERROR, "Sound", "Cannot load " + File);
+   }
+}
+
+Sound::~Sound()
+{
+   if(Chunk)
+   {
+      Mix_FreeChunk(Chunk);
+      Chunk = NULL;
+   }
+}
+
+void Sound::Play()
+{
+   if(Chunk)
+   {
+      (void)Mix_PlayChannel(-1, Chunk, 0);
+   }
+}
+
+bool Sound::Free()
+{
+   if(Chunk)
+   {
+      Mix_FreeChunk(Chunk);
+      Chunk = NULL;
+   }
+
+   return true;
+}
+
+bool Sound::Allocate()
+{
+   if(!Chunk)
+   {
+      Chunk = Mix_LoadWAV(File.c_str());
+   }
+
+   return (Chunk != NULL);
+}

Source/Sound/Sound.h

@@ -0,0 +1,19 @@
+/* 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>
+#include <SDL2/SDL_mixer.h>
+class Sound
+{
+public:
+   Sound(std::string file);
+   virtual ~Sound();
+   void Play();
+   bool Allocate();
+   bool Free();
+private:
+   std::string File;
+   Mix_Chunk *Chunk;
+};

Source/Utility/Log.cpp

@@ -0,0 +1,64 @@
+/* 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>
+#include <sstream>
+#include <ctime>
+
+std::ofstream Logger::WriteFileStream;
+std::streambuf *Logger::CerrStream = NULL;
+std::streambuf *Logger::CoutStream = NULL;
+
+bool Logger::StartLogFile(std::string file)
+{
+   WriteFileStream.open(file.c_str());
+
+   CerrStream = std::cerr.rdbuf(WriteFileStream.rdbuf());
+   CoutStream = std::cout.rdbuf(WriteFileStream.rdbuf());
+
+   return WriteFileStream.is_open();
+}
+
+void Logger::CloseLogFile()
+{
+   if(WriteFileStream.is_open())
+   {
+      WriteFileStream.close();
+
+   }
+
+   std::cerr.rdbuf(CerrStream);
+   std::cout.rdbuf(CoutStream);
+}
+
+
+void Logger::Write(Zone zone, std::string component, std::string message)
+{
+   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);
+
+   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();
+}

Source/Utility/Log.h

@@ -0,0 +1,31 @@
+/* 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>
+#include <fstream>
+#include <sstream>
+#include <streambuf>
+#include <iostream>
+
+class Logger
+{
+public:
+   enum Zone
+   {
+      ZONE_DEBUG,
+      ZONE_INFO,
+      ZONE_WARNING,
+      ZONE_ERROR
+
+   };
+   static bool StartLogFile(std::string file);
+   static void Write(Zone zone, std::string component, std::string message);
+   static void CloseLogFile();
+private:
+
+   static std::streambuf *CerrStream;
+   static std::streambuf *CoutStream;
+   static std::ofstream WriteFileStream;
+};

Source/Utility/Utils.cpp

@@ -0,0 +1,131 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "Utils.h"
+#include "../Database/Configuration.h"
+#include "Log.h"
+#include <algorithm>
+#include <sstream>
+#include <fstream>
+#include <dirent.h>
+
+Utils::Utils()
+{
+}
+
+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);
+
+      std::ifstream f(temp.c_str());
+
+      if (f.good())
+      {
+         file = temp;
+         return true;
+      }
+   }
+
+   return false;
+}
+
+
+std::string Utils::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;
+}
+
+
+float Utils::ConvertFloat(std::string content)
+{
+   float retVal = 0;
+   std::stringstream ss;
+   ss << content;
+   ss >> retVal;
+
+   return retVal;
+}
+
+int Utils::ConvertInt(std::string content)
+{
+   int retVal = 0;
+   std::stringstream ss;
+   ss << content;
+   ss >> retVal;
+
+   return retVal;
+}
+
+void Utils::NormalizeBackSlashes(std::string& content)
+{
+	std::replace(content.begin(), content.end(), '\\', '/');
+}
+
+std::string Utils::GetDirectory(std::string 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);
+   }
+
+   return directory;
+}
+
+std::string Utils::GetParentDirectory(std::string 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('/');
+   }
+
+   if (std::string::npos != last_slash_idx)
+   {
+      directory = directory.erase(last_slash_idx, directory.length());
+   }
+
+   return directory;
+}
+
+
+std::string Utils::GetFileName(std::string 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);
+   }
+
+   return filename;
+}
+

Source/Utility/Utils.h

@@ -0,0 +1,26 @@
+/* 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>
+#include <vector>
+
+class Utils
+{
+public:
+   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);
+private:
+   Utils();
+   virtual ~Utils();
+};
+

Source/Version.cpp

@@ -0,0 +1,37 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "Version.h"
+#include <sstream>
+
+#ifndef RETROFE_VERSION_MAJOR
+#define RETROFE_VERSION_MAJOR 0
+#endif
+
+#ifndef RETROFE_VERSION_MINOR
+#define RETROFE_VERSION_MINOR 0
+#endif
+
+#ifndef RETROFE_VERSION_BUILD
+#define RETROFE_VERSION_BUILD 0
+#endif
+
+#ifndef RETROFE_VERSION_PROD
+#define RETROFE_VERSION_BETA
+#endif
+
+std::string Version::GetString()
+{
+   std::stringstream version;
+   version << RETROFE_VERSION_MAJOR;
+   version << ".";
+   version << RETROFE_VERSION_MINOR;
+   version << ".";
+   version << RETROFE_VERSION_BUILD;
+
+#ifdef RETROFE_VERSION_BETA
+   version << "-beta";
+#endif
+
+   return version.str();
+}

Source/Version.h

@@ -0,0 +1,12 @@
+/* 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>
+
+class Version
+{
+public:
+   static std::string GetString();
+};

Source/Video/GStreamerVideo.cpp

@@ -0,0 +1,351 @@
+/* This file is subject to the terms and conditions defined in
+ * file 'LICENSE.txt', which is part of this source code package.
+ */
+#include "GStreamerVideo.h"
+#include "../Graphics/ViewInfo.h"
+#include "../Graphics/Component/Image.h"
+#include "../Database/Configuration.h"
+#include "../Utility/Log.h"
+#include "../SDL.h"
+#include <sstream>
+#include <cstring>
+#include <cstdlib>
+#include <cstdio>
+#include <SDL2/SDL.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <gst/app/gstappsink.h>
+
+bool GStreamerVideo::Initialized = false;
+
+//todo: this started out as sandbox code. This class needs to be refactored
+
+// 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;
+}
+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)
+{
+}
+GStreamerVideo::~GStreamerVideo()
+{
+   Stop();
+}
+
+void GStreamerVideo::SetNumLoops(int n)
+{
+	NumLoops = n;
+}
+
+SDL_Texture *GStreamerVideo::GetTexture() const
+{
+   return Texture;
+}
+
+void GStreamerVideo::ProcessNewBuffer (GstElement *fakesink, GstBuffer *buf, GstPad *new_pad, gpointer userdata)
+{
+   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);
+
+         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());
+}
+
+
+bool GStreamerVideo::Initialize()
+{
+   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());
+
+   Initialized = true;
+
+   return retVal;
+}
+
+bool GStreamerVideo::DeInitialize()
+{
+   gst_deinit();
+   Initialized = false;
+   return true;
+}
+
+
+bool GStreamerVideo::Stop()
+{
+   if(!Initialized)
+   {
+      return false;
+   }
+
+   if(VideoSink)
+   {
+      g_object_set(G_OBJECT(VideoSink), "signal-handoffs", FALSE, NULL);
+   }
+
+   if(Playbin)
+   {
+     (void)gst_element_set_state(Playbin, GST_STATE_NULL);
+   }
+
+   FreeElements();
+
+   IsPlaying = false;
+
+   if(Texture)
+   {
+      SDL_DestroyTexture(Texture);
+      Texture = NULL;
+   }
+   IsPlaying = false;
+   Height = 0;
+   Width = 0;
+   FrameReady = false;
+
+   if(VideoBuffer)
+   {
+      delete VideoBuffer;
+      VideoBuffer = NULL;
+   }
+   return true;
+}
+
+bool GStreamerVideo::Play(std::string file)
+{
+   PlayCount = 0;
+
+   if(!Initialized)
+   {
+      return false;
+   }
+
+   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;
+
+  //    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");
+
+      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);
+
+      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;
+
+      g_object_set(G_OBJECT(Playbin), "uri", file.c_str(), "video-sink", VideoBin, NULL);
+
+      IsPlaying = true;
+
+
+      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);
+
+      /* 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;
+}
+
+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;
+   }
+   
+}
+
+void GStreamerVideo::Draw()
+{
+   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);
+   }
+
+   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)
+            {
+               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);
+      }
+   }
+}
+

Source/Video/GStreamerVideo.h

@@ -0,0 +1,50 @@
+/* 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 "IVideo.h"
+
+extern "C"
+{
+#include <gst/gst.h>
+#include <gst/app/gstappsink.h>
+}
+
+
+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();
+
+private:
+   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;
+};

Source/Video/IVideo.h

@@ -0,0 +1,20 @@
+/* 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>
+#include <string>
+
+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;
+};

Source/Video/VideoFactory.cpp

@@ -0,0 +1,33 @@
+/* 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"
+
+bool VideoFactory::Enabled = true;
+int VideoFactory::NumLoops = 0;
+
+IVideo *VideoFactory::CreateVideo()
+{
+   IVideo *instance = NULL;
+
+   if(Enabled)
+   {
+      instance = new GStreamerVideo();
+      instance->Initialize();
+      ((GStreamerVideo *)(instance))->SetNumLoops(NumLoops);
+   }
+
+   return instance;
+}
+
+void VideoFactory::SetEnabled(bool enabled)
+{
+   Enabled = enabled;
+}
+
+void VideoFactory::SetNumLoops(int numLoops)
+{
+   NumLoops = numLoops;
+}

Source/Video/VideoFactory.h

@@ -0,0 +1,18 @@
+/* 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;
+
+class VideoFactory
+{
+public:
+   IVideo *CreateVideo();
+   static void SetEnabled(bool enabled);
+   static void SetNumLoops(int numLoops);
+
+private:
+  static bool Enabled;
+  static int NumLoops;
+};