Port from git

2026-03-19 10:22:42 +01:00 · 2015-01-01 10:14:26 -06:00
commit 93094bcbed
772 changed files with 621608 additions and 0 deletions
--- a/Source/Graphics/Animate/Tween.cpp
+++ b/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);
+}
--- a/Source/Graphics/Animate/Tween.h
+++ b/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;
+};
--- a/Source/Graphics/Animate/TweenTypes.h
+++ b/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
+};
--- a/Source/Graphics/Component/Component.cpp
+++ b/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;
+}
--- a/Source/Graphics/Component/Component.h
+++ b/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;
+};
--- a/Source/Graphics/Component/Image.cpp
+++ b/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());
+   }
+}
--- a/Source/Graphics/Component/Image.h
+++ b/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;
+};
--- a/Source/Graphics/Component/ImageBuilder.cpp
+++ b/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;
+}
--- a/Source/Graphics/Component/ImageBuilder.h
+++ b/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);
+};
--- a/Source/Graphics/Component/ReloadableMedia.cpp
+++ b/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();
+   }
+}
--- a/Source/Graphics/Component/ReloadableMedia.h
+++ b/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;
+};
--- a/Source/Graphics/Component/ReloadableText.cpp
+++ b/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();
+   }
+}
--- a/Source/Graphics/Component/ReloadableText.h
+++ b/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;
+};
--- a/Source/Graphics/Component/ScrollingList.cpp
+++ b/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;
+      }
+   }
+}
+
--- a/Source/Graphics/Component/ScrollingList.h
+++ b/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;
+};
+
--- a/Source/Graphics/Component/Text.cpp
+++ b/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);
+      }
+   }
+}
+
--- a/Source/Graphics/Component/Text.h
+++ b/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;
+};
--- a/Source/Graphics/Component/VideoBuilder.cpp
+++ b/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;
+}
+
--- a/Source/Graphics/Component/VideoBuilder.h
+++ b/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;
+};
--- a/Source/Graphics/Component/VideoComponent.cpp
+++ b/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());
+   }
+}
--- a/Source/Graphics/Component/VideoComponent.h
+++ b/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;
+};
--- a/Source/Graphics/ComponentItemBinding.cpp
+++ b/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;
+}
--- a/Source/Graphics/ComponentItemBinding.h
+++ b/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;
+};
--- a/Source/Graphics/ComponentItemBindingBuilder.cpp
+++ b/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;
+}
--- a/Source/Graphics/ComponentItemBindingBuilder.h
+++ b/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);
+};
--- a/Source/Graphics/Font.cpp
+++ b/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();
+   }
+
+}
--- a/Source/Graphics/Font.h
+++ b/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;
+};
+
+
--- a/Source/Graphics/FontCache.cpp
+++ b/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;
+}
+
--- a/Source/Graphics/FontCache.h
+++ b/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;
+
+};
+
--- a/Source/Graphics/MenuNotifierInterface.h
+++ b/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;
+};
+
--- a/Source/Graphics/Page.cpp
+++ b/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();
+      }
+   }
+}
+
--- a/Source/Graphics/Page.h
+++ b/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;
+
+};
--- a/Source/Graphics/PageBuilder.cpp
+++ b/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());
+            }
+         }
+      }
+   }
+}
--- a/Source/Graphics/PageBuilder.h
+++ b/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);
+};
--- a/Source/Graphics/ViewInfo.cpp
+++ b/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;
+}
--- a/Source/Graphics/ViewInfo.h
+++ b/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;
+};