No OneTemporary
Actions

Size

235 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/gui/animation.cpp b/util/gui/animation.cpp
	index c6740b1d..e7d1fe3e 100644
	--- a/util/gui/animation.cpp
	+++ b/util/gui/animation.cpp
	@@ -1,1231 +1,1236 @@
	#include "animation.h"

	#include <stdio.h>
	#include <vector>
	#include <math.h>
	#include <sstream>
	#include "util/token.h"
	#include "util/trans-bitmap.h"
	#include "util/bitmap.h"
	#include "util/stretch-bitmap.h"
	#include "util/font.h"
	#include "globals.h"
	#include "util/gradient.h"
	#include "../debug.h"
	#include "../funcs.h"
	#include "../file-system.h"
	#include "../load_exception.h"

	using namespace std;
	using namespace Gui;

	// Temporary solution
	static void renderSprite(const Graphics::Bitmap & bmp, const int x, const int y, const int alpha, const bool hflip, const bool vflip, const Graphics::Bitmap & work){
	if (alpha != 255){
	Graphics::Bitmap::transBlender( 0, 0, 0, alpha );
	if (hflip && !vflip){
	bmp.translucent().drawHFlip(x,y, work);
	} else if (!hflip && vflip){
	bmp.translucent().drawVFlip(x,y, work);
	} else if (hflip && vflip){
	bmp.translucent().drawHVFlip(x,y, work);
	} else if (!hflip && !vflip){
	bmp.translucent().draw(x,y, work);
	}
	} else {
	if (hflip && !vflip){
	bmp.drawHFlip(x,y, work);
	} else if (!hflip && vflip){
	bmp.drawVFlip(x,y, work);
	} else if (hflip && vflip){
	bmp.drawHVFlip(x,y, work);
	} else if (!hflip && !vflip){
	bmp.draw(x,y, work);
	}
	}
	}

	Element::Element(const Token * token):
	time(50),
	alpha(255){
	if (token != NULL){
	TokenView view = token->view();
	while (view.hasMore()){
	try{
	const Token * tok;
	view >> tok;
	parseToken(tok);
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Gui::Animation::Element parse error");
	} catch ( const LoadException & ex ) {
	throw ex;
	}
	}
	}
	}

	Element::~Element(){
	}

	void Element::parseToken(const Token * token){
	if (*token == "alpha"){
	// get alpha
	token->view() >> alpha;
	} else if (*token == "offset"){
	// Get the offset location it defaults to 0,0
	double x=0, y=0;
	try {
	token->view() >> x >> y;
	} catch (const TokenException & ex){
	}
	offset.set(x,y);
	} else if (*token == "time"){
	// time to display
	token->view() >> time;
	} else {
	Global::debug( 3 ) << "Unhandled Gui::Animation::Element attribute: " << endl;
	if (Global::getDebug() >= 3){
	token->print(" ");
	}
	}
	}

	void Element::act(double xvel, double yvel){
	scrollOffset.moveBy(xvel, yvel);
	}

	ImageFrame::ImageFrame(const Token *the_token, ImageMap &images, const string & baseDir):
	Element(the_token),
	bmp(NULL),
	horizontalFlip(false),
	verticalFlip(false){
	/*
	if (*the_token != "frame"){
	throw LoadException(__FILE__, __LINE__, "Not an frame");
	}
	*/
	/* The usual setup of an animation frame is
	// use image -1 to not draw anything, it can be used to get a blinking effect
	(frame (image NUM) (alpha NUM) (offset x y) (hflip 0\|1) (vflip 0\|1) (time NUM))
	*/
	TokenView view = the_token->view();
	while (view.hasMore()){
	try{
	const Token * token;
	view >> token;
	parseToken(token, baseDir, images);
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Menu animation parse error");
	} catch ( const LoadException & ex ) {
	throw ex;
	}
	}
	}

	void ImageFrame::parseToken(const Token * token, const string & baseDir, ImageMap & images){
	if (*token == "image"){
	// get the number
	string maybeNumber;
	token->view() >> maybeNumber;
	if (Util::matchRegex("[0-9]+", maybeNumber)){
	int num;
	token->view() >> num;
	if (images.find(num) == images.end()){
	ostringstream out;
	out << "No image for index " << num;
	throw LoadException(__FILE__, __LINE__, out.str());
	}
	// now assign the bitmap
	bmp = images[num];
	} else {
	bmp = Util::ReferenceCount<Graphics::Bitmap>(new Graphics::Bitmap(Storage::instance().find(Filesystem::RelativePath(baseDir + "/" + maybeNumber)).path()));
	}
	} else if (*token == "hflip"){
	// horizontal flip
	token->view() >> horizontalFlip;
	} else if (*token == "vflip"){
	// horizontal flip
	token->view() >> verticalFlip;
	} else {
	Global::debug( 3 ) << "Unhandled Gui::Animation::ImageFrame attribute: "<<endl;
	if (Global::getDebug() >= 3){
	token->print(" ");
	}
	}
	}

	ImageFrame::ImageFrame(Util::ReferenceCount<Graphics::Bitmap> bmp):
	Element(NULL),
	bmp(bmp),
	horizontalFlip(false),
	verticalFlip(false){
	time = -1;
	}

	ImageFrame::~ImageFrame(){
	}

	static bool closeFloat(double a, double b){
	const double epsilon = 0.001;
	return fabs(a-b) < epsilon;
	}

	void ImageFrame::act(double xvel, double yvel){
	scrollOffset.moveBy(xvel, yvel);
	if (bmp != NULL){
	if (scrollOffset.getDistanceFromCenterX() >= bmp->getWidth()){
	scrollOffset.setX(0);
	} else if (scrollOffset.getDistanceFromCenterX() <= -(bmp->getWidth())){
	scrollOffset.setX(0);
	}
	if (scrollOffset.getDistanceFromCenterY() >= bmp->getHeight()){
	scrollOffset.setY(0);
	} else if (scrollOffset.getDistanceFromCenterY() <= -(bmp->getHeight())){
	scrollOffset.setY(0);
	}
	}
	}

	void ImageFrame::draw(const int xaxis, const int yaxis, const Graphics::Bitmap & work){
	if (!bmp){
	return;
	}

	if (!closeFloat(scrollOffset.getDistanceFromCenterX(), 0) \|\| !closeFloat(scrollOffset.getDistanceFromCenterY(), 0)){

	// Lets do some scrolling
	// Graphics::Bitmap temp = Graphics::Bitmap::temporaryBitmap(bmp->getWidth(), bmp->getHeight());
	//AnimationPoint loc;
	AbsolutePoint loc;
	if (scrollOffset.getRelativeX() < 0){
	loc.setX(scrollOffset.getDistanceFromCenterX() + bmp->getWidth());
	} else if (scrollOffset.getRelativeX() > 0){
	loc.setX(scrollOffset.getDistanceFromCenterX() - bmp->getWidth());
	}
	if (scrollOffset.getRelativeY() < 0){
	loc.setY(scrollOffset.getDistanceFromCenterY() + bmp->getHeight());
	} else if (scrollOffset.getRelativeY() > 0){
	loc.setY(scrollOffset.getDistanceFromCenterY() - bmp->getHeight());
	}

	/*
	bmp->Blit((int) scrollOffset.getDistanceFromCenterX(), (int) scrollOffset.getDistanceFromCenterY(), temp);
	bmp->Blit((int) scrollOffset.getDistanceFromCenterX(), (int) loc.getY(), temp);
	bmp->Blit((int) loc.getX(), (int) scrollOffset.getDistanceFromCenterY(), temp);
	bmp->Blit((int) loc.getX(), (int) loc.getY(), temp);

	renderSprite(temp, (int)(xaxis+offset.getDistanceFromCenterX()), (int)(yaxis+offset.getDistanceFromCenterY()), alpha, horizontalFlip, verticalFlip, work);
	*/

	double x = xaxis+offset.getDistanceFromCenterX();
	double y = yaxis+offset.getDistanceFromCenterY();

	renderSprite(*bmp,
	(int)(x + scrollOffset.getDistanceFromCenterX()),
	(int)(y + scrollOffset.getDistanceFromCenterY()),
	alpha, horizontalFlip, verticalFlip, work);

	renderSprite(*bmp,
	(int)(x + loc.getX()),
	(int)(y + scrollOffset.getDistanceFromCenterY()),
	alpha, horizontalFlip, verticalFlip, work);

	renderSprite(*bmp,
	(int)(x + scrollOffset.getDistanceFromCenterX()),
	(int)(y + loc.getY()),
	alpha, horizontalFlip, verticalFlip, work);

	renderSprite(*bmp,
	(int)(x + loc.getX()),
	(int)(y + loc.getY()),
	alpha, horizontalFlip, verticalFlip, work);


	} else {
	renderSprite(*bmp, (int)(xaxis+offset.getDistanceFromCenterX()), (int)(yaxis+offset.getDistanceFromCenterY()), alpha, horizontalFlip, verticalFlip, work);
	}
	}

	/* This is mainly called from select-list to draw the cells. I'm not sure
	* of the utility of stretching the bitmap to fit the cell dimensions. Most
	* likely the cell will contain an image and the image will be the same
	* size as the cell.
	*/
	void ImageFrame::draw(const Graphics::Bitmap & work){
	const Graphics::Bitmap & temp = Graphics::Bitmap::temporaryBitmap(bmp->getWidth(), bmp->getHeight());
	temp.clearToMask();
	renderSprite(*bmp, 0, 0, alpha, horizontalFlip, verticalFlip, temp);
	temp.drawStretched(work);

	/* FIXME: This should work, but it doesn't.. */
	/*
	Graphics::StretchedBitmap show(bmp->getWidth(), bmp->getHeight(), work);
	show.start();
	renderSprite(*bmp, 0, 0, alpha, horizontalFlip, verticalFlip, show);
	show.finish();
	*/
	}

	void ImageFrame::reset(){
	scrollOffset = RelativePoint();
	}

	void ImageFrame::setToEnd(const RelativePoint & end){
	scrollOffset = end;
	}

	static const char * FRAME_TEXT = "Offset: ( %f, %f)\nScroll Offset: ( %f, %f)\nTime: %d\nHorizontal Flip: %d\nVertical Flip: %d\nAlpha: %d\n\n";

	const std::string ImageFrame::getInfo(){
	char info[255];
	sprintf(info, FRAME_TEXT, offset.getRelativeX(), offset.getRelativeY(), scrollOffset.getRelativeX(), scrollOffset.getRelativeY(), time, horizontalFlip, verticalFlip, alpha);
	return std::string(info);
	}

	TextFrame::TextFrame(const Token *token):
	Element(token),
	fontWidth(20),
	fontHeight(20){
	TokenView view = token->view();
	while (view.hasMore()){
	try{
	const Token * token;
	view >> token;
	parseToken(token);
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Menu animation parse error");
	} catch ( const LoadException & ex ) {
	throw ex;
	}
	}
	}

	TextFrame::~TextFrame(){
	}

	void TextFrame::act(double xvel, double yvel){
	gradient.forward();
	Element::act(xvel, yvel);
	}

	static const Font & getFont(const string & font, int width, int height){
	if (font != ""){
	return Font::getFont(Filesystem::RelativePath(font), width, height);
	}

	return Font::getDefaultFont(width, height);
	}

	void TextFrame::draw(int xaxis, int yaxis, const Graphics::Bitmap & work){
	double x = xaxis + offset.getDistanceFromCenterX() + scrollOffset.getDistanceFromCenterX();
	double y = yaxis + offset.getDistanceFromCenterY() + scrollOffset.getDistanceFromCenterY();

	const Font & font = getFont(this->font, fontWidth, fontHeight);
	font.printf((int) x, (int) y, gradient.current(), work, "%s", 0, message.c_str());
	}

	void TextFrame::draw(const Graphics::Bitmap & work){
	/* Probably don't need this.. but implement it if you do! */
	}

	void TextFrame::reset(){
	scrollOffset = RelativePoint();
	}

	void TextFrame::setToEnd(const RelativePoint & point){
	scrollOffset = point;
	}

	const std::string TextFrame::getInfo(){
	return message;
	}

	void TextFrame::parseToken(const Token * token){
	if (*token == "message"){
	token->view() >> message;
	} else if (*token == "font"){
	TokenView view = token->view();
	view >> font;
	try{
	view >> fontWidth >> fontHeight;
	} catch (const TokenException & ignore){
	}
	if (fontWidth < 1){
	fontWidth = 1;
	}
	if (fontHeight < 1){
	fontHeight = 1;
	}
	} else if (*token == "color"){
	int red, green, blue;
	token->view() >> red >> green >> blue;
	gradient = Effects::Gradient(Graphics::makeColor(red, green, blue));
	} else if (*token == "gradient"){
	gradient = Effects::Gradient(token);
	}
	}

	Sequence::Sequence(){
	}

	Sequence::~Sequence(){
	}

	SequenceFrame::SequenceFrame(const Util::ReferenceCount<Element> & frame):
	frame(frame),
	ticks(0){
	}

	-void SequenceFrame::draw(int xaxis, int yaxis, const Graphics::Bitmap & work){
	+void SequenceFrame::draw(int xaxis, int yaxis, const Graphics::Bitmap & work) const {
	frame->draw(xaxis, yaxis, work);
	}

	Util::ReferenceCount<Element> SequenceFrame::getCurrentFrame() const {
	return frame;
	}

	int SequenceFrame::totalTicks() const {
	return frame->getTime();
	}

	void SequenceFrame::setToEnd(){
	ticks = frame->getTime();
	}

	bool SequenceFrame::forward(int tickCount, double velocityX, double velocityY){
	frame->act(tickCount * velocityX, tickCount * velocityY);
	ticks += tickCount;
	return ticks > frame->getTime();
	}

	bool SequenceFrame::reverse(int tickCount, double velocityX, double velocityY){
	frame->act(-tickCount * velocityX, -tickCount * velocityY);
	ticks -= tickCount;
	return ticks < 0;
	}

	void SequenceFrame::forwardFrame(){
	/* nop */
	}

	void SequenceFrame::backFrame(){
	/* nop */
	}

	void SequenceFrame::reset(){
	ticks = 0;
	frame->reset();
	}

	void SequenceFrame::resetTicks(){
	ticks = 0;
	}

	SequenceLoop::SequenceLoop(int loops):
	currentFrame(0),
	currentLoop(loops),
	loopTimes(loops){
	}

	Util::ReferenceCount<Element> SequenceLoop::getCurrentFrame() const {
	if (currentFrame < frames.size()){
	return frames[currentFrame]->getCurrentFrame();
	} else {
	/* Return the last frame */
	if (frames.size() > 0){
	return frames[frames.size() - 1]->getCurrentFrame();
	}
	}
	return Util::ReferenceCount<Element>(NULL);
	}

	Util::ReferenceCount<Sequence> SequenceLoop::getCurrentSequence() const {
	if (currentFrame < frames.size()){
	return frames[currentFrame];
	} else {
	/* Return the last frame */
	if (frames.size() > 0){
	return frames[frames.size() - 1];
	}
	}
	return Util::ReferenceCount<Sequence>(NULL);

	}

	-void SequenceLoop::draw(int xaxis, int yaxis, const Graphics::Bitmap & work){
	+void SequenceLoop::draw(int xaxis, int yaxis, const Graphics::Bitmap & work) const {
	Util::ReferenceCount<Sequence> current = getCurrentSequence();
	if (current != NULL){
	current->draw(xaxis, yaxis, work);
	}
	}

	void SequenceLoop::reset(){
	currentFrame = 0;
	currentLoop = loopTimes;
	for (vector<Util::ReferenceCount<Sequence> >::iterator it = frames.begin(); it != frames.end(); it++){
	Util::ReferenceCount<Sequence> & sequence = *it;
	sequence->reset();
	}
	}

	/* Does the same thing as reset except for calling resetTicks on children nodes */
	void SequenceLoop::resetTicks(){
	currentFrame = 0;
	currentLoop = loopTimes;
	for (vector<Util::ReferenceCount<Sequence> >::iterator it = frames.begin(); it != frames.end(); it++){
	Util::ReferenceCount<Sequence> & sequence = *it;
	sequence->resetTicks();
	}
	}

	/* Similar to resetTicks but doesn't reset the current frame or loop */
	void SequenceLoop::resetChildrenTicks(){
	for (vector<Util::ReferenceCount<Sequence> >::iterator it = frames.begin(); it != frames.end(); it++){
	Util::ReferenceCount<Sequence> & sequence = *it;
	sequence->resetTicks();
	}
	}

	void SequenceLoop::setToEnd(){
	/* FIXME */
	}

	void SequenceLoop::addSequence(const Util::ReferenceCount<Sequence> & sequence){
	frames.push_back(sequence);
	}

	static Util::ReferenceCount<Sequence> parseSequence(const Token * token, ImageMap & images, const string & baseDir){
	if (*token == "frame"){
	Util::ReferenceCount<Element> frame(new ImageFrame(token, images, baseDir));
	return Util::ReferenceCount<Sequence>(new SequenceFrame(frame));
	} else if (*token == "text"){
	Util::ReferenceCount<Element> frame(new TextFrame(token));
	return Util::ReferenceCount<Sequence>(new SequenceFrame(frame));
	} else if (*token == "loop"){
	int times;
	token->view() >> times;
	Util::ReferenceCount<SequenceLoop> loop(new SequenceLoop(times));
	loop->parse(token, images, baseDir);
	return loop.convert<Sequence>();
	} else if (*token == "all"){
	return Util::ReferenceCount<Sequence>(new SequenceAll(token, images, baseDir));
	} else if (*token == "random"){
	return Util::ReferenceCount<Sequence>(new SequenceRandom(token, images, baseDir));
	}

	return Util::ReferenceCount<Sequence>(NULL);
	}

	void SequenceLoop::parse(const Token * token, ImageMap & images, const string & baseDir){
	TokenView view = token->view();
	/* first ignore the number of times to loop */
	int ignore;
	view >> ignore;

	while (view.hasMore()){
	const Token * next;
	view >> next;
	Util::ReferenceCount<Sequence> sequence = parseSequence(next, images, baseDir);
	if (sequence != NULL){
	addSequence(sequence);
	}
	}
	}

	int SequenceLoop::totalTicks() const {
	int total = 0;
	for (vector<Util::ReferenceCount<Sequence> >::const_iterator it = frames.begin(); it != frames.end(); it++){
	const Util::ReferenceCount<Sequence> & sequence = *it;
	total += sequence->totalTicks();
	}
	return total * (1 + loopTimes);
	}

	bool SequenceLoop::forward(int tickCount, double velocityX, double velocityY){
	Util::ReferenceCount<Sequence> current = getCurrentSequence();
	if (current != NULL){
	if (current->forward(tickCount, velocityX, velocityY)){
	forwardFrame();
	}
	}

	return currentFrame == frames.size();
	}

	bool SequenceLoop::reverse(int tickCount, double velocityX, double velocityY){
	Util::ReferenceCount<Sequence> current = getCurrentSequence();
	if (current != NULL){
	if (current->reverse(tickCount, velocityX, velocityY)){
	backFrame();
	}
	}

	return currentFrame == frames.size();
	}

	void SequenceLoop::forwardFrame(){
	currentFrame += 1;

	/* do the loop */
	if (currentFrame == frames.size() && currentLoop > 0){
	currentLoop -= 1;
	currentFrame = 0;
	resetChildrenTicks();
	}
	}

	void SequenceLoop::backFrame(){
	currentFrame -= 1;

	/* do the loop */
	if (currentFrame <= 0 && currentLoop > 0){
	currentLoop -= 1;
	resetChildrenTicks();
	if (frames.size() > 0){
	currentFrame = frames.size() - 1;
	} else {
	currentFrame = 0;
	}
	}
	}

	SequenceAll::SequenceAll(const Token * token, ImageMap & images, const string & baseDir){
	TokenView view = token->view();
	while (view.hasMore()){
	const Token * next;
	view >> next;
	Util::ReferenceCount<Sequence> sequence = parseSequence(next, images, baseDir);
	if (sequence != NULL){
	addSequence(sequence);
	}
	}
	}

	Util::ReferenceCount<Element> SequenceAll::getCurrentFrame() const {
	return Util::ReferenceCount<Element>(NULL);
	}

	void SequenceAll::reset(){
	for (SequenceIterator it = sequences.begin(); it != sequences.end(); it++){
	Util::ReferenceCount<Sequence> & next = *it;
	next->reset();
	}
	}

	void SequenceAll::resetTicks(){
	for (SequenceIterator it = sequences.begin(); it != sequences.end(); it++){
	Util::ReferenceCount<Sequence> & next = *it;
	next->resetTicks();
	}
	}

	void SequenceAll::setToEnd(){
	for (SequenceIterator it = sequences.begin(); it != sequences.end(); it++){
	Util::ReferenceCount<Sequence> & next = *it;
	next->setToEnd();
	}
	}

	void SequenceAll::addSequence(const Util::ReferenceCount<Sequence> & sequence){
	sequences.push_back(sequence);
	}

	-void SequenceAll::draw(int xaxis, int yaxis, const Graphics::Bitmap & work){
	- for (SequenceIterator it = sequences.begin(); it != sequences.end(); it++){
	- Util::ReferenceCount<Sequence> & next = *it;
	+void SequenceAll::draw(int xaxis, int yaxis, const Graphics::Bitmap & work) const {
	+ for (SequenceConstIterator it = sequences.begin(); it != sequences.end(); it++){
	+ const Util::ReferenceCount<Sequence> & next = *it;
	next->draw(xaxis, yaxis, work);
	}
	}

	/* Maximum ticks of any sequence */
	int SequenceAll::totalTicks() const {
	int max = 0;
	for (SequenceConstIterator it = sequences.begin(); it != sequences.end(); it++){
	const Util::ReferenceCount<Sequence> & next = *it;
	int what = next->totalTicks();
	if (what > max){
	max = what;
	}
	}
	return max;
	}

	bool SequenceAll::forward(int tickCount, double velocityX, double velocityY){
	bool go = false;
	for (SequenceIterator it = sequences.begin(); it != sequences.end(); it++){
	Util::ReferenceCount<Sequence> & next = *it;
	go = next->forward(tickCount, velocityX, velocityY) && go;
	}
	return go;
	}

	bool SequenceAll::reverse(int tickCount, double velocityX, double velocityY){
	bool go = false;
	for (SequenceIterator it = sequences.begin(); it != sequences.end(); it++){
	Util::ReferenceCount<Sequence> & next = *it;
	go = next->reverse(tickCount, velocityX, velocityY) && go;
	}
	return go;
	}

	void SequenceAll::forwardFrame(){
	for (SequenceIterator it = sequences.begin(); it != sequences.end(); it++){
	Util::ReferenceCount<Sequence> & next = *it;
	next->forwardFrame();
	}
	}

	void SequenceAll::backFrame(){
	for (SequenceIterator it = sequences.begin(); it != sequences.end(); it++){
	Util::ReferenceCount<Sequence> & next = *it;
	next->backFrame();
	}
	}

	SequenceRandom::SequenceRandom(const Token * token, ImageMap & images, const std::string & baseDir):
	current(0){
	TokenView view = token->view();
	while (view.hasMore()){
	const Token * next;
	view >> next;
	Util::ReferenceCount<Sequence> sequence = parseSequence(next, images, baseDir);
	if (sequence != NULL){
	addSequence(sequence);
	}
	}

	current = Util::rnd(sequences.size());
	}

	Util::ReferenceCount<Element> SequenceRandom::getCurrentFrame() const {
	return Util::ReferenceCount<Element>(NULL);
	}

	void SequenceRandom::reset(){
	current = Util::rnd(sequences.size());
	for (SequenceIterator it = sequences.begin(); it != sequences.end(); it++){
	Util::ReferenceCount<Sequence> & next = *it;
	next->reset();
	}
	}

	void SequenceRandom::resetTicks(){
	current = Util::rnd(sequences.size());
	for (SequenceIterator it = sequences.begin(); it != sequences.end(); it++){
	Util::ReferenceCount<Sequence> & next = *it;
	next->resetTicks();
	}
	}

	void SequenceRandom::setToEnd(){
	for (SequenceIterator it = sequences.begin(); it != sequences.end(); it++){
	Util::ReferenceCount<Sequence> & next = *it;
	next->setToEnd();
	}
	}

	void SequenceRandom::addSequence(const Util::ReferenceCount<Sequence> & sequence){
	sequences.push_back(sequence);
	}

	-void SequenceRandom::draw(int xaxis, int yaxis, const Graphics::Bitmap & work){
	+void SequenceRandom::draw(int xaxis, int yaxis, const Graphics::Bitmap & work) const {
	if (current < sequences.size()){
	Util::ReferenceCount<Sequence> now = sequences[current];
	now->draw(xaxis, yaxis, work);
	}
	}

	int SequenceRandom::totalTicks() const {
	int max = 0;
	for (SequenceConstIterator it = sequences.begin(); it != sequences.end(); it++){
	const Util::ReferenceCount<Sequence> & next = *it;
	int what = next->totalTicks();
	if (what > max){
	max = what;
	}
	}
	return max;
	}

	bool SequenceRandom::forward(int tickCount, double velocityX, double velocityY){
	if (current < sequences.size()){
	Util::ReferenceCount<Sequence> now = sequences[current];
	return now->forward(tickCount, velocityX, velocityY);
	}
	return true;
	}

	bool SequenceRandom::reverse(int tickCount, double velocityX, double velocityY){
	if (current < sequences.size()){
	Util::ReferenceCount<Sequence> now = sequences[current];
	return now->reverse(tickCount, velocityX, velocityY);
	}
	return true;
	}

	void SequenceRandom::forwardFrame(){
	if (current < sequences.size()){
	sequences[current]->forwardFrame();
	}
	}

	void SequenceRandom::backFrame(){
	if (current < sequences.size()){
	sequences[current]->backFrame();
	}
	}

	static int CURRENT_ID = 0;

	static int getNextId(){
	return CURRENT_ID++;
	}

	Animation::Animation(const Token *the_token):
	id(getNextId()),
	depth(BackgroundBottom),
	allowReset(true),
	sequence(0){
	/* Whats this for? */
	images[-1] = 0;

	std::string basedir = ".";
	if ( the_token != "anim" && the_token != "animation" ){
	throw LoadException(__FILE__, __LINE__, "Not an animation");
	}
	/* The usual setup of an animation is
	The images must be listed prior to listing any frames, basedir can be used to set the directory where the images are located
	loop will begin at the subsequent frame listed after loop
	axis is the location in which the drawing must be placed
	location old - used to render in background or foreground (0 == background [default]\| 1 == foreground)
	depth - used to render in background or foreground space (depth background bottom\|middle\|top) \| (depth foreground bottom\|midle\|top)
	reset - used to allow resetting of animation (0 == no \| 1 == yes [default])
	velocity - used to get a wrapping scroll effect while animating
	window - area in which the item will be contained
	(anim (id NUM)
	(location NUM)
	(scale NUM) ;; optional
	(depth background\|foreground NUM)
	(basedir LOCATION)
	(image NUM FILE [SCALE])
	(velocity x y)
	(axis x y)
	(frame "Read comments above in constructor")
	(loop 2)
	(reset NUM)
	(window x1 y1 x2 y2))
	*/
	double scale = 1.0;
	bool scaleSet = false;
	const Token & tok = *the_token;
	TokenView view = tok.view();
	while (view.hasMore()){
	try{
	const Token * token;
	view >> token;
	if (*token == "id"){
	// get the id
	token->view() >> id;
	} else if (*token == "location"){
	// translate location to depth
	/*int location = 0;
	token->view() >> location;
	if (location == 0){
	depth = BackgroundBottom;
	} else if (location == 1){
	depth = ForegroundBottom;
	}*/
	Global::debug(0) << "The option (" << token->getLineage() << ") in the file '" << token->getFileName() << "' is no longer valid and will be ignored. Consider using 'depth' instead." << std::endl;
	} else if (*token == "scale"){
	token->view() >> scale;
	scaleSet = true;
	} else if (*token == "depth"){
	// get the depth
	std::string name, level;
	token->view() >> name >> level;
	if (name == "background"){
	if (level == "bottom"){
	depth = BackgroundBottom;
	} else if (level == "middle"){
	depth = BackgroundMiddle;
	} else if (level == "top"){
	depth = BackgroundTop;
	}
	} else if (name == "foreground"){
	if (level == "bottom"){
	depth = ForegroundBottom;
	} else if (level == "middle"){
	depth = ForegroundMiddle;
	} else if (level == "top"){
	depth = ForegroundTop;
	}
	}
	} else if (*token == "basedir"){
	// set the base directory for loading images
	token->view() >> basedir;
	} else if (*token == "image"){
	// add bitmaps by number to the map
	int number;
	std::string temp;
	double localScale = 1;
	bool localScaleSet = false;
	TokenView view = token->view();
	view >> number >> temp;
	try{
	view >> localScale;
	localScaleSet = true;
	} catch (const TokenException & fail){
	}
	Util::ReferenceCount<Graphics::Bitmap> bmp(new Graphics::Bitmap(*Storage::instance().open(Storage::instance().find(Filesystem::RelativePath(basedir + "/" + temp)))));
	if (!bmp->getError()){
	if (scaleSet \|\| localScaleSet){
	if (localScaleSet){
	*bmp = bmp->scaleBy(localScale, localScale);
	} else {
	*bmp = bmp->scaleBy(scale, scale);
	}
	}
	images[number] = bmp;
	}
	} else if (*token == "axis"){
	// Get the axis location it defaults to 0,0
	double x=0, y=0;
	try {
	token->view() >> x >> y;
	} catch (const TokenException & ex){
	}
	axis.set(x,y);
	} else if (*token == "window"){
	// Windowed area where to clip if necessary otherwise it defaults to max
	double x1=0,x2=0, y1=0,y2=0;
	try {
	token->view() >> x1 >> y1 >> x2 >> y2;
	} catch (const TokenException & ex){
	}
	window.set(x1,y1,x2,y2);
	} else if (*token == "velocity"){
	// This allows the animation to get a wrapping scroll action going on
	double x=0, y=0;
	try {
	token->view() >> x >> y;
	} catch (const TokenException & ex){
	}
	velocity.set(x,y);
	} else if (*token == "frame"){
	Util::ReferenceCount<Element> frame(new ImageFrame(token, images, basedir));
	sequence.addSequence(Util::ReferenceCount<Sequence>(new SequenceFrame(frame)));
	} else if (*token == "text"){
	Util::ReferenceCount<Element> frame(new TextFrame(token));
	sequence.addSequence(Util::ReferenceCount<Sequence>(new SequenceFrame(frame)));
	} else if (*token == "all"){
	sequence.addSequence(Util::ReferenceCount<Sequence>(new SequenceAll(token, images, basedir)));
	} else if (*token == "random"){
	sequence.addSequence(Util::ReferenceCount<Sequence>(new SequenceRandom(token, images, basedir)));
	} else if (*token == "loop"){
	// start loop here
	int times;
	token->view() >> times;
	Util::ReferenceCount<SequenceLoop> loop(new SequenceLoop(times));
	loop->parse(token, images, basedir);
	sequence.addSequence(loop.convert<Sequence>());

	/*
	if (l >= (int)frames.size()){
	ostringstream out;
	out << "Loop location is larger than the number of frames. Loop: " << loop << " Frames: " << frames.size();
	throw LoadException(__FILE__, __LINE__, out.str());
	}
	*/
	} else if (*token == "reset"){
	// Allow reset of animation
	token->view() >> allowReset;
	} else {
	Global::debug( 3 ) << "Unhandled menu attribute: "<<endl;
	if (Global::getDebug() >= 3){
	token->print(" ");
	}
	}
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Menu animation parse error");
	} catch ( const LoadException & ex ) {
	throw ex;
	}
	}
	}

	Animation::Animation(const std::string & background):
	id(getNextId()),
	depth(BackgroundBottom),
	allowReset(true),
	sequence(0){
	// add bitmap
	Util::ReferenceCount<Graphics::Bitmap> bmp(new Graphics::Bitmap(*Storage::instance().open(Storage::instance().find(Filesystem::RelativePath(background)))));
	if (bmp->getError()){
	throw LoadException(__FILE__,__LINE__, "Problem loading file: " + background);
	} else {
	images[0] = bmp;
	}
	Util::ReferenceCount<Element> frame(new ImageFrame(bmp));
	sequence.addSequence(Util::ReferenceCount<Sequence>(new SequenceFrame(frame)));
	}

	Animation::Animation(const Filesystem::AbsolutePath & path):
	id(getNextId()),
	depth(BackgroundBottom),
	allowReset(true),
	sequence(0){
	// add bitmap
	Util::ReferenceCount<Graphics::Bitmap> bmp(new Graphics::Bitmap(*Storage::instance().open(path)));
	if (bmp->getError()){
	throw LoadException(__FILE__,__LINE__, "Problem loading file: " + path.path());
	} else {
	images[0] = bmp;
	}
	Util::ReferenceCount<Element> frame(new ImageFrame(bmp));
	sequence.addSequence(Util::ReferenceCount<Sequence>(new SequenceFrame(frame)));
	}

	Animation::Animation(Util::ReferenceCount<Graphics::Bitmap> image):
	id(getNextId()),
	depth(BackgroundBottom),
	allowReset(true),
	sequence(0){
	images[0] = image;
	Util::ReferenceCount<Element> frame(new ImageFrame(image));
	sequence.addSequence(Util::ReferenceCount<Sequence>(new SequenceFrame(frame)));
	}

	Animation::~Animation(){
	}

	int Animation::totalTicks() const {
	return sequence.totalTicks();
	}

	void Animation::forward(int tickCount){
	sequence.forward(tickCount, velocity.getRelativeX(), velocity.getRelativeY());
	}

	void Animation::reverse(int tickCount){
	sequence.reverse(tickCount, velocity.getRelativeX(), velocity.getRelativeY());
	}

	void Animation::act(){
	forward();
	}

	-void Animation::draw(const Graphics::Bitmap & work){
	+void Animation::draw(const Graphics::Bitmap & work) const {
	/* FIXME: should use sub-bitmaps here */
	/*const int x = window.getX();
	const int y = window.getY();
	const int width = window.getWidth();
	const int height = window.getHeight();
	Global::debug(0) << "Distance x2: " << width << " Distance y2: " << height << std::endl;
	Graphics::Bitmap clipped(work, x, y, height, width);
	frames[currentFrame]->draw(0, 0,clipped);*/
	// Set clip from the axis default is 0,0,bitmap width, bitmap height
	work.setClipRect(-window.getPosition().getDistanceFromCenterX(),
	-window.getPosition().getDistanceFromCenterY(),
	work.getWidth() - window.getPosition2().getDistanceFromCenterX(),
	work.getHeight() - window.getPosition2().getDistanceFromCenterY());

	sequence.draw(axis.getDistanceFromCenterX(), axis.getDistanceFromCenterY(), work);

	work.setClipRect(0, 0, work.getWidth(), work.getHeight());
	}

	-void Animation::draw(int x, int y, int width, int height, const Graphics::Bitmap & work){
	+void Animation::draw(int x, int y, int width, int height, const Graphics::Bitmap & work) const {
	const Util::ReferenceCount<Element> & frame = sequence.getCurrentFrame();
	if (frame != NULL){
	Graphics::Bitmap clipped(work, x, y, width, height);
	frame->draw(clipped);
	}
	}

	void Animation::forwardFrame(){
	sequence.forwardFrame();
	}

	void Animation::backFrame(){
	sequence.backFrame();
	}

	void Animation::reset(){
	sequence.reset();
	}

	void Animation::resetAll(){
	sequence.reset();
	}

	void Animation::setToEnd(){
	/* FIXME */
	sequence.setToEnd();
	// currentFrame = frames.size()-1;
	// currentLoop = 0;
	// Set offsets
	/*
	for (std::vector<Util::ReferenceCount<Element> >::iterator i = frames.begin(); i != frames.end(); ++i){
	Util::ReferenceCount<Element> frame = *i;
	frame->setToEnd(RelativePoint(ticks * velocity.getRelativeX(), ticks * velocity.getRelativeY()));
	}
	*/
	}

	const std::string Animation::getInfo(){
	/*
	static const char * ANIMATION_TEXT = "Animation ID: %d\nTicks: %d\nFrame Index: %d\nLoop From: %d\nAxis: ( %f, %f)\nVelocity: ( %f, %f)\n";
	char info[255];
	sprintf(info, ANIMATION_TEXT, id, ticks, currentFrame, loop, axis.getRelativeX(), axis.getRelativeY(), velocity.getRelativeX(), velocity.getRelativeY());
	return std::string(info) + frames[currentFrame]->getInfo();
	*/
	/* FIXME */
	ostringstream out;
	out << "Animation ID: " << id;
	return out.str();
	}

	AnimationManager::AnimationManager(){
	// Set the current id to 0 for each context
	CURRENT_ID = 0;
	}

	AnimationManager::AnimationManager(const AnimationManager & copy):
	animations(copy.animations){
	// Set the current id to 0 for each context
	CURRENT_ID = 0;
	}

	AnimationManager::~AnimationManager(){
	}

	const AnimationManager & AnimationManager::operator=(const AnimationManager & copy){
	animations = copy.animations;
	return *this;
	}


	void AnimationManager::forward(int tickCount){
	for (std::map<Gui::Animation::Depth, std::vector<Util::ReferenceCount<Gui::Animation> > >::iterator i = animations.begin(); i != animations.end(); ++i){
	std::vector<Util::ReferenceCount<Gui::Animation> > & animations = i->second;
	for (std::vector<Util::ReferenceCount<Gui::Animation> >::iterator j = animations.begin(); j != animations.end(); ++j){
	Util::ReferenceCount<Gui::Animation> animation = *j;
	if (animation != NULL){
	animation->forward(tickCount);
	}
	}
	}
	}

	void AnimationManager::reverse(int tickCount){
	for (std::map<Gui::Animation::Depth, std::vector<Util::ReferenceCount<Gui::Animation> > >::iterator i = animations.begin(); i != animations.end(); ++i){
	std::vector<Util::ReferenceCount<Gui::Animation> > & animations = i->second;
	for (std::vector<Util::ReferenceCount<Gui::Animation> >::iterator j = animations.begin(); j != animations.end(); ++j){
	Util::ReferenceCount<Gui::Animation> animation = *j;
	if (animation != NULL){
	animation->reverse(tickCount);
	}
	}
	}
	}

	void AnimationManager::act(){
	forward();
	}

	-void AnimationManager::render(const Gui::Animation::Depth & depth, const Graphics::Bitmap & work){
	- for (std::vector<Util::ReferenceCount<Gui::Animation> >::iterator i = animations[depth].begin(); i != animations[depth].end(); ++i){
	- Util::ReferenceCount<Gui::Animation> animation = *i;
	- if (animation != NULL){
	- animation->draw(work);
	- }
	+void AnimationManager::render(const Gui::Animation::Depth & depth, const Graphics::Bitmap & work) const {
	+ std::map< Gui::Animation::Depth, std::vector< Util::ReferenceCount<Gui::Animation> > >::const_iterator animation = animations.find(depth);
	+
	+ if (animation != animations.end()){
	+ const vector<Util::ReferenceCount<Gui::Animation> > & all = animation->second;
	+ for (std::vector<Util::ReferenceCount<Gui::Animation> >::const_iterator i = all.begin(); i != all.end(); ++i){
	+ Util::ReferenceCount<Gui::Animation> animation = *i;
	+ if (animation != NULL){
	+ animation->draw(work);
	+ }
	+ }
	}
	}

	void AnimationManager::add(Util::ReferenceCount<Gui::Animation > animation){
	animations[animation->getDepth()].push_back(animation);
	}

	void AnimationManager::reset(){
	for (std::map<Gui::Animation::Depth, std::vector<Util::ReferenceCount<Gui::Animation> > >::iterator i = animations.begin(); i != animations.end(); ++i){
	std::vector<Util::ReferenceCount<Gui::Animation> > & animations = i->second;
	for (std::vector<Util::ReferenceCount<Gui::Animation> >::iterator j = animations.begin(); j != animations.end(); ++j){
	Util::ReferenceCount<Gui::Animation> animation = *j;
	if (animation != NULL){
	animation->resetAll();
	}
	}
	}
	}

	int AnimationManager::totalTicks() const {
	int count = 0;
	for (map<Gui::Animation::Depth, vector<Util::ReferenceCount<Gui::Animation> > >::const_iterator it = animations.begin(); it != animations.end(); it++){
	Gui::Animation::Depth depth = it->first;
	const vector<Util::ReferenceCount<Gui::Animation> > & stuff = it->second;
	int next = countTicks(stuff);
	/* If any animation takes infinite time then the whole thing takes infinite time */
	if (next == -1){
	return -1;
	}
	if (next > count){
	count = next;
	}
	}
	return count;
	}

	int AnimationManager::countTicks(const vector<Util::ReferenceCount<Animation> > & toCount) const {
	int total = 0;
	for (vector<Util::ReferenceCount<Animation> >::const_iterator it = toCount.begin(); it != toCount.end(); it++){
	const Util::ReferenceCount<Animation> & animation = *it;
	int ticks = animation->totalTicks();
	if (ticks == -1){
	return ticks;
	}
	total += ticks;
	}
	return total;
	}

	void AnimationManager::setToEnd(){
	for (std::map<Gui::Animation::Depth, std::vector<Util::ReferenceCount<Gui::Animation> > >::iterator i = animations.begin(); i != animations.end(); ++i){
	std::vector<Util::ReferenceCount<Gui::Animation> > & animations = i->second;
	for (std::vector<Util::ReferenceCount<Gui::Animation> >::iterator j = animations.begin(); j != animations.end(); ++j){
	Util::ReferenceCount<Gui::Animation> animation = *j;
	if (animation != NULL){
	animation->setToEnd();
	}
	}
	}
	}

	const std::string AnimationManager::getInfo(int id, bool all){
	std::string info("");
	for (std::map<Gui::Animation::Depth, std::vector<Util::ReferenceCount<Gui::Animation> > >::iterator i = animations.begin(); i != animations.end(); ++i){
	std::vector<Util::ReferenceCount<Gui::Animation> > & animations = i->second;
	for (std::vector<Util::ReferenceCount<Gui::Animation> >::iterator j = animations.begin(); j != animations.end(); ++j){
	Util::ReferenceCount<Gui::Animation> animation = *j;
	if (animation != NULL){
	if (id == animation->getID() \|\| all){
	info += animation->getInfo();
	}
	}
	}
	}
	return info;
	}

	const std::vector<int> AnimationManager::getIdList(){
	std::vector<int> list;
	for (std::map<Gui::Animation::Depth, std::vector<Util::ReferenceCount<Gui::Animation> > >::iterator i = animations.begin(); i != animations.end(); ++i){
	std::vector<Util::ReferenceCount<Gui::Animation> > & animations = i->second;
	for (std::vector<Util::ReferenceCount<Gui::Animation> >::iterator j = animations.begin(); j != animations.end(); ++j){
	Util::ReferenceCount<Gui::Animation> animation = *j;
	if (animation != NULL){
	list.push_back(animation->getID());
	}
	}
	}
	return list;
	}
	diff --git a/util/gui/animation.h b/util/gui/animation.h
	index bee4a26b..d306c4fe 100644
	--- a/util/gui/animation.h
	+++ b/util/gui/animation.h
	@@ -1,373 +1,373 @@
	#ifndef _paintown_gui_animation_h
	#define _paintown_gui_animation_h

	#include <vector>
	#include <map>
	#include <string>

	#include "coordinate.h"
	#include "util/pointer.h"
	#include "util/gradient.h"

	class Filesystem;
	namespace Path{
	class AbsolutePath;
	}
	typedef Path::AbsolutePath AbsolutePath;

	namespace Graphics{
	class Bitmap;
	}

	class Token;

	namespace Gui{

	// To hold images by number easier to access and reuse
	typedef std::map<int, Util::ReferenceCount<Graphics::Bitmap> > ImageMap;

	/! Base Element class for frame types /
	class Element{
	public:
	virtual ~Element();
	virtual void act(double xvel, double yvel);
	virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &) = 0;
	virtual void draw(const Graphics::Bitmap &) = 0;
	virtual void reset() = 0;
	virtual void setToEnd(const RelativePoint &) = 0;
	virtual const std::string getInfo() = 0;

	virtual inline const RelativePoint getOffset() const {
	return this->offset;
	}

	virtual inline const RelativePoint getScrollOffset() const {
	return this->offset;
	}

	virtual inline int getTime() const {
	return this->time;
	}

	virtual inline int getAlpha() const {
	return this->alpha;
	}
	protected:
	Element(const Token *);
	RelativePoint offset;
	RelativePoint scrollOffset;
	int time;
	int alpha;
	private:
	void parseToken(const Token *);
	};

	/! Image Frame /
	class ImageFrame : public Element{
	public:
	ImageFrame(const Token *, ImageMap &, const std::string &);
	ImageFrame(Util::ReferenceCount<Graphics::Bitmap> bmp);
	virtual ~ImageFrame();
	virtual void act(double xvel, double yvel);
	virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &);
	virtual void draw(const Graphics::Bitmap &);
	virtual void reset();
	virtual void setToEnd(const RelativePoint &);
	virtual const std::string getInfo();
	virtual inline const Util::ReferenceCount<Graphics::Bitmap> & getBitmap() const {
	return this->bmp;
	}
	protected:
	virtual void parseToken(const Token *, const std::string &, ImageMap &);

	protected:
	Util::ReferenceCount<Graphics::Bitmap> bmp;
	bool horizontalFlip;
	bool verticalFlip;
	};

	/! Text Frame /
	class TextFrame: public Element {
	public:
	TextFrame(const Token *);
	virtual ~TextFrame();

	virtual void act(double xvel, double yvel);
	virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &);
	virtual void draw(const Graphics::Bitmap &);
	virtual void reset();
	virtual void setToEnd(const RelativePoint &);
	virtual const std::string getInfo();
	protected:
	virtual void parseToken(const Token *);

	/* FIXME: default this to Globals::DEFAULT_FONT */
	std::string font;
	std::string message;
	int fontWidth, fontHeight;
	Effects::Gradient gradient;
	};

	/* Iterates over a series of items */
	class Sequence{
	public:
	Sequence();

	virtual Util::ReferenceCount<Element> getCurrentFrame() const = 0;
	virtual int totalTicks() const = 0;
	virtual void setToEnd() = 0;

	/* Move the sequence along by the number of ticks and at the specified speed
	* Returns true if the sequence can't move any farther.
	*/
	virtual bool forward(int tickCount, double velocityX, double velocityY) = 0;
	virtual bool reverse(int tickCount, double velocityX, double velocityY) = 0;

	- virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &) = 0;
	+ virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &) const = 0;

	virtual void reset() = 0;
	virtual void resetTicks() = 0;

	/* Forcifully move to the next/previous frame */
	virtual void forwardFrame() = 0;
	virtual void backFrame() = 0;

	virtual ~Sequence();
	};

	class SequenceFrame: public Sequence {
	public:
	SequenceFrame(const Util::ReferenceCount<Element> & frame);
	virtual Util::ReferenceCount<Element> getCurrentFrame() const;

	virtual int totalTicks() const;
	virtual void reset();
	virtual void resetTicks();
	virtual void setToEnd();

	- virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &);
	+ virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &) const;

	/* Move the sequence along by the number of ticks and at the specified speed */
	virtual bool forward(int tickCount, double velocityX, double velocityY);
	virtual bool reverse(int tickCount, double velocityX, double velocityY);

	/* Forcifully move to the next/previous frame */
	virtual void forwardFrame();
	virtual void backFrame();

	protected:
	Util::ReferenceCount<Element> frame;
	int ticks;
	};

	/* Shows sequences in a loop */
	class SequenceLoop: public Sequence {
	public:
	SequenceLoop(int loops);

	virtual Util::ReferenceCount<Element> getCurrentFrame() const;

	virtual void reset();
	virtual void resetTicks();
	virtual void setToEnd();
	virtual void addSequence(const Util::ReferenceCount<Sequence> & sequence);
	virtual void parse(const Token * token, ImageMap & map, const std::string & baseDir);

	- virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &);
	+ virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &) const;

	virtual int totalTicks() const;

	/* Move the sequence along by the number of ticks and at the specified speed */
	virtual bool forward(int tickCount, double velocityX, double velocityY);
	virtual bool reverse(int tickCount, double velocityX, double velocityY);

	/* Forcifully move to the next/previous frame */
	virtual void forwardFrame();
	virtual void backFrame();

	protected:
	void resetChildrenTicks();
	virtual Util::ReferenceCount<Sequence> getCurrentSequence() const;

	/* The current frame to display */
	unsigned int currentFrame;

	/* The number of times left to loop */
	unsigned int currentLoop;

	/* The total number of times to loop */
	const unsigned int loopTimes;

	std::vector<Util::ReferenceCount<Sequence> > frames;
	};

	/* Shows all sequences simaltaneously */
	class SequenceAll: public Sequence {
	public:
	SequenceAll(const Token * token, ImageMap & images, const std::string & baseDir);

	virtual Util::ReferenceCount<Element> getCurrentFrame() const;

	virtual void reset();
	virtual void resetTicks();
	virtual void setToEnd();
	virtual void addSequence(const Util::ReferenceCount<Sequence> & sequence);

	- virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &);
	+ virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &) const;

	virtual int totalTicks() const;

	/* Move the sequence along by the number of ticks and at the specified speed */
	virtual bool forward(int tickCount, double velocityX, double velocityY);
	virtual bool reverse(int tickCount, double velocityX, double velocityY);

	/* Forcifully move to the next/previous frame */
	virtual void forwardFrame();
	virtual void backFrame();

	protected:
	std::vector<Util::ReferenceCount<Sequence> > sequences;
	typedef std::vector<Util::ReferenceCount<Sequence> >::iterator SequenceIterator;
	typedef std::vector<Util::ReferenceCount<Sequence> >::const_iterator SequenceConstIterator;
	};

	/* Displays a random child node for its duration */
	class SequenceRandom: public Sequence {
	public:
	SequenceRandom(const Token * token, ImageMap & images, const std::string & baseDir);

	virtual Util::ReferenceCount<Element> getCurrentFrame() const;

	virtual void reset();
	virtual void resetTicks();
	virtual void setToEnd();
	virtual void addSequence(const Util::ReferenceCount<Sequence> & sequence);

	- virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &);
	+ virtual void draw(int xaxis, int yaxis, const Graphics::Bitmap &) const;

	virtual int totalTicks() const;

	/* Move the sequence along by the number of ticks and at the specified speed */
	virtual bool forward(int tickCount, double velocityX, double velocityY);
	virtual bool reverse(int tickCount, double velocityX, double velocityY);

	/* Forcifully move to the next/previous frame */
	virtual void forwardFrame();
	virtual void backFrame();

	protected:
	unsigned int current;
	std::vector<Util::ReferenceCount<Sequence> > sequences;
	typedef std::vector<Util::ReferenceCount<Sequence> >::iterator SequenceIterator;
	typedef std::vector<Util::ReferenceCount<Sequence> >::const_iterator SequenceConstIterator;
	};

	class Animation{
	public:
	Animation(const Token *token);
	/! Load only a single bitmap (for backwards compatibility of backgrounds in menu) /
	Animation(const std::string &);
	Animation(const AbsolutePath &);
	/! use an existing bitmap /
	Animation(Util::ReferenceCount<Graphics::Bitmap> image);
	virtual ~Animation();
	/! Reverse with ticks /
	virtual void reverse(int tickCount = 1);
	/! Forward with ticks /
	virtual void forward(int tickCount = 1);
	/! Logic ticking per iteration and moving to subsequent frames /
	virtual void act();
	/! Draw /
	- virtual void draw(const Graphics::Bitmap &);
	- virtual void draw(int x, int y, int width, int height, const Graphics::Bitmap &);
	+ virtual void draw(const Graphics::Bitmap &) const;
	+ virtual void draw(int x, int y, int width, int height, const Graphics::Bitmap &) const;
	/! Forward to next frame with no regard to ticks /
	virtual void forwardFrame();
	/! Back a frame with no regard to ticks /
	virtual void backFrame();
	/! Reset everything to the beginning of the start of the animation /
	virtual void resetAll();
	/! Set everything to the end of the animation /
	virtual void setToEnd();
	/! Get printable information regarding current frame /
	virtual const std::string getInfo();

	/! Reset only frame ticks and other things are ignored /
	virtual void reset();

	/* Total number of ticks used by this animation. If any frames have a time
	* of -1 then the total time will also be -1, meaning infinity.
	*/
	virtual int totalTicks() const;

	/! Return ID /
	virtual inline int getID() const {
	return id;
	}
	/*! Depth of animation
	TODO make depth unlimited and just use integers for weight of depth
	*/
	enum Depth {
	BackgroundBottom,
	BackgroundMiddle,
	BackgroundTop,
	ForegroundBottom,
	ForegroundMiddle,
	ForegroundTop,
	};
	/! Get depth /
	inline const Depth & getDepth() const {
	return this->depth;
	}

	private:
	int id;
	Depth depth;
	unsigned int currentSequence;
	bool allowReset;
	RelativePoint axis;
	// This allows the frames to scroll in place
	RelativePoint velocity;
	Coordinate window;
	// std::vector<Util::ReferenceCount<Frame> > frames;
	SequenceLoop sequence;
	ImageMap images;
	};

	/! Generalized to for re-use in other contexts (menu, cutscene, characterselect, etc) /
	class AnimationManager{
	public:
	AnimationManager();
	AnimationManager(const AnimationManager &);
	virtual ~AnimationManager();

	const AnimationManager & operator=(const AnimationManager &);

	void forward(int tickCount = 1);
	void reverse(int tickCount = 1);
	void act();
	- void render(const Gui::Animation::Depth &, const Graphics::Bitmap &);
	+ void render(const Gui::Animation::Depth &, const Graphics::Bitmap &) const;

	void add(Util::ReferenceCount<Gui::Animation > animation);

	void reset();
	void setToEnd();

	int totalTicks() const;

	const std::string getInfo(int id, bool all = false);

	const std::vector<int> getIdList();

	virtual inline const bool empty() const{
	return this->animations.empty();
	}

	protected:
	int countTicks(const std::vector<Util::ReferenceCount<Gui::Animation> > & toCount) const;

	private:
	std::map< Gui::Animation::Depth, std::vector< Util::ReferenceCount<Gui::Animation> > > animations;
	};

	}
	#endif
	diff --git a/util/gui/coordinate.cpp b/util/gui/coordinate.cpp
	index 0eea3085..d20c8193 100644
	--- a/util/gui/coordinate.cpp
	+++ b/util/gui/coordinate.cpp
	@@ -1,535 +1,535 @@
	#include "util/bitmap.h"
	#include "coordinate.h"
	#include "globals.h"
	#include "util/funcs.h"
	#include "util/load_exception.h"
	#include <sstream>
	#include <math.h>

	using namespace Gui;

	namespace Gui{
	namespace Space{

	static double translate(double x, double amount){
	return x + amount;
	}

	static double scale(double x, double amount){
	return x * amount;
	}

	/* convert a point in a space with the given width to a new space with the given width
	* 1. translate relative original origin
	* 2. scale it to the range -1, 1
	* 3. scale it to the new width
	* 4. translate relative to the new origin
	*/
	static double convertSpace(double original, double originalMinimum, double originalWidth, double newMinimum, double newWidth){
	return translate(scale(scale(translate(original, -originalMinimum),
	1.0 / originalWidth),
	newWidth),
	newMinimum);
	}

	/* hard coded for now */
	static double physicalWidth = 640;
	static double physicalHeight = 480;

	Point::Point(double x, double y, const Space & space):
	x(x),
	y(y),
	space(space){
	}

	Point::Point(const Point & point, const Space & space):
	space(space){
	x = space.getLocalX(point.physicalX());
	y = space.getLocalY(point.physicalY());
	}

	Point::Point(const Point & point):
	x(point.x),
	y(point.y),
	space(point.space){
	}

	static bool close(double a, double b){
	return fabs(a - b) < 0.0001;
	}

	bool Point::operator==(const Point & him) const {
	if (this == &him){
	return true;
	}

	return close(physicalX(), him.physicalX()) &&
	close(physicalY(), him.physicalY());
	}

	bool Point::operator!=(const Point & him) const {
	return !(*this == him);
	}

	Point & Point::operator=(const Point & point){
	if (*this == point){
	this->x = point.x;
	this->y = point.y;
	} else {
	this->x = space.getLocalX(point.physicalX());
	this->y = space.getLocalY(point.physicalY());
	}
	return *this;
	}

	Point & Point::operator+=(const Point & point){
	this = this + point;
	return *this;
	}

	Point Point::operator+(const Point & point){
	if (sameSpace(point)){
	x = space.boundX(x + point.x);
	y = space.boundY(y + point.y);
	return *this;
	} else {
	return *this + Point(point, space);
	}
	}

	bool Point::sameSpace(const Point & point) const {
	return space == point.space;
	}

	double Point::physicalX() const {
	return convertSpace(x, space.getMinimumX(), space.sizeX(), 0, physicalWidth);
	}

	double Point::physicalY() const {
	return convertSpace(y, space.getMinimumY(), space.sizeY(), 0, physicalHeight);
	}

	Space::Space(double minX, double minY, double maxX, double maxY):
	minX(minX),
	minY(minY),
	maxX(maxX),
	maxY(maxY){
	}

	bool Space::operator==(const Space & space) const {
	if (this == &space){
	return true;
	}

	return minX == space.minX &&
	minY == space.minY &&
	maxX == space.maxX &&
	maxY == space.maxY;
	}

	Point Space::fromPhysical(int x, int y){
	return Point(getLocalX(x), getLocalY(y), *this);
	}

	Point Space::fromLocal(double x, double y){
	return Point(boundX(x), boundY(y), *this);
	}

	double Space::sizeX() const {
	return maxX - minX;
	}

	double Space::sizeY() const {
	return maxY - minY;
	}

	double Space::boundX(double x) const {
	return Util::clamp(x, minX, maxX);
	}

	double Space::boundY(double y) const {
	return Util::clamp(y, minY, maxY);
	}

	double Space::centerX() const {
	return (maxX - minX) / 2;
	}

	double Space::centerY() const {
	return (maxY - minY) / 2;
	}

	double Space::getLocalX(double physicalX) const {
	return convertSpace(physicalX, 0, physicalWidth, minX, sizeX());
	}

	double Space::getLocalY(double physicalY) const {
	return convertSpace(physicalY, 0, physicalHeight, minY, sizeY());
	}

	double Space::getMinimumX() const {
	return minX;
	}

	double Space::getMinimumY() const {
	return minY;
	}

	}
	}

	static int relativeToAbsolute(double x, int center){
	return (int)(center + (center * x));
	}

	static int amountFromCenterX(int x){
	return x - (640 / 2);
	}

	static int amountFromCenterY(int y){
	return y - (480 / 2);
	}

	/* scale an absolute distance to a relative distance
	* distance / absolute = X / relative
	* absolute space = 0 to 640
	* relative space = -1 to 1
	* X = distance * relative / absolute
	*/
	static double scaleAbsoluteToRelativeDistanceX(int distance){
	return distance * (1.0 - (-1.0)) / (640.0 - 0);
	}

	static double scaleAbsoluteToRelativeDistanceY(int distance){
	return distance * (1.0 - (-1.0)) / (480.0 - 0);
	}

	/* convert a point in absolute space to relative space */
	static double absoluteToRelative(int x, int center){
	return (double)(x-center)/center;
	}

	static double relativeToAbsoluteX(double x){
	// return relativeToAbsolute(x, Global::getScreenWidth() / 2);
	return relativeToAbsolute(x, 640 / 2);
	}

	static double relativeToAbsoluteY(double y){
	// return relativeToAbsolute(y, Global::getScreenHeight() / 2);
	return relativeToAbsolute(y, 480 / 2);
	}

	static double absoluteToRelativeX(int x){
	return absoluteToRelative(x, 640/2);
	}

	static double absoluteToRelativeY(int y){
	return absoluteToRelative(y, 480/2);
	}

	AbsolutePoint::AbsolutePoint():
	x(0),
	y(0){
	}
	AbsolutePoint::AbsolutePoint(int x, int y):
	x(x),
	y(y){
	}
	AbsolutePoint::AbsolutePoint(const AbsolutePoint & copy):
	x(copy.x),
	y(copy.y){
	}
	AbsolutePoint::~AbsolutePoint(){
	}

	const AbsolutePoint & AbsolutePoint::operator=(const AbsolutePoint & copy){
	this->x = copy.x;
	this->y = copy.y;
	return *this;
	}

	int AbsolutePoint::getX() const {
	return x;
	}

	int AbsolutePoint::getY() const {
	return y;
	}

	RelativePoint::RelativePoint():
	x(0),
	y(0){
	}

	RelativePoint::RelativePoint(double x, double y):
	x(x),
	y(y){
	}

	RelativePoint::RelativePoint(const RelativePoint & copy):
	x(copy.x),
	y(copy.y){
	}

	RelativePoint::RelativePoint(const AbsolutePoint & point):
	x(absoluteToRelativeX(point.getX())),
	y(absoluteToRelativeY(point.getY())){
	}

	RelativePoint::~RelativePoint(){
	}

	const RelativePoint & RelativePoint::operator=(const RelativePoint & copy){
	this->x = copy.x;
	this->y = copy.y;
	return *this;
	}
	const RelativePoint & RelativePoint::operator=(const AbsolutePoint & point){
	this->x = absoluteToRelativeX(point.getX());
	this->y = absoluteToRelativeY(point.getY());
	return *this;
	}
	bool RelativePoint::operator==(const RelativePoint & point){
	return (this->x == point.x && this->y == point.y);
	}
	bool RelativePoint::operator!=(const RelativePoint & point){
	return !(*this == point);
	}

	int RelativePoint::getX() const{
	return relativeToAbsoluteX(x);
	}

	int RelativePoint::getY() const{
	return relativeToAbsoluteY(y);
	}

	-int RelativePoint::getDistanceFromCenterX(){
	+int RelativePoint::getDistanceFromCenterX() const {
	return amountFromCenterX(getX());
	}

	-int RelativePoint::getDistanceFromCenterY(){
	+int RelativePoint::getDistanceFromCenterY() const {
	return amountFromCenterY(getY());
	}

	void RelativePoint::moveX(double percent){
	x += percent;
	}

	void RelativePoint::moveY(double percent){
	y += percent;
	}

	void RelativePoint::moveBy(double x, double y){
	moveX(x);
	moveY(y);
	}

	AbsolutePoint RelativePoint::getAbsolute(){
	return AbsolutePoint(relativeToAbsoluteX(x), relativeToAbsoluteY(y));
	}

	double RelativePoint::getRelativeX() const{
	return x;
	}

	double RelativePoint::getRelativeY() const{
	return y;
	}

	Coordinate::Coordinate():
	z(0){
	}

	Coordinate::Coordinate(AbsolutePoint & position, AbsolutePoint & position2):
	position(position),
	position2(position2),
	z(0){
	}

	Coordinate::Coordinate(const RelativePoint & position, const RelativePoint & position2):
	position(position),
	position2(position2),
	z(0){
	}

	Coordinate::Coordinate(const Coordinate & copy):
	position(copy.position),
	position2(copy.position2),
	z(copy.z){
	}

	Coordinate::~Coordinate(){
	}

	const Coordinate & Coordinate::operator=(const Coordinate & copy){
	this->position = copy.position;
	this->position2 = copy.position2;
	this->z = copy.z;

	return *this;
	}

	int Coordinate::getX() const{
	return position.getX();
	}
	int Coordinate::getY() const{
	return position.getY();
	}

	int Coordinate::getWidth() const {
	return position2.getX() - position.getX();
	}

	int Coordinate::getHeight() const {
	return position2.getY() - position.getY();
	}

	int Coordinate::getX2() const{
	return position2.getX();
	}
	int Coordinate::getY2() const{
	return position2.getY();
	}

	void Coordinate::growHorizontal(double by){
	position.moveX(-(by));
	position2.moveX(by);
	}

	void Coordinate::growHorizontalAbsolute(int distance){
	growHorizontal(scaleAbsoluteToRelativeDistanceX(distance));
	}

	void Coordinate::growVerticalAbsolute(int distance){
	growVertical(scaleAbsoluteToRelativeDistanceY(distance));
	}

	void Coordinate::growVertical(double by){
	position.moveY(-(by));
	position2.moveY(by);
	}

	void Coordinate::growTo(const Coordinate & coord, double percent){
	if (position.getRelativeX() > coord.position.getRelativeX()){
	position.moveX(-(percent));
	if (position.getRelativeX() < coord.position.getRelativeX()){
	position.setX(coord.position.getRelativeX());
	}
	} else if (position.getRelativeX() < coord.position.getRelativeX()){
	position.moveX(percent);
	if (position.getRelativeX() > coord.position.getRelativeX()){
	position.setX(coord.position.getRelativeX());
	}
	}
	if (position.getRelativeY() > coord.position.getRelativeY()){
	position.moveY(-(percent));
	if (position.getRelativeY() < coord.position.getRelativeY()){
	position.setY(coord.position.getRelativeY());
	}
	} else if (position.getRelativeY() < coord.position.getRelativeY()){
	position.moveY(percent);
	if (position.getRelativeY() > coord.position.getRelativeY()){
	position.setY(coord.position.getRelativeY());
	}
	}
	if (position2.getRelativeX() > coord.position2.getRelativeX()){
	position2.moveX(-(percent));
	if (position2.getRelativeX() < coord.position2.getRelativeX()){
	position2.setX(coord.position2.getRelativeX());
	}
	} else if (position2.getRelativeX() < coord.position2.getRelativeX()){
	position2.moveX(percent);
	if (position2.getRelativeX() > coord.position2.getRelativeX()){
	position2.setX(coord.position2.getRelativeX());
	}
	}
	if (position2.getRelativeY() > coord.position2.getRelativeY()){
	position2.moveY(-(percent));
	if (position2.getRelativeY() < coord.position2.getRelativeY()){
	position2.setY(coord.position2.getRelativeY());
	}
	} else if (position2.getRelativeY() < coord.position2.getRelativeY()){
	position2.moveY(percent);
	if (position2.getRelativeY() > coord.position2.getRelativeY()){
	position2.setY(coord.position2.getRelativeY());
	}
	}
	}

	void Coordinate::center(const Coordinate & coord){
	const double centerx = (coord.getRelativeX1() + coord.getRelativeX2())/2;
	const double centery = (coord.getRelativeY1() + coord.getRelativeY2())/2;

	set(centerx, centery, centerx, centery);
	}

	void Coordinate::moveBy(double x, double y){
	position.moveBy(x, y);
	position2.moveBy(x, y);
	}

	bool Coordinate::operator==( const Coordinate & coord){
	return ( (position == coord.position) &&
	(position2 == coord.position2));
	}

	bool Coordinate::operator!=( const Coordinate & coord){
	return ( !(position == coord.position) \|\|
	!(position2 == coord.position2));
	}

	bool Coordinate::operator==( const Graphics::Bitmap & bmp){
	return ( (getWidth() == bmp.getWidth()) &&
	(getHeight() == bmp.getHeight()));
	}

	bool Coordinate::operator!=( const Graphics::Bitmap & bmp){
	return !(*this == bmp);
	}

	void Coordinate::setPosition(const RelativePoint & point){
	position = point;
	}

	void Coordinate::setPosition(const AbsolutePoint & point){
	position = RelativePoint(point);
	}

	void Coordinate::setPosition2(const RelativePoint & point){
	position2 = point;
	}

	void Coordinate::setPosition2(const AbsolutePoint & point){
	position2 = RelativePoint(point);
	}

	void Coordinate::moveTo(const AbsolutePoint & where){
	double dx = position2.getRelativeX() - position.getRelativeX();
	double dy = position2.getRelativeY() - position.getRelativeY();
	setPosition(where);

	/* sort of ugly, use operator+ for RelativePosition */
	setPosition2(RelativePoint(position.getRelativeX() + dx, position.getRelativeY() + dy));
	}

	void Coordinate::checkDimensions(){
	if (getWidth() < 0 \|\| getHeight() < 0){
	std::ostringstream out;
	out << "Cannot have a negative coordinate dimension " << getWidth() << ", " << getHeight();
	throw LoadException(__FILE__, __LINE__, out.str());
	}
	}

	void Coordinate::setDimensions(int width, int height){
	position2 = RelativePoint(AbsolutePoint(getX() + width, getY() + height));
	}

	void Coordinate::setCenterPosition(const RelativePoint & center){
	int width = getWidth();
	int height = getHeight();
	this->position = center;
	this->position2 = center;
	growHorizontalAbsolute(width / 2.0);
	growVerticalAbsolute(height / 2.0);
	}
	diff --git a/util/gui/coordinate.h b/util/gui/coordinate.h
	index 5f4dcbfa..034e6ff2 100644
	--- a/util/gui/coordinate.h
	+++ b/util/gui/coordinate.h
	@@ -1,236 +1,236 @@
	#ifndef _paintown_gui_coordinate_h
	#define _paintown_gui_coordinate_h

	namespace Graphics{
	class Bitmap;
	}

	namespace Gui {

	namespace Space{

	class Space;
	/* a 2-d point */
	class Point{
	public:
	Point(double x, double y, const Space & space);
	Point(const Point & point, const Space & space);
	Point(const Point & point);

	Point operator+(const Point &);
	Point & operator+=(const Point &);
	Point & operator=(const Point &);
	bool operator==(const Point &) const;
	bool operator!=(const Point &) const;

	/* convert to physical space */
	double physicalX() const;
	double physicalY() const;

	double x;
	double y;
	const Space & space;
	private:
	/* true if points use the same space system */
	bool sameSpace(const Point & point) const;
	};

	/* mapping from coordinate space to physical space */
	class Space{
	public:
	Space(double minX, double minY, double maxX, double maxY);
	Point fromPhysical(int x, int y);
	Point fromLocal(double x, double y);

	bool operator==(const Space & space) const;

	/* clamp the values to the size of the space */
	double boundX(double x) const;
	double boundY(double y) const;

	double getMinimumX() const;
	double getMinimumY() const;

	double sizeX() const;
	double sizeY() const;
	double centerX() const;
	double centerY() const;
	double getLocalX(double physicalX) const;
	double getLocalY(double physicalY) const;
	private:
	double minX, minY, maxX, maxY;
	};

	}

	/* Coordinate system for handling scalable graphics */

	class AbsolutePoint {
	public:
	AbsolutePoint();
	explicit AbsolutePoint(int x, int y);
	AbsolutePoint(const AbsolutePoint &);
	virtual ~AbsolutePoint();

	const AbsolutePoint & operator=(const AbsolutePoint &);
	virtual inline void setX(int x){
	this->x = x;
	}
	virtual int getX() const;
	virtual inline void setY(int y){
	this->y = y;
	}
	virtual int getY() const;
	private:
	int x;
	int y;
	};

	class RelativePoint {
	public:
	RelativePoint();
	explicit RelativePoint(double x, double y);
	RelativePoint(const RelativePoint &);
	RelativePoint(const AbsolutePoint &);
	virtual ~RelativePoint();

	const RelativePoint & operator=(const RelativePoint &);
	const RelativePoint & operator=(const AbsolutePoint &);
	bool operator==(const RelativePoint &);
	bool operator!=(const RelativePoint &);
	virtual inline void setX(double x){
	this->x = x;
	}
	virtual int getX() const;
	virtual inline void setY(double y){
	this->y = y;
	}
	virtual int getY() const;
	virtual inline void set(double x, double y){
	this->x = x;
	this->y = y;
	}
	- virtual int getDistanceFromCenterX();
	- virtual int getDistanceFromCenterY();
	+ virtual int getDistanceFromCenterX() const;
	+ virtual int getDistanceFromCenterY() const;
	virtual void moveX(double percent);
	virtual void moveY(double percent);
	virtual void moveBy(double x, double y);
	virtual AbsolutePoint getAbsolute();
	virtual double getRelativeX() const;
	virtual double getRelativeY() const;
	private:
	double x;
	double y;
	};

	class Coordinate {
	public:
	Coordinate();
	Coordinate(AbsolutePoint &, AbsolutePoint &);
	Coordinate(const RelativePoint &, const RelativePoint &);
	Coordinate(const Coordinate &);
	virtual ~Coordinate();

	const Coordinate & operator=(const Coordinate &);

	virtual inline void setZ(double z){
	this->z = z;
	}
	virtual inline double getZ() const{
	return this->z;
	}

	virtual int getX() const;
	virtual int getY() const;
	virtual int getWidth() const;
	virtual int getHeight() const;
	virtual int getX2() const;
	virtual int getY2() const;
	/* give a relative quantity */
	virtual void growHorizontal(double by);
	/* give an absolute quantity */
	virtual void growHorizontalAbsolute(int by);
	/* give a relative quantity */
	virtual void growVertical(double by);
	/* give an absolute quantity */
	virtual void growVerticalAbsolute(int by);

	virtual void growTo(const Coordinate &, double percent = 0.005);
	virtual void center(const Coordinate &);
	virtual void moveBy(double x, double y);
	virtual inline double getRelativeX1() const{
	return this->position.getRelativeX();
	}
	virtual inline double getRelativeX2() const{
	return this->position2.getRelativeX();
	}
	virtual inline double getRelativeY1() const{
	return this->position.getRelativeY();
	}
	virtual inline double getRelativeY2() const{
	return this->position2.getRelativeY();
	}

	virtual inline void set(double x1, double y1, double x2, double y2){
	this->position.setX(x1);
	this->position.setY(y1);
	this->position2.setX(x2);
	this->position2.setY(y2);
	}

	virtual inline void setX1(double x){
	this->position.setX(x);
	}
	virtual inline void setX2(double x){
	this->position2.setX(x);
	}
	virtual inline void setY1(double y){
	this->position.setY(y);
	}
	virtual inline void setY2(double y){
	this->position2.setY(y);
	}

	bool operator==( const Coordinate &);
	bool operator!=( const Coordinate &);
	bool operator==( const Graphics::Bitmap &);
	bool operator!=( const Graphics::Bitmap &);

	/* moves the positions so that `center' is in the middle but the
	* width/height is maintained
	*/
	virtual void setCenterPosition(const RelativePoint & center);

	virtual void setPosition(const RelativePoint &);
	virtual void setPosition(const AbsolutePoint &);
	virtual void setPosition2(const RelativePoint &);
	virtual void setPosition2(const AbsolutePoint &);

	virtual void moveTo(const AbsolutePoint &);

	virtual void setDimensions(int width, int height);

	- virtual inline RelativePoint & getPosition(){
	+ virtual inline const RelativePoint & getPosition() const {
	return this->position;
	}

	- virtual inline RelativePoint & getPosition2(){
	+ virtual inline const RelativePoint & getPosition2() const {
	return this->position2;
	}

	virtual inline bool empty(){
	return (getWidth() == 0 && getHeight() == 0);
	}

	private:
	void checkDimensions();

	RelativePoint position;
	RelativePoint position2;
	double z;
	};

	}


	#endif
	diff --git a/util/menu/menu.cpp b/util/menu/menu.cpp
	index 006715ac..703c0614 100644
	--- a/util/menu/menu.cpp
	+++ b/util/menu/menu.cpp
	@@ -1,1826 +1,1834 @@
	#include "util/bitmap.h"
	#include "util/trans-bitmap.h"
	#include "util/stretch-bitmap.h"
	#include "menu.h"
	#include "menu_option.h"
	#include "util/funcs.h"
	#include "util/sound.h"
	#include "util/font.h"
	#include "util/token.h"
	#include "util/events.h"
	#include "util/tokenreader.h"
	#include "util/file-system.h"
	#include "util/resource.h"
	#include "globals.h"
	#include "util/debug.h"
	#include "util/init.h"
	#include "configuration.h"
	#include "util/music.h"
	#include "util/gradient.h"
	#include "util/exceptions/shutdown_exception.h"
	#include "util/exceptions/exception.h"

	#include "optionfactory.h"
	#include "actionfactory.h"

	#include "util/input/input-manager.h"
	#include "util/input/input-map.h"
	#include "util/input/input-source.h"
	#include "util/parameter.h"

	#include <queue>
	#include <map>
	#include <ostream>
	#include <sstream>

	#include "util/gui/context-box.h"

	using namespace std;
	using namespace Gui;

	/* the current font is a property of the dynamic execution. so it will
	* be modified by various functions that call Parameter::push
	*/
	static const Font & currentFont(){
	return Menu::menuFontParameter.current()->get();
	}

	Util::Parameter<Util::ReferenceCount<Menu::FontInfo> > Menu::menuFontParameter;

	static std::string sharedFont = "fonts/arial.ttf";
	static int sharedFontWidth = 24;
	static int sharedFontHeight = 24;

	Effects::Gradient Menu::standardGradient(){
	return Gui::standardGradient(50);
	}

	Menu::Point::Point():
	x(0),
	y(0){
	}

	Menu::Point::Point(int x, int y):
	x(x),
	y(y){
	}

	Menu::Point::~Point(){
	}

	Menu::InfoBox::InfoBox():
	state(NotActive),
	fadeAlpha(0){
	popup.setFadeSpeed(20);
	}

	Menu::InfoBox::~InfoBox(){
	}

	void Menu::InfoBox::act(const Font & font){
	popup.act(font);

	int speed = 9;
	switch (state){
	case Opening: {
	if (fadeAlpha < 255){
	fadeAlpha += speed;
	}

	if (fadeAlpha >= 255){
	fadeAlpha = 255;
	if (popup.isActive()){
	state = Active;
	}
	}
	break;
	}
	case Closing: {
	if (fadeAlpha > 0){
	fadeAlpha -= speed;
	}

	if (fadeAlpha <= 0){
	fadeAlpha = 0;
	if (!popup.isActive()){
	state = NotActive;
	}
	}
	break;
	}
	case Active:
	case NotActive:
	default:
	break;
	}
	}

	void Menu::InfoBox::render(const Graphics::Bitmap &){
	throw MenuException(__FILE__, __LINE__, "Don't call the render(Bitmap) function");
	}

	void Menu::InfoBox::render(const Graphics::Bitmap & bmp, const Font & vFont){
	popup.render(bmp);

	// const Font & vFont = Configuration::getMenuFont()->get(*font);

	const int x1 = popup.getArea().getX()+(int)(popup.getTransforms().getRadius()/2);
	const int y1 = popup.getArea().getY()+2;
	const int x2 = popup.getArea().getX2()-(int)(popup.getTransforms().getRadius()/2);
	const int y2 = popup.getArea().getY2()-2;
	bmp.setClipRect(x1, y1, x2, y2);

	// FIXME height is proportionally wrong in a majority of the cases, this is perhaps due to ftalleg.
	int sy = location.getY() - vFont.getHeight()/6;// - location.getHeight()/2 - vFont.getHeight()/2;
	static Graphics::Color white = Graphics::makeColor(255,255,255);
	unsigned int padding_index = 0;
	for (vector<string>::iterator it = text.begin(); it != text.end(); it++){
	string & str = *it;
	if (fadeAlpha < 255){
	Graphics::Bitmap::transBlender(0, 0, 0, fadeAlpha);
	vFont.printf(location.getX() + padding[padding_index]/2, sy, white, bmp.translucent(), str, 0 );
	} else {
	vFont.printf(location.getX() + padding[padding_index]/2, sy, white, bmp, str, 0 );
	}
	sy += vFont.getHeight();
	padding_index++;
	}
	bmp.setClipRect(0, 0, bmp.getWidth(), bmp.getHeight());
	}

	void Menu::InfoBox::open(){
	state = Opening;
	popup.location = location;
	popup.transforms = transforms;
	popup.colors = colors;
	popup.open();
	fadeAlpha = 0;
	}

	void Menu::InfoBox::close(){
	state = Closing;
	popup.close();
	}

	/* dimensions are computed lazily when we get a font, but only compute once per font */
	void Menu::InfoBox::initialize(const Font & font){
	int maxWidth = 0;
	int height = 0;
	for (vector<string>::iterator it = text.begin(); it != text.end(); it++){
	// Add the padding
	ostringstream pad;
	pad << (it)[0] << (it)[(*it).size()-1];
	padding.push_back(font.textLength(pad.str().c_str()));
	int w = font.textLength((*it).c_str()) + padding.back();
	if (w > maxWidth){
	maxWidth = w;
	}
	height += font.getHeight();
	}

	location.setDimensions(maxWidth, height);
	}

	void Menu::InfoBox::setText(const std::string & info){
	if (info.empty()){
	return;
	}
	text.clear();
	// const Font & vFont = Configuration::getMenuFont()->get(*font);
	size_t start = 0;
	size_t last = 0;
	start = info.find("\n");
	while (start != string::npos){
	text.push_back(info.substr(last, start - last));
	last = start + 1;
	start = info.find("\n", last);
	}
	text.push_back(info.substr(last));

	}

	static std::vector<Util::ReferenceCount<ContextItem> > toContextList(const ContextBox & context, const std::vector<Util::ReferenceCount<MenuOption> > & list){
	std::vector<Util::ReferenceCount<ContextItem> > contextItems;
	for (std::vector<Util::ReferenceCount<MenuOption> >::const_iterator i = list.begin(); i != list.end(); ++i){
	const Util::ReferenceCount<MenuOption> & option = *i;
	contextItems.push_back(option.convert<ContextItem>());
	}
	return contextItems;
	}

	static void tryPlaySound(const Filesystem::RelativePath & path){
	Sound * ok = Resource::getSound(path);
	if (ok != NULL){
	ok->play();
	}
	}
	/*
	* FIXME Exception handling for ValueHolder*/
	Menu::MenuException::MenuException(const std::string & file, int line, const std::string reason ):
	Exception::Base(file, line),
	reason(reason){
	}
	Menu::MenuException::MenuException(const MenuException & copy):
	Exception::Base(copy),
	reason(copy.reason){
	}
	Menu::MenuException::MenuException(const Exception::Base & copy):
	Exception::Base(copy),
	reason("unknown"){
	}
	Menu::MenuException::~MenuException() throw(){
	}
	Exception::Base * Menu::MenuException::copy() const {
	return new MenuException(*this);
	}

	Menu::Reload::Reload(const std::string & file, int line, const std::string reason):
	MenuException(file, line, reason){
	}

	Menu::Reload::~Reload() throw() {
	}

	Exception::Base * Menu::Reload::copy() const {
	return new Reload(*this);
	}

	Menu::ValueHolder::ValueHolder(const std::string & name):
	name(name),
	location(0){
	}

	Menu::ValueHolder::~ValueHolder(){
	}

	Menu::ValueHolder::ValueHolder(const ValueHolder & copy){
	// reset position
	this->location = 0;
	this->name = copy.name;
	this->values = copy.values;
	}

	Menu::ValueHolder & Menu::ValueHolder::operator=(const ValueHolder & copy){
	// reset position
	this->location = 0;
	this->name = copy.name;
	this->values = copy.values;
	return *this;
	}

	Menu::ValueHolder & Menu::ValueHolder::operator<<(const std::string & val){
	values.push_back(val);
	return *this;
	}
	Menu::ValueHolder & Menu::ValueHolder::operator<<(bool val){
	std::ostringstream o;
	o << val;
	return *this << o.str();
	}
	Menu::ValueHolder & Menu::ValueHolder::operator<<(int val){
	std::ostringstream o;
	o << val;
	return *this << o.str();
	}
	Menu::ValueHolder & Menu::ValueHolder::operator<<(double val){
	std::ostringstream o;
	o << val;
	return *this << o.str();
	}

	Menu::ValueHolder & Menu::ValueHolder::operator<<(TokenView & view){
	std::string temp;
	view >> temp;
	return *this << temp;
	}

	Menu::ValueHolder & Menu::ValueHolder::operator>>(std::string & val){
	if (values[location].empty()){
	throw MenuException(__FILE__, __LINE__, "Empty value.");
	}
	val = values[location];
	next();
	return *this;
	}
	Menu::ValueHolder & Menu::ValueHolder::operator>>(bool & val){
	if (values[location].empty()){
	throw MenuException(__FILE__, __LINE__, "Empty value.");
	}
	std::istringstream i(values[location]);
	i >> val;
	next();
	return *this;
	}
	Menu::ValueHolder & Menu::ValueHolder::operator>>(int & val){
	if (values[location].empty()){
	throw MenuException(__FILE__, __LINE__, "Empty value.");
	}
	std::istringstream i(values[location]);
	i >> val;
	next();
	return *this;
	}
	Menu::ValueHolder & Menu::ValueHolder::operator>>(double & val){
	if (values[location].empty()){
	throw MenuException(__FILE__, __LINE__, "Empty value.");
	}
	std::istringstream i(values[location]);
	i >> val;
	next();
	return *this;
	}

	void Menu::ValueHolder::next(){
	location++;
	if (location >= values.size()){
	location = 0;
	}
	}

	const std::string Menu::ValueHolder::getValues() {
	std::string temp;
	for (std::vector<std::string>::iterator i = values.begin(); i != values.end(); ++i){
	temp += *i + "; ";
	}
	return temp;
	}

	static bool parseDisplayList(const Token * token, ContextBox & menu){
	if (*token == "display-list"){
	TokenView view = token->view();
	while (view.hasMore()){
	const Token * tok;
	view >> tok;
	std::string type;
	bool wrap = true;
	if (tok->match("type", type)){
	if (type == "normal"){
	menu.setListType(ContextBox::Normal);
	} else if (type == "scroll"){
	menu.setListType(ContextBox::Scroll);
	}
	} else if (tok->match("wrap", wrap)){
	menu.setListWrap(wrap);
	} else if ( *tok == "items"){
	Gui::ListValues values;
	values.getValues(tok);
	menu.setListValues(values);
	}
	}
	return true;
	}
	return false;
	}

	Menu::Renderer::Renderer(){
	}

	Menu::Renderer::~Renderer(){
	// Kill info boxes
	for (std::vector< ::Menu::InfoBox *>::iterator i = info.begin(); i != info.end();++i){
	if (*i){
	delete *i;
	}
	}
	}

	/*
	void Menu::Renderer::setFont(const Util::ReferenceCount<FontInfo> & font){
	}
	*/

	void Menu::Renderer::addInfo(const std::string & text, const Gui::Widget & defaults, Context & context, const Font & font){
	if (!info.empty()){
	info.back()->close();
	}
	if (text.empty()){
	return;
	}
	::Menu::InfoBox * temp = new ::Menu::InfoBox();
	// temp->setFont(context.getFont());
	temp->setText(text);
	temp->initialize(font);
	const int width = temp->location.getWidth();
	const int height = temp->location.getHeight();
	temp->location.setPosition(Gui::AbsolutePoint(context.getInfoLocation().getX() - width/2, context.getInfoLocation().getY() - height/2));
	// have to pass the dimensions back in to correct proper placement
	temp->location.setPosition2(Gui::AbsolutePoint(temp->location.getX() + width,temp->location.getY() + height));
	temp->transforms.setRadius(defaults.transforms.getRadius());
	temp->colors = defaults.colors;
	temp->open();
	info.push_back(temp);
	}

	void Menu::Renderer::actInfo(const Font & font){
	for (std::vector< ::Menu::InfoBox *>::iterator i = info.begin(); i != info.end();){
	::Menu::InfoBox box = i;
	box->act(font);
	if (!box->isActive()){
	delete box;
	i = info.erase(i);
	} else {
	i++;
	}
	}
	}

	void Menu::Renderer::renderInfo(const Graphics::Bitmap & work, const Font & font){
	for (std::vector< ::Menu::InfoBox *>::iterator i = info.begin(); i != info.end(); ++i){
	::Menu::InfoBox box = i;
	box->render(work, font);
	}
	}

	Menu::DefaultRenderer::DefaultRenderer():
	hasOverride(false),
	overrideIndex(0){
	// Default the menu to a certain size and details
	menu.transforms.setRadius(15);
	menu.location.set(-.6, -.3, .6, .8);
	menu.colors.body = Graphics::makeColor(0,0,0);
	menu.colors.bodyAlpha = 128;
	menu.colors.border = Graphics::makeColor(200,200,200);
	menu.colors.borderAlpha = 255;
	}

	vector<Util::ReferenceCount<MenuOption> > Menu::DefaultRenderer::getOptions() const {
	return options;
	}

	void Menu::DefaultRenderer::invokeOverride(const Context & context){
	if (hasOverride){
	options[overrideIndex]->run(context);
	throw Exception::Return(__FILE__, __LINE__);
	}
	}

	Menu::DefaultRenderer::~DefaultRenderer(){
	}

	Menu::Renderer::Type Menu::DefaultRenderer::getType() const {
	return Default;
	}

	bool Menu::DefaultRenderer::readToken(const Token * token, const OptionFactory & factory){
	if( *token == "option" ) {
	try{
	MenuOption * temp = factory.getOption(menu, token);
	if (temp){
	// Check for info/name
	{
	TokenView view = token->view();
	while (view.hasMore()){
	const Token * tok;
	view >> tok;
	try{
	if (*tok == "info"){
	temp->addInfo(tok);
	} else if (*tok == "name"){
	temp->addName(tok);
	}
	} catch (const TokenException & ex){
	// Output something
	}
	}
	}
	options.push_back(Util::ReferenceCount<MenuOption>(temp));
	if (!hasOverride){
	const Token * tok;
	token->view() >> tok;
	if (tok->findToken("_/override") != NULL){
	overrideIndex = options.size()-1;
	hasOverride = true;
	}
	}
	}
	} catch (const LoadException & le){
	Global::debug(0) << "Could not read option: " << le.getTrace() << endl;
	token->print(" ");
	}
	} else if ( *token == "position" ) {
	// This handles the placement of the menu list and surrounding box
	menu.setCoordinates(token);
	} else if ( *token == "relative-position"){
	menu.setCoordinates(token);
	} else if ( *token == "coordinate"){
	menu.setCoordinates(token);
	} else if ( *token == "position-body" ) {
	// This handles the body color of the menu box
	menu.setColors(token);
	} else if ( *token == "position-border" ) {
	// This handles the border color of the menu box
	menu.setColors(token);
	} else if ( *token == "transforms" ) {
	// This handles the border color of the menu box
	menu.setTransforms(token);
	} else if ( *token == "fade-speed" ) {
	// Menu fade in speed
	int speed;
	token->view() >> speed;
	menu.setFadeSpeed(speed);
	} else if ( parseDisplayList(token, menu) ){
	} else {
	return false;
	}

	return true;
	}

	void Menu::DefaultRenderer::initialize(Context & context){

	menu.setList(toContextList(menu, options));
	menu.open();

	// const Font & font = Configuration::getMenuFont()->get(context.getFont()->get());
	const Font & font = currentFont();
	// Menu info
	if (!context.getMenuInfoText().empty()){
	menuInfo.setText(context.getMenuInfoText());
	menuInfo.initialize(font);
	const int width = menuInfo.location.getWidth();
	const int height = menuInfo.location.getHeight();
	menuInfo.location.setPosition(Gui::AbsolutePoint(context.getMenuInfoLocation().getX() - width/2, context.getMenuInfoLocation().getY() - height/2));
	// have to pass the dimensions back in to correct proper placement
	menuInfo.location.setPosition2(Gui::AbsolutePoint(menuInfo.location.getX() + width, menuInfo.location.getY() + height));
	menuInfo.transforms.setRadius(menu.transforms.getRadius());
	menuInfo.colors = menu.colors;
	}

	menuInfo.open();

	// Add first info option
	addInfo(options[menu.getCurrentIndex()]->getInfoText(), menu, context, font);
	}

	void Menu::DefaultRenderer::finish(){
	menu.close();
	menuInfo.close();
	}

	bool Menu::DefaultRenderer::active(){
	return menu.isActive();
	}

	void Menu::DefaultRenderer::act(const Context & context){
	// const Font & font = Configuration::getMenuFont()->get(context.getFont()->get());
	const Font & font = currentFont();

	// FIXME find a better way to get options to update this is a waste
	for (std::vector<Util::ReferenceCount<MenuOption> >::iterator i = options.begin(); i != options.end(); ++i){
	Util::ReferenceCount<MenuOption> & option = *i;
	option->logic();
	}
	menu.act(font);
	menuInfo.act(font);
	actInfo(font);
	}

	void Menu::DefaultRenderer::render(const Graphics::Bitmap & bmp, const Font & font){
	menu.render(bmp, font);
	menuInfo.render(bmp, font);
	renderInfo(bmp, font);
	}

	void Menu::DefaultRenderer::addOption(MenuOption * opt){
	this->options.push_back(Util::ReferenceCount<MenuOption>(opt));
	}

	void Menu::DefaultRenderer::doAction(const Actions & action, Context & context){
	const Font & font = currentFont();
	switch(action){
	case Up:
	if (menu.previous(font)){
	context.playSound(Up);
	addInfo(options[menu.getCurrentIndex()]->getInfoText(), menu, context, font);
	}
	break;
	case Down:
	if (menu.next(font)){
	context.playSound(Down);
	addInfo(options[menu.getCurrentIndex()]->getInfoText(), menu, context, font);
	}
	break;
	case Left:
	if (options[menu.getCurrentIndex()]->leftKey()){
	// setFont(context.getFont());
	context.playSound(Left);
	}
	break;
	case Right:
	if (options[menu.getCurrentIndex()]->rightKey()){
	// setFont(context.getFont());
	context.playSound(Right);
	}
	break;
	case Select: {
	if (options[menu.getCurrentIndex()]->isRunnable()){
	try{
	context.playSound(Select);
	options[menu.getCurrentIndex()]->run(context);
	} catch (const Reload & reload){
	menu.open();
	menuInfo.open();
	}
	// setFont(context.getFont());
	context.playMusic();
	/* font might have been recreated */
	const Font & font = currentFont();
	addInfo(options[menu.getCurrentIndex()]->getInfoText(), menu, context, font);
	menuInfo.initialize(font);
	}
	break;
	}
	case Cancel:
	context.playSound(Cancel);
	throw Exception::Return(__FILE__, __LINE__);
	break;
	default:
	break;
	}
	}

	Menu::TabInfo::TabInfo(){
	}

	Menu::TabInfo::~TabInfo(){

	}

	void Menu::TabInfo::act(){
	// Miguel: FIXME find a better way to get options to update this is a waste
	// Jon: Whats wrong with it?
	for (std::vector<Util::ReferenceCount<MenuOption> >::iterator i = options.begin(); i != options.end(); ++i){
	Util::ReferenceCount<MenuOption> & option = *i;
	option->logic();
	}
	}

	Menu::TabRenderer::TabRenderer():
	hasOverride(false),
	overrideIndex(0){

	// Default the menu to a certain size and details
	//menu.transforms.setRadius(15);
	menu.location.set(-.6, -.3, .6, .8);
	menu.colors.body = Graphics::makeColor(0,0,0);
	menu.colors.bodyAlpha = 128;
	menu.colors.border = Graphics::makeColor(200,200,200);
	menu.colors.borderAlpha = 255;
	}

	Menu::Renderer::Type Menu::TabRenderer::getType() const {
	return Tabbed;
	}

	vector<Util::ReferenceCount<MenuOption> > Menu::TabRenderer::getOptions() const {
	vector<Util::ReferenceCount<MenuOption> > options;
	for (vector<TabInfo *>::const_iterator it = tabs.begin(); it != tabs.end(); ++it){
	options.insert(options.end(), (it)->options.begin(), (it)->options.end());
	}
	return options;
	}

	/* FIXME need to implement override for tabs */
	void Menu::TabRenderer::invokeOverride(const Context & context){
	if (hasOverride){
	//options[overrideIndex]->run(context);
	throw Exception::Return(__FILE__, __LINE__);
	}
	}

	Menu::TabRenderer::~TabRenderer(){
	// Kill tabs
	for (std::vector<TabInfo *>::iterator i = tabs.begin(); i != tabs.end(); ++i){
	if (*i){
	delete *i;
	}
	}
	}

	bool Menu::TabRenderer::readToken(const Token * token, const OptionFactory & factory){
	if (*token == "menu"){
	TabInfo * tabInfo = new TabInfo();
	Gui::Tab * tab = new Gui::Tab();
	TokenView view = token->view();
	while (view.hasMore()){
	const Token * tok;
	view >> tok;
	try{
	if (*tok == "name"){
	tok->view() >> tabInfo->name;
	tok->view() >> tab->name;
	} else if (*tok == "info"){
	tok->view() >> tabInfo->info;
	} else if (*tok == "menuinfo"){
	tok->view() >> tabInfo->menuInfo;
	} else if (parseDisplayList(tok, tab->getContext())){
	} else if (*tok == "option"){
	try {
	MenuOption *temp = factory.getOption(tab->getContext(), tok);
	if (temp){
	// Check for info/name
	{
	TokenView info = tok->view();
	while (info.hasMore()){
	const Token * check;
	info >> check;
	try{
	if (*check == "info"){
	temp->addInfo(check);
	} else if (*check == "name"){
	temp->addName(check);
	}
	} catch (const TokenException & ex){
	// Output something
	}
	}
	}
	Util::ReferenceCount<MenuOption> ref(temp);
	tabInfo->options.push_back(ref);
	tab->addOption(ref.convert<Gui::ContextItem>());
	// tab->addOption(ref->getAsScrollItem<ContextItem>(tab->getContext()));
	}
	} catch (const LoadException & le){
	tok->print(" ");
	}
	}
	} catch (const TokenException & ex){
	// Output something
	}
	}
	menu.addTab(tab);
	tabs.push_back(tabInfo);
	} else if ( *token == "position" ) {
	// This handles the placement of the menu list and surrounding box
	menu.setCoordinates(token);
	} else if ( *token == "relative-position"){
	menu.setCoordinates(token);
	} else if ( *token == "coordinate"){
	menu.setCoordinates(token);
	} else if ( *token == "position-body" ) {
	// This handles the body color of the menu box
	menu.setColors(token);
	} else if ( *token == "position-border" ) {
	// This handles the border color of the menu box
	menu.setColors(token);
	} else if ( *token == "transforms" ) {
	// This handles the border color of the menu box
	menu.setTransforms(token);
	} else if ( *token == "tab-body" ) {
	int r,g,b;
	token->view() >> r >> g >> b >> menu.tabColors.bodyAlpha;
	menu.tabColors.body = Graphics::makeColor(r,g,b);
	} else if ( *token == "tab-border" ) {
	int r,g,b;
	token->view() >> r >> g >> b >> menu.tabColors.borderAlpha;
	menu.tabColors.border = Graphics::makeColor(r,g,b);
	} else if ( *token == "selectedtab-body" ) {
	int r,g,b;
	token->view() >> r >> g >> b >> menu.selectedTabColors.bodyAlpha;
	menu.selectedTabColors.body = Graphics::makeColor(r,g,b);
	} else if ( *token == "selectedtab-border" ) {
	int r,g,b;
	token->view() >> r >> g >> b >> menu.selectedTabColors.borderAlpha;
	menu.selectedTabColors.border = Graphics::makeColor(r,g,b);
	} else if ( *token == "runningtab-body" ) {
	int r,g,b;
	token->view() >> r >> g >> b >> menu.runningTabColors.bodyAlpha;
	menu.runningTabColors.body = Graphics::makeColor(r,g,b);
	} else if ( *token == "runningtab-border" ) {
	int r,g,b;
	token->view() >> r >> g >> b >> menu.runningTabColors.borderAlpha;
	menu.runningTabColors.border = Graphics::makeColor(r,g,b);
	} else if ( *token == "font-color" ) {
	int r,g,b;
	token->view() >> r >> g >> b;
	menu.setTabFontColor(Graphics::makeColor(r,g,b));
	} else if ( *token == "selectedfont-color" ) {
	int r,g,b;
	token->view() >> r >> g >> b;
	menu.setSelectedTabFontColor(Graphics::makeColor(r,g,b));
	} else if ( *token == "runningfont-color" ) {

	} else if ( *token == "fade-speed" ) {
	// Menu fade in speed
	int speed;
	token->view() >> speed;
	//menu.setFadeSpeed(speed);
	} else {
	return false;
	}

	return true;
	}

	void Menu::TabRenderer::initialize(Context & context){

	const Font & font = currentFont();
	// Menu info
	if (!context.getMenuInfoText().empty()){
	menuInfo.setText(context.getMenuInfoText());
	menuInfo.initialize(font);
	const int width = menuInfo.location.getWidth();
	const int height = menuInfo.location.getHeight();
	menuInfo.location.setPosition(Gui::AbsolutePoint(context.getMenuInfoLocation().getX() - width/2, context.getMenuInfoLocation().getY() - height/2));
	// have to pass the dimensions back in to correct proper placement
	menuInfo.location.setPosition2(Gui::AbsolutePoint(menuInfo.location.getX() + width,menuInfo.location.getY() + height));
	menuInfo.transforms.setRadius(menu.transforms.getRadius());
	menuInfo.colors = menu.colors;
	}

	menuInfo.open();

	if (tabs.size() > 0 && tabs[menu.getCurrentTab()]->options.size() > menu.getCurrentIndex()){
	// Add first info option
	addInfo(tabs[menu.getCurrentTab()]->options[menu.getCurrentIndex()]->getInfoText(), menu, context, font);
	}

	}

	void Menu::TabRenderer::finish(){
	//menu.close();
	menuInfo.close();
	}

	bool Menu::TabRenderer::active(){
	return true;//menu.isActive();
	}

	void Menu::TabRenderer::act(const Context & context){
	const Font & font = currentFont();
	// FIXME find a better way to get options to update this is a waste
	for (std::vector<TabInfo *>::iterator i = tabs.begin(); i != tabs.end(); ++i){
	TabInfo * tab = *i;
	tab->act();
	}
	menu.act(font);
	menuInfo.act(font);
	actInfo(font);
	}

	void Menu::TabRenderer::render(const Graphics::Bitmap & bmp, const Font & font){
	menu.render(bmp, font);
	menuInfo.render(bmp, font);
	renderInfo(bmp, font);
	}

	void Menu::TabRenderer::addOption(MenuOption * opt){
	//this->options.push_back(opt);
	}

	void Menu::TabRenderer::doAction(const Actions & action, Context & context){
	const Font & font = currentFont();

	bool updateInfo = false;
	switch (action){
	case Up:
	menu.up(font);
	context.playSound(Up);
	updateInfo = true;
	break;
	case Down:
	menu.down(font);
	context.playSound(Down);
	updateInfo = true;
	break;
	case Left:
	menu.left(font);
	context.playSound(Up);
	updateInfo = true;
	break;
	case Right:
	menu.right(font);
	context.playSound(Down);
	updateInfo = true;
	break;
	case Select:
	try{
	if (!menu.isInTab()){
	menu.toggleTabSelect();
	} else {
	if (menu.getCurrentTab() < tabs.size() &&
	menu.getCurrentIndex() < tabs[menu.getCurrentTab()]->options.size() &&
	tabs[menu.getCurrentTab()]->options[menu.getCurrentIndex()]->isRunnable()){
	tabs[menu.getCurrentTab()]->options[menu.getCurrentIndex()]->run(context);
	}
	// tabs[menu.getCurrentTab()]->run(menu.getCurrentIndex(), context);
	}
	context.playSound(Select);
	} catch (const Exception::Return & ex){
	menuInfo.open();
	}
	context.playMusic();
	updateInfo = true;
	break;
	case Cancel:
	context.playSound(Cancel);
	if (menu.isInTab()){
	menu.toggleTabSelect();
	} else {
	throw Exception::Return(__FILE__, __LINE__);
	}
	break;
	default:
	break;
	}

	if (updateInfo){
	if (tabs.size() > menu.getCurrentTab() &&
	tabs[menu.getCurrentTab()]->options.size() > menu.getCurrentIndex()){
	addInfo(tabs[menu.getCurrentTab()]->options[menu.getCurrentIndex()]->getInfoText(), menu, context, font);
	}
	}
	}

	Menu::Context::Context():
	cleanup(true),
	state(NotStarted),
	fades(0),
	font(NULL),
	infoLocation(0, -.5),
	menuInfoLocation(0,.95){
	}

	Menu::Context::Context(const Context & parent, const Context & child):
	cleanup(false),
	state(NotStarted),
	fades(NULL),
	font(NULL),
	infoLocation(0,-.5),
	menuInfoLocation(0,.95),
	/* include child's languages?? */
	languages(parent.getLanguages()){
	// Update with parents info
	fades = parent.fades;
	background = parent.background;
	sounds = parent.sounds;
	music = parent.music;
	// font = parent.font;
	infoLocation = parent.infoLocation;
	menuInfoLocation = parent.menuInfoLocation;

	// Then overwrite with childs
	if (child.fades != NULL){
	fades = child.fades;
	}

	if (!child.background.empty()){
	background = child.background;
	}

	if (!child.sounds.empty()){
	sounds = child.sounds;
	}

	if (Storage::instance().exists(child.music)){
	music = child.music;
	}

	if (child.hasFont()){
	font = child.getFontInfo();
	} else if (parent.hasFont()){
	font = parent.getFontInfo();
	}

	/* what are these magic numbers -.5 and .95? */
	if (child.infoLocation.getRelativeX() != 0 \|\| child.infoLocation.getRelativeY() != -.5){
	infoLocation = child.infoLocation;
	}

	if (child.menuInfoLocation.getRelativeX() != 0 \|\| child.menuInfoLocation.getRelativeY() != .95){
	menuInfoLocation = child.menuInfoLocation;
	}

	if (!child.menuInfo.empty()){
	menuInfo = child.menuInfo;
	}
	}

	Menu::Context::~Context(){
	// Only delete if required
	if (cleanup){
	if (fades != NULL){
	delete fades;
	}
	}
	}

	std::vector<std::string> Menu::Context::getLanguages() const {
	return languages;
	}

	void Menu::Context::setLanguages(const std::vector<std::string> & languages){
	this->languages = languages;
	}

	bool Menu::Context::hasFont() const {
	return font != NULL;
	}

	void Menu::Context::parseToken(const Token * token){
	if ( *token != "context" ){
	throw LoadException(__FILE__, __LINE__, "Not a menu context");
	} else if (!token->hasTokens()){
	return;
	}
	// Token
	const Token * tok;
	token->view() >> tok;

	TokenView view = tok->view();
	while (view.hasMore()){
	const Token * context;
	view >> context;
	if (*context == "fade"){
	// Fade info
	if (!fades){
	fades = new Gui::FadeTool();
	}
	// Set fader default to white
	fades->setFadeInColor(Graphics::makeColor(255,255,255));
	fades->setFadeOutColor(Graphics::makeColor(255,255,255));
	fades->setFadeInTime(25);
	fades->setFadeOutTime(12);

	// Load defaults
	fades->parseDefaults(context);
	} else if (context == "animation" \|\| context == "background"){
	// Backgrounds
	addBackground(context);
	} else if (*context == ""){
	}
	}

	}

	void Menu::Context::addBackground(const Token * token){
	// Backgrounds
	/*if (background == NULL){
	background = new Gui::AnimationManager();
	}*/
	background.add(Util::ReferenceCount<Gui::Animation>(new Gui::Animation(token)));
	}

	void Menu::Context::addBackground(const Graphics::Bitmap & image){
	/*if (background == NULL){
	background = new Gui::AnimationManager();
	}*/
	background.add(Util::ReferenceCount<Gui::Animation>(new Gui::Animation(Util::ReferenceCount<Graphics::Bitmap>(new Graphics::Bitmap(image)))));
	}

	void Menu::Context::addBackground(const std::string & image){
	// Backgrounds
	/*if (background == NULL){
	background = new Gui::AnimationManager();
	}*/
	background.add(Util::ReferenceCount<Gui::Animation>(new Gui::Animation(image)));
	}

	void Menu::Context::initialize(){
	if (fades){
	// state
	state = Initializing;
	// set fader state
	fades->setState(FadeTool::FadeIn);
	} else {
	// Running
	state = Running;
	}
	}

	void Menu::Context::finish(){
	if (fades){
	// state
	state = Finishing;
	// set fader state
	fades->setState(FadeTool::FadeOut);
	} else {
	// Completed
	state = Completed;
	}
	}

	void Menu::Context::playSound(const Actions & sound) const {
	map<Actions, Filesystem::RelativePath>::const_iterator find = sounds.find(sound);
	if (find != sounds.end() && Storage::instance().exists(find->second)){
	tryPlaySound(find->second);
	}
	}

	void Menu::Context::addSound(const Actions & sound, const Filesystem::RelativePath & path){
	sounds[sound] = path;
	}

	void Menu::Context::playMusic(){
	if (Storage::instance().exists(music)){
	if (Music::loadSong(Storage::instance().find(music).path())){
	Music::pause();
	Music::play();
	}
	}
	}

	void Menu::Context::act(){
	// fader
	if (fades){
	fades->act();
	if (state == Initializing){
	if(fades->getState() == Gui::FadeTool::NoFade){
	state = Running;
	}
	} else if (state == Finishing){
	if(fades->getState() == Gui::FadeTool::EndFade){
	state = Completed;
	}
	}
	}
	// Backgrounds
	background.act();
	}

	-void Menu::Context::render(const Util::ReferenceCount<Renderer> & renderer, const Graphics::Bitmap & bmp){
	+void Menu::Context::renderBackground(const Graphics::Bitmap & bmp) const {
	if (!background.empty()){
	// background
	background.render(Gui::Animation::BackgroundBottom, bmp);
	background.render(Gui::Animation::BackgroundMiddle, bmp);
	background.render(Gui::Animation::BackgroundTop, bmp);
	} else {
	bmp.fill(Graphics::makeColor(0,0,0));
	}
	+}

	- // Menu
	- if (renderer != NULL){
	- renderer->render(bmp, currentFont());
	- }
	-
	+void Menu::Context::renderForeground(const Graphics::Bitmap & bmp) const {
	if (!background.empty()){
	// foreground
	background.render(Gui::Animation::ForegroundBottom, bmp);
	background.render(Gui::Animation::ForegroundMiddle, bmp);
	background.render(Gui::Animation::ForegroundTop, bmp);
	}
	-
	+}
	+
	+void Menu::Context::render(const Util::ReferenceCount<Renderer> & renderer, const Graphics::Bitmap & bmp){
	+ renderBackground(bmp);
	+
	+ // Menu
	+ if (renderer != NULL){
	+ renderer->render(bmp, currentFont());
	+ }
	+
	+ renderForeground(bmp);
	+
	// Fades
	if (fades){
	fades->draw(bmp);
	}
	}

	void Menu::Context::setFadeTool(Gui::FadeTool *fade){
	fades = fade;
	}
	/*
	void Menu::Context::setBackground(Background *bg){
	background = bg;
	}
	*/

	/* New Menu */

	// Utilizes default renderer
	Menu::Menu::Menu(const Renderer::Type & type):
	type(type){
	setRenderer(type);
	}

	Menu::Menu::Menu(const Util::ReferenceCount<Renderer> & renderer):
	renderer(renderer),
	type(renderer->getType()){
	}

	Menu::Menu::Menu(const Filesystem::AbsolutePath & filename, const Renderer::Type & type):
	type(type){
	// Load up tokenizer
	try{
	Global::debug(1,"menu") << "Loading menu " << filename.path() << endl;
	TokenReader tr;
	Token * token = tr.readTokenFromFile(*Storage::instance().open(filename));
	OptionFactory defaultFactory;
	load(token, defaultFactory);
	} catch (const TokenException & e){
	throw LoadException(__FILE__, __LINE__, e, "Error loading menu");
	}
	}

	Menu::Menu::Menu(const Filesystem::AbsolutePath & filename, const OptionFactory & factory, const Renderer::Type & type):
	renderer(0),
	type(type){
	// Load up tokenizer
	try{
	Global::debug(1,"menu") << "Loading menu " << filename.path() << endl;
	TokenReader tr;
	Token * token = tr.readTokenFromFile(*Storage::instance().open(filename));
	load(token, factory);
	} catch (const TokenException & e){
	throw LoadException(__FILE__, __LINE__, e, "Error loading menu");
	}
	}

	Menu::Menu::Menu(const Token * token, const Renderer::Type & type):
	renderer(0),
	type(type){
	OptionFactory defaultFactory;
	load(token, defaultFactory);
	}

	Menu::Menu::Menu(const Token * token, const OptionFactory & factory, const Renderer::Type & type):
	renderer(0),
	type(type){
	load(token, factory);
	}

	Menu::Menu::~Menu(){
	// Kill values
	for (std::map<string,ValueHolder *>::iterator i = data.begin(); i != data.end(); ++i){
	if (i->second){
	delete i->second;
	}
	}
	}

	void Menu::Menu::setFont(const Util::ReferenceCount<FontInfo> & font){
	context.setFont(font);
	/*
	if (renderer){
	renderer->setFont(font);
	}
	*/
	}

	void Menu::Menu::load(const Token * token, const OptionFactory & factory){
	// version info;
	int major=0, minor=0, micro=0;
	if (!token->hasTokens()){
	throw LoadException(__FILE__, __LINE__, "Empty Menu");
	} else {
	const Token *ourToken = token->findToken("_/type");
	if (ourToken != NULL){
	try {
	std::string menuType;
	ourToken->view() >> menuType;
	if (menuType == "default"){
	type = Renderer::Default;
	} else if (menuType == "tabbed"){
	type = Renderer::Tabbed;
	}
	} catch (const TokenException & ex){
	}
	}
	ourToken = token->findToken("_/version");
	if (ourToken != NULL){
	try {
	ourToken->view() >> major >> minor >> micro;
	} catch (const TokenException & ex){
	}
	} else {
	Global::debug(0, "menu") << "No version indicated, assuming 3.3.1 or below." << endl;
	major = 3;
	minor = 3;
	micro = 1;
	}
	}

	setRenderer(type);

	if (Global::getVersion(major, minor, micro) != Global::getVersion()){
	// Do compatible translations if necessary
	handleCompatibility(token, Global::getVersion(major, minor, micro), factory);
	} else {
	handleCurrentVersion(token);
	}

	}

	typedef Menu::Menu MenuClass;
	class LanguageMenu: public Menu::Menu {
	public:
	class LanguageOption: public MenuOption {
	public:
	LanguageOption(const Gui::ContextBox & box, const string & language):
	MenuOption(box, NULL){
	setText(language);
	setInfoText(language);
	}

	virtual void logic(){
	}

	virtual void run(const ::Menu::Context & context){
	Configuration::setLanguage(getText());
	Configuration::saveConfiguration();
	throw ::Menu::MenuException(__FILE__, __LINE__);
	}
	};

	static vector<string> findLanguages(const MenuClass & original){
	return original.getLanguages();
	}

	static vector<string> putEnglishFirst(vector<string> languages){
	vector<string> out;
	bool haveEnglish = false;
	for (vector<string>::iterator it = languages.begin(); it != languages.end(); it++){
	const string & name = *it;
	if (name == "English"){
	out.insert(out.begin(), name);
	haveEnglish = true;
	} else {
	out.push_back(name);
	}
	}

	/* We should always have at least english available */
	if (!haveEnglish){
	out.insert(out.begin(), "English");
	}

	return out;
	}

	LanguageMenu(const MenuClass & original){
	Util::ReferenceCount< ::Menu::DefaultRenderer > renderer = getRenderer().convert< ::Menu::DefaultRenderer>();
	vector<string> languages = putEnglishFirst(findLanguages(original));
	for (vector<string>::iterator it = languages.begin(); it != languages.end(); it++){
	addOption(new LanguageOption(renderer->getBox(), *it));
	}
	}
	};

	void Menu::Menu::setupDefaultLanguage(const Context & context, const MenuClass & parent){
	LanguageMenu menu(parent);
	menu.setFont(Util::ReferenceCount<FontInfo>(new RelativeFontInfo(Filesystem::RelativePath(sharedFont), sharedFontWidth, sharedFontHeight)));
	Configuration::setLanguage("English");
	try{
	menu.run(context);
	} catch (const ::Menu::MenuException & ignore){
	}
	}

	void Menu::Menu::openOptions(){
	vector<Util::ReferenceCount<MenuOption> > options = getRenderer()->getOptions();
	for (vector<Util::ReferenceCount<MenuOption> >::iterator it = options.begin(); it != options.end(); it++){
	Util::ReferenceCount<MenuOption> & option = *it;
	option->open();
	}
	}

	void Menu::Menu::closeOptions(){
	vector<Util::ReferenceCount<MenuOption> > options = getRenderer()->getOptions();
	for (vector<Util::ReferenceCount<MenuOption> >::iterator it = options.begin(); it != options.end(); it++){
	Util::ReferenceCount<MenuOption> & option = *it;
	option->close();
	}
	}

	vector<string> Menu::Menu::getLanguages() const {
	return languages;
	}

	void Menu::Menu::run(const Context & parentContext){
	/* TODO: replace with Parameter */
	Keyboard::pushRepeatState(true);
	try{
	// Setup context from parent and this menu and initialize
	Context localContext(parentContext, context);
	Util::Parameter<Util::ReferenceCount<FontInfo> > currentFont(menuFontParameter);
	if (context.hasFont()){
	currentFont.push(context.getFontInfo());
	}
	localContext.initialize();

	/* Not sure if this is the right place to set the languages.
	* For now the semantics is that if a sub-menu specifies a set
	* of languages then we will use those, otherwise the
	* languages will come from the parentContext.
	*
	* getLanguages() is supposed to hold at least one language
	* which might be English, the default.
	*
	* This logic is sort of lame.. fix it.
	*/
	if (getLanguages().size() > 1 \|\| (getLanguages().size() == 1 && getLanguages()[0] != "English")){
	localContext.setLanguages(getLanguages());
	}

	// Setup menu fonts etc
	if (renderer != NULL){
	renderer->initialize(localContext);

	// Invoke Override if available
	renderer->invokeOverride(localContext);
	}

	//Play music
	localContext.playMusic();

	if (Configuration::getLanguage() == ""){
	setupDefaultLanguage(localContext, *this);
	}

	/* do any lazy loading options want to do */
	openOptions();

	/* vi keys -- make these optional? */
	input.set(Keyboard::Key_J, 0, true, Down);
	input.set(Keyboard::Key_K, 0, true, Up);
	input.set(Keyboard::Key_H, 0, true, Left);
	input.set(Keyboard::Key_L, 0, true, Right);
	/* regular keys */
	input.set(Configuration::getUp(0), 0, true, Up);
	input.set(Configuration::getDown(0), 0, true, Down);
	input.set(Configuration::getLeft(0), 0, true, Left);
	input.set(Configuration::getRight(0), 0, true, Right);
	input.set(Configuration::getAttack1(0), 0, true, Select);
	/* FIXME: use configuration keys */
	input.set(Keyboard::Key_ENTER, 0, true, Select);
	input.set(Keyboard::Key_ESC, 0, true, Cancel);
	/* joystick */
	input.set(Joystick::Up, 0, true, Up);
	input.set(Joystick::Down, 0, true, Down);
	input.set(Joystick::Left, 0, true, Left);
	input.set(Joystick::Right, 0, true, Right);
	/! FIXME this should be changed to Select/Cancel buttons, all other buttons should be Select /
	input.set(Joystick::Button1, 0, true, Select);
	input.set(Joystick::Button2, 0, true, Select);
	input.set(Joystick::Button3, 0, true, Select);
	input.set(Joystick::Button4, 0, true, Select);
	input.set(Joystick::Start, 0, true, Select);
	input.set(Joystick::Quit, 0, true, Cancel);

	class Logic: public Util::Logic {
	public:
	Logic(Menu & menu, Context & localContext, const Util::ReferenceCount<Renderer> & renderer):
	menu(menu),
	localContext(localContext),
	renderer(renderer){
	}

	Menu & menu;
	Context & localContext;
	Util::ReferenceCount<Renderer> renderer;

	void run(){
	try {
	menu.act(localContext);
	} catch (const Exception::Return & ex){
	// signaled to quit current menu, closing this one out
	localContext.finish();
	if (renderer != NULL){
	renderer->finish();
	}
	}
	}

	double ticks(double system){
	return system * Global::ticksPerSecond(90);
	}

	bool done(){
	return localContext.getState() == Context::Completed \|\|
	!(renderer != NULL && renderer->active());
	}
	};

	class Draw: public Util::Draw {
	public:
	Draw(Menu & menu, Context & localContext):
	menu(menu),
	localContext(localContext){
	}

	Menu & menu;
	Context & localContext;

	void draw(const Graphics::Bitmap & buffer){
	Graphics::StretchedBitmap work(640, 480, buffer, Graphics::qualityFilterName(Configuration::getQualityFilter()));
	Util::Parameter<Util::ReferenceCount<FontInfo> > currentFont(menuFontParameter);
	if (Configuration::hasMenuFont()){
	currentFont.push(Configuration::getMenuFont());
	}

	work.start();
	menu.render(localContext, work);
	work.finish();

	buffer.BlitToScreen();
	}
	};

	Logic logic(*this, localContext, renderer);
	Draw draw(*this, localContext);

	Util::standardLoop(logic, draw);

	closeOptions();

	// FIXME Menu is finished, lets return. Is this even required anymore?
	throw Exception::Return(__FILE__, __LINE__);
	} catch (...){
	Keyboard::popRepeatState();
	throw;
	}
	}

	void Menu::Menu::act(Context & ourContext){
	// Keys
	vector<InputMap<Actions>::InputEvent> events = InputManager::getEvents(input, InputSource());

	for (vector<InputMap<Actions>::InputEvent>::iterator it = events.begin(); it != events.end(); it++){
	InputMap<Actions>::InputEvent event = *it;

	if (!event.enabled){
	continue;
	}

	if (event.out == Cancel){
	if (renderer != NULL){
	InputManager::waitForRelease(input, InputSource(), Cancel);
	renderer->doAction(Cancel, ourContext);
	} else {
	ourContext.playSound(Cancel);
	InputManager::waitForRelease(input, InputSource(), Cancel);
	throw Exception::Return(__FILE__, __LINE__);
	}
	}

	if (renderer != NULL){
	switch (event.out){
	case Up: renderer->doAction(Up, ourContext); break;
	case Down: renderer->doAction(Down, ourContext); break;
	case Left: renderer->doAction(Left, ourContext); break;
	case Right: renderer->doAction(Right, ourContext); break;
	case Select: renderer->doAction(Select, ourContext); break;
	default: break;
	}
	}
	}

	if (renderer != NULL){
	Util::Parameter<Util::ReferenceCount<FontInfo> > currentFont(menuFontParameter);
	if (Configuration::hasMenuFont()){
	currentFont.push(Configuration::getMenuFont());
	}
	renderer->act(ourContext);
	}

	// Act context
	ourContext.act();
	}

	void Menu::Menu::render(Context & ourContext, const Graphics::Bitmap & bmp){
	// Render context
	ourContext.render(renderer, bmp);
	}

	std::string Menu::Menu::getName(){
	std::string name;
	try {
	if (data["name"]){
	*data["name"] >> name;
	}
	} catch (const MenuException & ex){
	}
	return name;
	}

	std::string Menu::Menu::getInfo(){
	std::string name;
	try {
	if (data["info"]){
	*data["info"] >> name;
	}
	} catch (const MenuException & ex){
	}
	return name;
	}

	void Menu::Menu::addData(ValueHolder * item){
	std::pair<std::map<std::string,ValueHolder *>::iterator,bool> check;
	check = data.insert( std::pair<std::string,ValueHolder *>(item->getName(),item) );
	if (check.second == false){
	Global::debug(0,"menu") << "Value \"" << check.first->second->getName() << "\" already exists - (" << check.first->second->getValues() << ")." << endl;
	Global::debug(0,"menu") << "Replacing with value \"" << item->getName() << "\" - (" << item->getValues() << ")." << endl;
	data[item->getName()] = item;
	}
	}

	void Menu::Menu::handleCurrentVersion(const Token * token){
	TokenView view = token->view();
	while (view.hasMore()){
	try{
	const Token * tok;
	view >> tok;
	// Newer items
	if (tok == "val" \|\| tok == "value"){
	const Token * val;
	tok->view() >> val;
	ValueHolder * value = new ValueHolder(val->getName());
	TokenView valueView = val->view();
	try {
	while (true){
	*value << valueView;
	}
	} catch (const TokenException & ex){
	}
	addData(value);
	} else if (*tok == "context"){
	context.parseToken(tok);
	} else {
	Global::debug(3,"menu") <<"Unhandled menu attribute: "<<endl;
	if (Global::getDebug() >= 3){
	tok->print(" ");
	}
	}
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Menu parse error");
	} catch (const LoadException & ex){
	throw ex;
	} catch (const Filesystem::NotFound & ex){
	throw LoadException(__FILE__, __LINE__, ex, "Menu parse error");
	}
	}
	}

	void Menu::Menu::handleCompatibility(const Token * token, int version, const OptionFactory & factory){
	Global::debug(1,"menu") << "Trying version: " << version << endl;
	if (version <= Global::getVersion(3, 3, 1)){

	const Token * languages = token->findToken("_/languages");
	if (languages != NULL){
	try{
	TokenView view = languages->view();
	while (true){
	string language;
	view >> language;
	this->languages.push_back(language);
	}
	} catch (const TokenException & fail){
	}
	}
	if (this->languages.size() == 0){
	this->languages.push_back("English");
	}

	TokenView view = token->view();
	while (view.hasMore()){
	try {
	const Token * tok;
	view >> tok;
	if ( *tok == "name" ){
	ValueHolder * value = new ValueHolder("name");
	TokenView nameView = tok->view();
	*value << nameView;
	addData(value);
	} else if ( *tok == "music" ) {
	ValueHolder * value = new ValueHolder("music");
	TokenView musicView = tok->view();
	*value << musicView;
	addData(value);
	try {
	std::string music;
	*value >> music;
	context.setMusic(Filesystem::RelativePath(music));
	} catch (const MenuException & ex){
	}
	} else if( *tok == "select-sound" ) {
	ValueHolder * value = new ValueHolder("select-sound");
	TokenView soundView = tok->view();
	*value << soundView;
	addData(value);
	try{
	std::string sound;
	*value >> sound;
	context.addSound(Up, Filesystem::RelativePath(sound));
	context.addSound(Down, Filesystem::RelativePath(sound));
	} catch (const MenuException & ex){
	}
	} else if (*tok == "back-sound"){
	ValueHolder * value = new ValueHolder("back-sound");
	TokenView soundView = tok->view();
	*value << soundView;
	addData(value);
	try{
	std::string sound;
	*value >> sound;
	context.addSound(Back,Filesystem::RelativePath(sound));
	context.addSound(Cancel,Filesystem::RelativePath(sound));
	} catch (const MenuException & ex){
	}
	} else if (*tok == "ok-sound"){
	ValueHolder * value = new ValueHolder("ok-sound");
	TokenView okView = tok->view();
	*value << okView;
	addData(value);
	try{
	std::string sound;
	*value >> sound;
	context.addSound(Select,Filesystem::RelativePath(sound));
	} catch (const MenuException & ex){
	}
	} else if ( *tok == "background" ) {
	std::string temp;
	tok->view() >> temp;
	context.addBackground(temp);
	} else if (*tok == "anim"){
	context.addBackground(tok);
	} else if ( *tok == "clear-color" ) {
	// Not necessary ignore
	} else if (renderer != NULL && renderer->readToken(tok, factory)){
	// Nothing checks compatible version of renderer
	} else if ( *tok == "font" ) {
	ValueHolder * value = new ValueHolder("font");
	TokenView fontView = tok->view();
	*value << fontView << fontView << fontView;
	addData(value);
	try {
	std::string font;
	int w = 24, h = 24;
	*value >> font >> w >> h;
	/*context.setFont(Filesystem::RelativePath(font));
	context.setFontWidth(w);
	context.setFontHeight(h);*/
	context.setFont(Util::ReferenceCount<FontInfo>(new RelativeFontInfo(Filesystem::RelativePath(font), w, h)));
	} catch (const MenuException & ex){
	}
	} else if ( *tok == "action"){
	// Set speed
	//ActionAct(tok);
	} else if ( *tok == "info-position"){
	ValueHolder * value = new ValueHolder("info-position");
	TokenView infoView = tok->view();
	*value << infoView << infoView;
	addData(value);
	try {
	double x=0, y=-.5;
	*value >> x >> y;
	context.setInfoLocation(x,y);
	} catch (const MenuException & ex){
	}
	} else if (*tok == "menuinfo"){
	ValueHolder * value = new ValueHolder("menuinfo");
	TokenView infoView = tok->view();
	*value << infoView;
	addData(value);
	try {
	std::string info;
	*value >> info;
	context.setMenuInfoText(info);
	} catch (const MenuException & ex){
	}
	} else if (*tok == "menuinfo-position"){
	ValueHolder * value = new ValueHolder("menuinfo-position");
	TokenView infoView = tok->view();
	*value << infoView << infoView;
	addData(value);
	try {
	double x=0, y=.95;
	*value >> x >> y;
	context.setMenuInfoLocation(x,y);
	} catch (const MenuException & ex){
	}
	} else {
	Global::debug(3,"menu") <<"Unhandled menu attribute: "<<endl;
	if (Global::getDebug() >= 3){
	tok->print(" ");
	}
	}
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Menu parse error");
	} catch (const LoadException & ex){
	throw ex;
	} catch (const Filesystem::NotFound & ex){
	throw LoadException(__FILE__, __LINE__, ex, "Menu parse error");
	}
	}
	}
	}

	void Menu::Menu::setRenderer(const Renderer::Type & type){
	renderer = rendererType(type);
	}

	void Menu::Menu::setRenderer(const Util::ReferenceCount<Renderer> & renderer){
	this->renderer = renderer;
	}

	void Menu::Menu::addOption(MenuOption * opt){
	if (renderer != NULL){
	this->renderer->addOption(opt);
	}
	}

	Util::ReferenceCount<Menu::Renderer> Menu::Menu::rendererType(const Renderer::Type & type){
	switch (type){
	case Renderer::Tabbed: {
	return Util::ReferenceCount<Renderer>(new TabRenderer());
	break;
	}
	case Renderer::Default:
	default: {
	return Util::ReferenceCount<Renderer>(new DefaultRenderer());
	break;
	}
	}

	return Util::ReferenceCount<Renderer>(NULL);
	}
	diff --git a/util/menu/menu.h b/util/menu/menu.h
	index 61124120..33c8e546 100644
	--- a/util/menu/menu.h
	+++ b/util/menu/menu.h
	@@ -1,564 +1,567 @@
	#ifndef _paintown_Menu_h
	#define _paintown_Menu_h

	#include <vector>
	#include <string>
	#include <map>

	#include "util/load_exception.h"
	#include "util/file-system.h"
	#include "util/pointer.h"
	#include "util/parameter.h"
	#include "util/input/input-map.h"
	#include "util/gradient.h"
	#include "font-info.h"

	#include "util/gui/animation.h"
	#include "util/gui/box.h"
	#include "util/gui/context-box.h"
	#include "util/gui/fadetool.h"
	#include "util/gui/popup-box.h"
	#include "util/gui/tabbed-box.h"
	#include "util/gui/widget.h"

	#ifdef _MSC_VER
	#ifndef uint32_t
	typedef unsigned __int32 uint32_t;
	#endif
	#endif

	class Font;

	namespace Graphics{
	class Bitmap;
	}

	class MenuOption;
	class Token;
	class TokenView;

	namespace Menu{

	extern Util::Parameter<Util::ReferenceCount<FontInfo> > menuFontParameter;

	Effects::Gradient standardGradient();

	class OptionFactory;
	class Point{
	public:
	int x;
	int y;
	Point();
	Point(int x, int y);
	~Point();
	};

	class InfoBox: public Gui::Widget {
	public:
	InfoBox();
	~InfoBox();

	void act(const Font &);
	virtual void render(const Graphics::Bitmap &);
	void render(const Graphics::Bitmap &, const Font & font);
	void open();
	void close();
	void setText(const std::string &);

	inline bool isActive(){
	return (this->state != NotActive);
	}

	/*
	inline void setFont(const Util::ReferenceCount<FontInfo> & font){
	this->font = font;
	}
	*/
	virtual void initialize(const Font & font);

	private:
	enum State{
	NotActive,
	Opening,
	Active,
	Closing,
	};

	State state;
	Gui::PopupBox popup;

	// Util::ReferenceCount<FontInfo> font;

	int fadeAlpha;

	std::vector<std::string> text;

	std::vector<int> padding;
	};

	class MenuException : public Exception::Base{
	public:
	MenuException(const std::string & file, int line, const std::string reason = "");
	MenuException(const MenuException & copy);
	MenuException(const Exception::Base & copy);
	virtual ~MenuException() throw();
	protected:

	std::string reason;

	virtual inline const std::string getReason() const {
	return reason;
	}

	virtual Exception::Base * copy() const;
	};

	/* reload the current menu, usually thrown by some option */
	class Reload: public MenuException {
	public:
	Reload(const std::string & file, int line, const std::string reason = "");
	virtual ~Reload() throw();
	protected:
	virtual Exception::Base * copy() const;
	};

	class ValueHolder{
	public:
	ValueHolder(const std::string &);
	ValueHolder(const ValueHolder &);
	virtual ~ValueHolder();

	virtual ValueHolder & operator=(const ValueHolder &);

	virtual ValueHolder & operator<<(const std::string &);
	virtual ValueHolder & operator<<(bool val);
	virtual ValueHolder & operator<<(int val);
	virtual ValueHolder & operator<<(double val);
	virtual ValueHolder & operator<<(TokenView &);

	virtual ValueHolder & operator>>(std::string &);
	virtual ValueHolder & operator>>(bool &);
	virtual ValueHolder & operator>>(int &);
	virtual ValueHolder & operator>>(double &);

	virtual inline const std::string & getName() const {
	return this->name;
	}

	virtual const std::string getValues();

	private:
	std::string name;
	std::vector<std::string> values;
	unsigned int location;

	void next();
	};

	/! Menu actions /
	enum Actions{
	Up,
	Down,
	Left,
	Right,
	Select,
	Back,
	Cancel,
	Modify,
	Pause,
	PlayAsteroids /* Hack for now, remove later */
	};

	class Context;

	/*! Menu Renderer
	* Allows menu to modify the way it displays it's contents
	* ie regular menus, tab menus, specialized menu etc
	*/
	class Renderer{
	public:
	Renderer();
	virtual ~Renderer();

	enum Type{
	Default,
	Tabbed
	};

	//! Reader
	virtual bool readToken(const Token *, const OptionFactory &)=0;

	virtual Type getType() const = 0;

	virtual void initialize(Context &)=0;
	virtual void finish()=0;
	virtual bool active()=0;

	virtual void act(const Context &)=0;
	virtual void render(const Graphics::Bitmap &, const Font & font)=0;

	// Set font if applicable
	// virtual void setFont(const Util::ReferenceCount<FontInfo> &);

	//! Compatibility for now, remove later
	virtual void addOption(MenuOption *)=0;
	virtual std::vector<Util::ReferenceCount<MenuOption> > getOptions() const = 0;

	/*! Handle action, with access to context
	*/
	virtual void doAction(const Actions &, Context &)=0;

	/! Invoke override /
	virtual void invokeOverride(const Context &)=0;

	protected:
	/! Info boxes /
	std::vector <InfoBox *> info;

	/! Menu info box /
	InfoBox menuInfo;

	/! Add info box /
	virtual void addInfo(const std::string &, const Gui::Widget &, Context &, const Font &);

	/! act info box /
	virtual void actInfo(const Font &);

	/! render info box /
	virtual void renderInfo(const Graphics::Bitmap &, const Font & font);
	};

	/! Regular Menu /
	class DefaultRenderer : public Renderer {
	public:
	DefaultRenderer();
	virtual ~DefaultRenderer();

	// virtual void setFont(const Util::ReferenceCount<FontInfo> &);
	virtual bool readToken(const Token *, const OptionFactory &);
	virtual void initialize(Context &);
	virtual void finish();
	virtual bool active();
	virtual void act(const Context &);
	virtual void render(const Graphics::Bitmap &, const Font &);
	virtual void addOption(MenuOption *);
	virtual void doAction(const Actions &, Context &);
	virtual std::vector<Util::ReferenceCount<MenuOption> > getOptions() const;
	virtual void invokeOverride(const Context &);

	virtual Type getType() const;

	virtual const Gui::ContextBox & getBox() const {
	return menu;
	}

	virtual Gui::ContextBox & getBox(){
	return menu;
	}

	private:

	/! Options /
	std::vector<Util::ReferenceCount<MenuOption> > options;

	/! Context Box /
	Gui::ContextBox menu;

	/! Override /
	bool hasOverride;

	/! Override index /
	unsigned int overrideIndex;
	};

	/! Tabbed Menu /
	class TabInfo {
	public:
	TabInfo();
	~TabInfo();
	std::string name;
	std::string info;
	std::string menuInfo;

	void act();

	/! Options /
	std::vector<Util::ReferenceCount<MenuOption> > options;
	};

	class TabRenderer: public Renderer {
	public:
	TabRenderer();
	virtual ~TabRenderer();

	// virtual void setFont(const Util::ReferenceCount<FontInfo> &);
	virtual bool readToken(const Token *, const OptionFactory &);
	virtual void initialize(Context &);
	virtual void finish();
	virtual bool active();
	virtual void act(const Context &);
	virtual void render(const Graphics::Bitmap &, const Font &);
	virtual void addOption(MenuOption *);
	virtual void doAction(const Actions &, Context &);
	virtual std::vector<Util::ReferenceCount<MenuOption> > getOptions() const;
	virtual void invokeOverride(const Context &);
	virtual Type getType() const;

	virtual Gui::TabbedBox & getBox(){
	return menu;
	}

	private:

	/! Tabs /
	std::vector<TabInfo *> tabs;

	/! Tabbed Box /
	Gui::TabbedBox menu;

	/! Override /
	bool hasOverride;

	/! Override index /
	unsigned int overrideIndex;
	};

	/*! Menu contexts
	- Each menu has a context which it defaults to
	- Sub menus will be passed the parents context when run
	- Fader
	- Backgrounds (No background will fall back onto a fill screen)
	- Menu (options, ContextBox, etc)
	- Contexts are settable to omit drawing certain items (usefull for things like in-game menus)
	*/
	class Context{
	public:
	Context();
	Context(const Context &, const Context &);
	virtual ~Context();

	virtual void act();
	/*! Pass the widget (Menu ContextBox in this case) to be drawn
	* Allows for custom widget menus to be draw in place (ie for tabs or something)
	*/
	virtual void render(const Util::ReferenceCount<Renderer> &, const Graphics::Bitmap &);

	+ virtual void renderBackground(const Graphics::Bitmap & bmp) const;
	+ virtual void renderForeground(const Graphics::Bitmap & bmp) const;
	+
	/! Parse data /
	virtual void parseToken(const Token *);

	//! Compatibility stuff
	virtual void addBackground(const Token *);
	virtual void addBackground(const std::string &);
	virtual void addBackground(const Graphics::Bitmap & image);

	/! Initializes things like faders /
	virtual void initialize();

	/! Closes things out like faders /
	virtual void finish();

	/! Play sound /
	virtual void playSound(const Actions &) const;

	/! Add sound /
	virtual void addSound(const Actions &, const Filesystem::RelativePath &);

	/! Play music /
	virtual void playMusic();

	/! set music /
	virtual inline void setMusic(const Filesystem::RelativePath & music){
	this->music = music;
	}

	/! Current state /
	enum State{
	NotStarted,
	Initializing,
	Running,
	Finishing,
	Completed,
	};

	inline const State & getState() const {
	return this->state;
	}

	virtual void setFadeTool(Gui::FadeTool *);

	virtual inline Gui::FadeTool * getFadeTool(){
	return this->fades;
	}
	/*
	virtual void setBackground(Util::ReferenceCount<Gui::AnimationManager> background);

	virtual inline Util::ReferenceCount<Gui::AnimationManager> getBackground(){
	return this->background;
	}
	*/
	virtual inline void setFont(const Util::ReferenceCount<FontInfo> & font){
	this->font = font;
	}

	virtual bool hasFont() const;

	virtual inline const Util::ReferenceCount<FontInfo> & getFont() const {
	return this->font;
	}

	virtual inline const Util::ReferenceCount<FontInfo> & getFontInfo() const {
	return this->font;
	}

	virtual inline void setInfoLocation(double x, double y){
	this->infoLocation.set(x,y);
	}

	virtual inline const Gui::RelativePoint & getInfoLocation() const {
	return this->infoLocation;
	}

	virtual inline void setMenuInfoLocation(double x, double y){
	this->menuInfoLocation.set(x,y);
	}

	virtual inline const Gui::RelativePoint & getMenuInfoLocation() const {
	return this->menuInfoLocation;
	}

	virtual inline void setMenuInfoText(const std::string & text){
	this->menuInfo = text;
	}

	virtual inline const std::string & getMenuInfoText() const {
	return this->menuInfo;
	}

	virtual std::vector<std::string> getLanguages() const;
	virtual void setLanguages(const std::vector<std::string> & languages);

	private:
	/! Require cleanup default constructor only* */
	bool cleanup;

	/! Current state /
	State state;

	/! Fade Tool /
	Gui::FadeTool * fades;

	/! Backgrounds /
	Gui::AnimationManager background;

	/! Sounds /
	std::map<Actions, Filesystem::RelativePath> sounds;

	/! Music /
	Filesystem::RelativePath music;

	/! Font /
	Util::ReferenceCount<FontInfo> font;

	/! Info Placement /
	Gui::RelativePoint infoLocation;

	/! Menu Info Placement /
	Gui::RelativePoint menuInfoLocation;

	/! Menu Info Text /
	std::string menuInfo;

	std::vector<std::string> languages;
	};

	/! New Menu class /
	class Menu{
	public:

	/* These two are basically the same but the Type version will create the renderer for you */
	Menu(const Renderer::Type & type = Renderer::Default);
	Menu(const Util::ReferenceCount<Renderer> & renderer);

	Menu(const Filesystem::AbsolutePath &, const Renderer::Type & type = Renderer::Default);
	Menu(const Filesystem::AbsolutePath &, const OptionFactory & factory, const Renderer::Type & type = Renderer::Default);
	Menu(const Token *, const Renderer::Type & type = Renderer::Default);
	Menu(const Token * token, const OptionFactory & factory, const Renderer::Type & type = Renderer::Default);
	virtual ~Menu();

	/! Run Menu pass parent context /
	virtual void run(const Context &);

	/! Logic pass local context /
	virtual void act(Context &);

	/! render pass local context and work /
	virtual void render(Context &, const Graphics::Bitmap &);

	virtual void setRenderer(const Renderer::Type &);
	virtual void setRenderer(const Util::ReferenceCount<Renderer> & renderer);

	/* a list of languages (translations) supported by this menu */
	virtual std::vector<std::string> getLanguages() const;

	/! Get Name /
	virtual std::string getName();
	virtual std::string getInfo();

	virtual void setFont(const Util::ReferenceCount<FontInfo> &);

	/! Add option /
	virtual void addOption(MenuOption * opt);

	virtual inline Util::ReferenceCount<Renderer> getRenderer() const {
	return renderer;
	}

	static const int Width = 640;
	static const int Height = 480;

	protected:
	void setupDefaultLanguage(const Context & context, const Menu & parent);
	virtual void openOptions();
	virtual void closeOptions();

	/! Context /
	Context context;

	/! Data holder /
	std::map<std::string, ValueHolder *> data;

	/! Renderer /
	Util::ReferenceCount<Renderer> renderer;

	/! load token /
	void load(const Token * token, const OptionFactory & factory);
	#if 0
	/*! Handle Override
	* There can only be one decleration of an override per file/token
	* The first one found will be the one executed.
	* If found it will return true so that the menu can handle it and avoid going to everything else
	*/
	virtual bool handleOverride(const Token *);
	#endif
	/! Do current version /
	virtual void handleCurrentVersion(const Token *);

	/! Prior token compatibility based on version Global::getVersion() /
	virtual void handleCompatibility(const Token *, int version, const OptionFactory & factory);

	/! Add Data /
	void addData(ValueHolder *);

	/! Keys /
	InputMap<Actions> input;

	/! Type /
	Renderer::Type type;

	/! Check type /
	virtual Util::ReferenceCount<Renderer> rendererType(const Renderer::Type &);
	std::vector<std::string> languages;
	};

	}
	#endif
	diff --git a/util/menu/options.cpp b/util/menu/options.cpp
	index ab03e14e..1347321b 100644
	--- a/util/menu/options.cpp
	+++ b/util/menu/options.cpp
	@@ -1,2663 +1,2700 @@
	#include "util/bitmap.h"
	#include "util/stretch-bitmap.h"
	#include "util/trans-bitmap.h"

	#include "options.h"
	#include "util/token.h"
	#include "util/input/input-source.h"
	#include "util/parameter.h"
	#include "util/tokenreader.h"
	#include "menu.h"
	#include "configuration.h"
	#include "menu-exception.h"
	#include "util/init.h"
	#include "util/events.h"
	#include "optionfactory.h"

	#include "util/music.h"

	#include "util/input/keyboard.h"
	#include "util/funcs.h"
	#include "util/file-system.h"
	#include "factory/font_factory.h"
	/* FIXME: its probably bad to depend on the top-level globals. Most of globals.h/cpp should
	* be moved to the utils directory.
	*/
	#include "globals.h"
	#include "util/exceptions/shutdown_exception.h"
	#include "util/exceptions/exception.h"
	#include "util/font.h"
	#include "util/gui/box.h"
	#include "util/thread.h"

	#include "util/loading.h"
	#include "util/fire.h"
	#include "util/input/input-map.h"
	#include "util/input/input-manager.h"

	#include <sstream>
	#include <algorithm>
	#include <time.h>
	#include <math.h>

	using namespace std;
	using namespace Gui;

	/* true if the arguments passed in match todays date.
	* pass 0 for any argument that you don't care about (it will match any date)
	*/
	static bool todaysDate(int month, int day, int year){
	time_t result = time(NULL);
	struct tm * local = localtime(&result);
	return (month == 0 \|\| month == (local->tm_mon + 1)) &&
	(day == 0 \|\| day == local->tm_mday) &&
	(year == 0 \|\| year == local->tm_year + 1900);
	}

	static bool jonBirthday(){
	return todaysDate(3, 25, 0);
	}

	static bool miguelBirthday(){
	return todaysDate(8, 11, 0);
	}

	OptionCredits::Block::Block(const std::string & title):
	title(title),
	titleColorOverride(false),
	titleColor(Graphics::makeColor(0,255,255)),
	colorOverride(false),
	color(Graphics::makeColor(255,255,255)),
	spacing(0){
	}

	OptionCredits::Block::Block(const Token * token):
	titleColorOverride(false),
	titleColor(Graphics::makeColor(0,255,255)),
	colorOverride(false),
	color(Graphics::makeColor(255,255,255)),
	topWidth(0),
	topHeight(0),
	bottomWidth(0),
	bottomHeight(0),
	spacing(0){
	if ( *token != "block" ){
	throw LoadException(__FILE__, __LINE__, "Not a credit block");
	}

	TokenView view = token->view();

	while (view.hasMore()){
	std::string match;
	try{
	const Token * tok;
	view >> tok;
	if ( *tok == "title" ) {
	tok->view() >> title;
	} else if (*tok == "credit"){
	std::string credit;
	tok->view() >> credit;
	credits.push_back(credit);
	} else if ( *tok == "titlecolor" ) {
	try{
	int r,b,g;
	tok->view() >> r >> g >> b;
	titleColor = Graphics::makeColor( r, g, b );
	titleColorOverride = true;
	} catch (const TokenException & ex){
	}
	} else if ( *tok == "color" ) {
	try{
	int r,b,g;
	tok->view() >> r >> g >> b;
	color = Graphics::makeColor( r, g, b );
	colorOverride = true;
	} catch (const TokenException & ex){
	}
	} else if ( *tok == "animation" ) {
	TokenView animView = tok->view();
	while (animView.hasMore()){
	const Token * animTok;
	animView >> animTok;
	if (*animTok == "top"){
	tok->match("_/width", topWidth);
	tok->match("_/height", topHeight);
	topAnimation = Util::ReferenceCount<Gui::Animation>(new Animation(tok));
	} else if (*animTok == "bottom"){
	tok->match("_/width", bottomWidth);
	tok->match("_/height", bottomHeight);
	bottomAnimation = Util::ReferenceCount<Gui::Animation>(new Animation(tok));
	}
	}
	} else if (*tok == "spacing"){
	tok->view() >> spacing;
	} else {
	Global::debug( 3 ) <<"Unhandled Credit Block attribute: "<<endl;
	if (Global::getDebug() >= 3){
	tok->print(" ");
	}
	}
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Credit Block parse error");
	} catch ( const LoadException & ex ) {
	throw ex;
	}
	}
	}

	OptionCredits::Block::Block(const OptionCredits::Block & copy):
	title(copy.title),
	credits(copy.credits),
	titleColorOverride(copy.titleColorOverride),
	titleColor(copy.titleColor),
	colorOverride(copy.colorOverride),
	color(copy.color),
	topAnimation(copy.topAnimation),
	topWidth(copy.topWidth),
	topHeight(copy.topHeight),
	bottomAnimation(copy.bottomAnimation),
	bottomWidth(copy.bottomWidth),
	bottomHeight(copy.bottomHeight),
	spacing(copy.spacing){
	}

	OptionCredits::Block::~Block(){
	}

	const OptionCredits::Block & OptionCredits::Block::operator=(const OptionCredits::Block & copy){
	title = copy.title;
	credits = copy.credits;
	titleColor = copy.titleColor;
	titleColorOverride = copy.titleColorOverride;
	color = copy.color;
	colorOverride = copy.colorOverride;
	topAnimation = copy.topAnimation;
	topWidth =copy.topWidth;
	topHeight = copy.topHeight;
	bottomAnimation = copy.bottomAnimation;
	bottomWidth = copy.bottomWidth;
	bottomHeight = copy.bottomHeight;
	spacing = copy.spacing;
	return *this;
	}

	void OptionCredits::Block::addCredit(const std::string & credit){
	credits.push_back(credit);
	}

	void OptionCredits::Block::act(){
	// Top animation
	if (topAnimation != NULL){
	topAnimation->act();
	}
	// Bottom animation
	if (bottomAnimation != NULL){
	bottomAnimation->act();
	}
	}

	int OptionCredits::Block::print(int x, int y, Graphics::Color defaultTitleColor, Graphics::Color defaultColor, const Font & font, const Graphics::Bitmap & work, const Justification & justification) const {
	int currentY = y;

	// Top animation
	if (topAnimation != NULL){
	int xmod = 0;
	switch (justification){
	default:
	case Left:
	xmod = 0;
	break;
	case Center:
	xmod = topWidth/2;
	break;
	case Right:
	xmod = topWidth;
	break;
	}
	// FIXME temporary solution
	const Graphics::Bitmap & temp = Graphics::Bitmap::temporaryBitmap(topWidth, topHeight);
	//topAnimation->draw(x - xmod, y, topWidth, topHeight, work);
	topAnimation->draw(0, 0, topWidth, topHeight, temp);
	temp.translucent().draw(x-xmod, y, work);
	currentY+=topHeight;
	}

	if (!title.empty()){
	int xmod = 0;
	switch (justification){
	default:
	case Left:
	xmod = 0;
	break;
	case Center:
	xmod = font.textLength(title.c_str())/2;
	break;
	case Right:
	xmod = font.textLength(title.c_str());
	break;
	}
	font.printf(x - xmod, currentY, (titleColorOverride ? titleColor : defaultTitleColor), work, title, 0);
	currentY += font.getHeight();
	}

	for (std::vector<std::string>::const_iterator i = credits.begin(); i != credits.end(); ++i){
	const std::string & credit = *i;
	int xmod = 0;
	switch (justification){
	default:
	case Left:
	xmod = 0;
	break;
	case Center:
	xmod = font.textLength(credit.c_str())/2;
	break;
	case Right:
	xmod = font.textLength(credit.c_str());
	break;
	}
	font.printf(x - xmod, currentY, (colorOverride ? color : defaultColor), work, credit, 0);
	currentY += font.getHeight();
	}

	// Bottom animation
	if (bottomAnimation != NULL){
	int xmod = 0;
	switch (justification){
	default:
	case Left:
	xmod = 0;
	break;
	case Center:
	xmod = bottomWidth/2;
	break;
	case Right:
	xmod = bottomWidth;
	break;
	}
	// FIXME temporary solution
	const Graphics::Bitmap & temp = Graphics::Bitmap::temporaryBitmap(topWidth, topHeight);
	//bottomAnimation->draw(x - xmod, y, bottomWidth, bottomHeight, work);
	bottomAnimation->draw(0, 0, bottomWidth, bottomHeight, temp);
	temp.translucent().draw(x-xmod, y, work);
	currentY+=bottomHeight;
	}

	currentY += font.getHeight() + spacing;

	return currentY;
	}

	const int OptionCredits::Block::size(const Font & font) const{
	// Counts title and space in between
	int total = 0;
	if (topAnimation != NULL){
	total += topHeight;
	}
	if (!title.empty()){
	total+= font.getHeight();
	}
	total += credits.size() * font.getHeight();
	if (bottomAnimation != NULL){
	total += bottomHeight;
	}
	total += font.getHeight();

	total += spacing;
	return total;
	}

	OptionCredits::Sequence::Sequence(const Token * token):
	type(Primary),
	x(0),
	y(0),
	startx(0),
	endx(0),
	starty(0),
	endy(0),
	ticks(0),
	duration(250),
	speed(0),
	alpha(0),
	alphaMultiplier(0),
	justification(Block::Center),
	current(0),
	done(false),
	creditLength(0){
	if ( *token != "sequence" ){
	throw LoadException(__FILE__, __LINE__, "Not a credit sequence");
	}

	TokenView view = token->view();

	while (view.hasMore()){
	std::string match;
	try{
	const Token * tok;
	view >> tok;
	if (*tok == "type"){
	std::string sequenceType;
	tok->view() >> sequenceType;
	if (sequenceType == "roll"){
	type = Roll;
	} else if (sequenceType == "primary"){
	type = Primary;
	}
	} else if (*tok == "start-x"){
	tok->view() >> startx;
	} else if (*tok == "end-x"){
	tok->view() >> endx;
	} else if (*tok == "start-y"){
	tok->view() >> starty;
	} else if (*tok == "end-y"){
	tok->view() >> endy;
	} else if (*tok == "duration"){
	tok->view() >> duration;
	} else if (*tok == "speed"){
	tok->view() >> speed;
	} else if (*tok == "alpha-multiplier"){
	tok->view() >> alphaMultiplier;
	} else if ( *tok == "justification" ) {
	std::string justify;
	tok->view() >> justify;
	if (justify == "left"){
	justification = Block::Left;
	} else if (justify == "center"){
	justification = Block::Center;
	} else if (justify == "right"){
	justification = Block::Right;
	}
	} else if (*tok == "block"){
	credits.push_back(Block(tok));
	} else {
	Global::debug( 3 ) <<"Unhandled Credit Sequence attribute: "<<endl;
	if (Global::getDebug() >= 3){
	tok->print(" ");
	}
	}
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Credit Sequence parse error");
	} catch ( const LoadException & ex ) {
	throw ex;
	}
	}

	// Initial
	reset();
	for (std::vector<OptionCredits::Block>::const_iterator i = credits.begin(); i != credits.end(); ++i){
	const OptionCredits::Block & block = *i;
	creditLength += block.size(Menu::menuFontParameter.current()->get());
	}
	}

	OptionCredits::Sequence::Sequence(const Sequence & copy):
	type(copy.type),
	x(copy.x),
	y(copy.y),
	startx(copy.startx),
	endx(copy.endx),
	starty(copy.starty),
	endy(copy.endy),
	ticks(copy.ticks),
	duration(copy.duration),
	speed(copy.speed),
	alpha(copy.alpha),
	alphaMultiplier(copy.alphaMultiplier),
	justification(copy.justification),
	credits(copy.credits),
	current(copy.current),
	done(false),
	creditLength(copy.creditLength){
	}

	OptionCredits::Sequence::~Sequence(){
	}

	const OptionCredits::Sequence & OptionCredits::Sequence::operator=(const OptionCredits::Sequence & copy){
	type = copy.type;
	x = copy.x;
	y = copy.y;
	startx = copy.startx;
	endx = copy.endx;
	starty = copy.starty;
	endy = copy.endy;
	ticks = copy.ticks;
	duration = copy.duration;
	speed = copy.speed;
	alpha = copy.alpha;
	alphaMultiplier = copy.alphaMultiplier;
	justification = copy.justification;
	credits = copy.credits;
	current = copy.current;
	done = false;
	creditLength = copy.creditLength;
	return *this;
	}

	static int alphaClamp(int x, double multiplier){
	int clamp = x * multiplier;
	if (clamp < 0){
	clamp = 0;
	} else if (clamp > 255){
	clamp = 255;
	}
	return clamp;
	}

	void OptionCredits::Sequence::act(){
	if (!done && !credits.empty()){
	if (type == Roll){
	y += speed;
	if (starty > endy){
	if ((y + (creditLength * 1.1)) < endy){
	done = true;
	}
	} else if (starty < endy){
	if ((y * 1.1) > endy){
	done = true;
	}
	}
	} else if (type == Primary){
	credits[current].act();
	if (startx != endx){
	x += speed;
	if (startx > endx){
	const double midpoint = (startx+endx)/2;
	const int mid = x > midpoint ? startx -x : x - endx;
	alpha = alphaClamp(mid, alphaMultiplier);
	if (x < endx){
	next();
	}
	} else if (startx < endx){
	const double midpoint = (startx+endx)/2;
	const int mid = x < midpoint ? x - startx : endx - x;
	alpha = alphaClamp(mid, alphaMultiplier);
	//Global::debug(0) << "alpha: " << alpha << " midpoint: " << midpoint << " mid: " << mid << std::endl;
	if (x > endx){
	next();
	}
	}
	} else {
	const double midpoint = duration/2;
	const int mid = ticks < midpoint ? ticks : duration - ticks;
	alpha = alphaClamp(mid, alphaMultiplier);
	ticks++;
	if (ticks >= duration){
	ticks = 0;
	next();
	}
	}
	}
	}
	}

	void OptionCredits::Sequence::draw(Graphics::Color title, Graphics::Color color, const Graphics::Bitmap & work){
	if (!done && !credits.empty()){
	if (type == Roll){
	int rollY = (int) y;
	for (std::vector<OptionCredits::Block>::const_iterator i = credits.begin(); i != credits.end(); ++i){
	const OptionCredits::Block & block = *i;
	rollY = block.print(x, rollY, title, color, Menu::menuFontParameter.current()->get(), work, justification);
	}
	} else if (type == Primary){
	Graphics::Bitmap::transBlender(0, 0, 0, alpha);
	credits[current].print(x, y, title, color, Menu::menuFontParameter.current()->get(), work.translucent(), justification);
	}
	}
	}

	void OptionCredits::Sequence::reset(){
	done = false;
	current = 0;
	ticks = 0;
	if (!credits.empty()){
	if (type == Roll){
	x = startx;
	y = starty;
	} else if (type == Primary){
	x = startx;
	y = starty - (credits[current].size(Menu::menuFontParameter.current()->get())/2);
	}
	}
	}

	void OptionCredits::Sequence::next(){
	if (type == Primary){
	if (current < credits.size()){
	current++;
	if (current == credits.size()){
	done = true;
	} else {
	x = startx;
	y = starty - (credits[current].size(Menu::menuFontParameter.current()->get())/2);
	}
	}
	}
	}

	static std::string defaultPositions(){
	const int width = Configuration::getScreenWidth();
	const int height = Configuration::getScreenHeight();
	std::ostringstream out;
	out << "(start-x " << width/2.3 << ") (end-x " << width/1.8 << ") (start-y " << height/2 << ") ";
	//out << "(start-x " << width/2 << ") (end-x " << width/2 << ") (start-y " << height/2 << ") (duration 250) ";
	return out.str();
	}

	OptionCredits::OptionCredits(const Gui::ContextBox & parent, const Token * token):
	MenuOption(parent, token),
	creditsContext(new Menu::Context()),
	music(""),
	color(Graphics::makeColor(255,255,255)),
	title(Graphics::makeColor(0,255,255)),
	clearColor(Graphics::makeColor(0,0,0)){
	std::string defaultSequence = "(sequence (type primary) (speed 0.3) (alpha-multiplier 20) (justification center) " + defaultPositions();

	/* Always */
	if (jonBirthday()){
	defaultSequence += "(block (title \"Happy birthday, Jon!\"))";
	}

	if (miguelBirthday()){
	defaultSequence += "(block (title \"Happy birthday, Jon!\"))";
	}
	defaultSequence += "(block (animation (top) (width 350) (height 65) (image 0 \"sprites/paintown.png\") (frame (image 0) (time -1))) (credit \"Version " + Global::getVersionString() + "\"))";

	defaultSequence += "(block (title \"Programming\") (credit \"Jon Rafkind\") (credit \"Miguel Gavidia\"))";

	defaultSequence += "(block (title \"Level design\") (credit \"Jon Rafkind\") (credit \"Miguel Gavidia\"))";

	defaultSequence += "(block (title \"Contact\") (credit \"Website: http://paintown.org\") (credit \"Email: jon@rafkind.com\")))";
	TokenReader reader;
	Sequence sequence(reader.readTokenFromString(defaultSequence));
	sequences.push_back(sequence);

	//Global::debug(0) << defaultSequence << std::endl;

	if ( *token != "credits" ){
	throw LoadException(__FILE__, __LINE__, "Not a credit menu");
	}

	readName(token);

	TokenView view = token->view();

	// NOTE Use this to handle legacy additional blocks for the time being
	Block legacyAdditional("");
	bool additionalTitle = true;

	while (view.hasMore()){
	try{
	const Token * tok;
	view >> tok;
	if ( *tok == "music" ) {
	/* Set music for credits */
	tok->view() >> music;
	} else if ( *tok == "background" ) {
	/* Create an image and push it back on to vector */
	std::string temp;
	tok->view() >> temp;
	creditsContext->addBackground(temp);
	} else if ( tok == "anim" \|\| tok == "animation" ){
	creditsContext->addBackground(tok);
	} else if ( *tok == "additional" ) {
	std::string str;
	TokenView additionalView = tok->view();
	while (additionalView.hasMore()){
	additionalView >> str;
	if (additionalTitle){
	legacyAdditional = Block(str);
	additionalTitle = false;
	} else {
	legacyAdditional.addCredit(str);
	}
	}
	} else if (*tok == "sequence"){
	sequences.push_back(OptionCredits::Sequence(tok));
	} else if ( *tok == "titlecolor" ) {
	int r,b,g;
	tok->view() >> r >> g >> b;
	title = Graphics::makeColor( r, g, b );
	} else if ( *tok == "color" ) {
	int r,b,g;
	tok->view() >> r >> g >> b;
	color = Graphics::makeColor( r, g, b );
	} else if ( *tok == "clear-color" ) {
	int r,b,g;
	tok->view() >> r >> g >> b;
	clearColor = Graphics::makeColor( r, g, b );
	} else {
	Global::debug( 3 ) <<"Unhandled menu attribute: "<<endl;
	if (Global::getDebug() >= 3){
	tok->print(" ");
	}
	}
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Menu parse error");
	} catch ( const LoadException & ex ) {
	throw ex;
	}
	}

	if (!legacyAdditional.empty()){
	//creditsRoll.push_back(legacyAdditional);
	}

	input.set(Keyboard::Key_ESC, 0, true, Exit);
	input.set(Joystick::Button2, 0, true, Exit);
	}

	OptionCredits::~OptionCredits(){
	}

	void OptionCredits::logic(){
	}

	class CreditsLogicDraw : public Util::Logic, public Util::Draw{
	public:
	CreditsLogicDraw(std::vector<OptionCredits::Sequence> & sequences, Graphics::Color clearColor, Graphics::Color title, Graphics::Color color, const Font & font, InputMap<OptionCredits::CreditKey> & input, Menu::Context & context):
	sequences(sequences),
	clearColor(clearColor),
	title(title),
	color(color),
	font(font),
	input(input),
	quit(false),
	context(context),
	current(0){
	}

	std::vector<OptionCredits::Sequence> & sequences;
	Graphics::Color clearColor, title, color;
	const Font & font;
	InputMap<OptionCredits::CreditKey> & input;
	bool quit;
	Menu::Context & context;
	unsigned int current;

	void run(){
	vector<InputMap<OptionCredits::CreditKey>::InputEvent> out = InputManager::getEvents(input, InputSource());
	for (vector<InputMap<OptionCredits::CreditKey>::InputEvent>::iterator it = out.begin(); it != out.end(); it++){
	const InputMap<OptionCredits::CreditKey>::InputEvent & event = *it;
	if (event.enabled){
	if (event.out == OptionCredits::Exit){
	quit = true;
	context.finish();
	}
	}
	}

	sequences[current].act();
	if (sequences[current].isDone()){
	sequences[current].reset();
	current++;
	if (current >= sequences.size()){
	current = 0;
	}
	}
	context.act();
	}

	bool done(){
	return quit;
	}

	double ticks(double system){
	return system * Global::ticksPerSecond(90);
	}

	void draw(const Graphics::Bitmap & buffer){
	/* FIXME: hard coded resolution */
	Graphics::StretchedBitmap work(640, 480, buffer, Graphics::qualityFilterName(Configuration::getQualityFilter()));
	work.fill(clearColor);
	work.start();
	//background.Blit(work);
	context.render(Util::ReferenceCount<Menu::Renderer>(NULL), work);

	sequences[current].draw(title, color, work);
	work.finish();

	buffer.BlitToScreen();
	}

	};

	void OptionCredits::run(const Menu::Context & context){
	Menu::Context localContext(context, *creditsContext);
	localContext.initialize();

	if (!music.empty()){
	if (Music::loadSong(Storage::instance().find(Filesystem::RelativePath(music)).path())){
	Music::pause();
	Music::play();
	}
	}

	const Font & vFont = Menu::menuFontParameter.current()->get();

	CreditsLogicDraw loop(sequences, clearColor, title, color, vFont, input, localContext);
	Util::standardLoop(loop, loop);

	InputManager::waitForRelease(input, InputSource(), Exit);
	throw Menu::Reload(__FILE__, __LINE__);
	}

	OptionDummy::OptionDummy(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token){
	if ( *token != "dummy" ){
	throw LoadException(__FILE__, __LINE__, "Not dummy option");
	}

	readName(token);

	if (getText().empty()){
	this->setText("Dummy");
	}

	setRunnable(false);
	}

	OptionDummy::OptionDummy(const Gui::ContextBox & parent, const std::string &name):
	MenuOption(parent, 0){
	if (name.empty()){
	throw LoadException(__FILE__, __LINE__, "No name given to dummy");
	}
	this->setText(name);


	setRunnable(false);
	}

	OptionDummy::~OptionDummy(){
	}

	void OptionDummy::logic(){
	}

	void OptionDummy::run(const Menu::Context & context){
	}

	OptionFullscreen::OptionFullscreen(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token),
	lblue(255),
	lgreen(255),
	rblue(255),
	rgreen(255){
	setRunnable(false);

	if ( *token != "fullscreen" )
	throw LoadException(__FILE__, __LINE__, "Not fullscreen option");

	readName(token);
	}

	OptionFullscreen::~OptionFullscreen()
	{
	// Nothing
	}

	std::string OptionFullscreen::getText() const {
	ostringstream out;
	out << MenuOption::getText() << ": " << (Configuration::getFullscreen() ? "Yes" : "No");
	return out.str();
	}

	void OptionFullscreen::logic(){;
	}

	static void changeScreenMode(){
	Configuration::setFullscreen(!Configuration::getFullscreen());
	int gfx = (Configuration::getFullscreen() ? Global::FULLSCREEN : Global::WINDOWED);
	Graphics::setGraphicsMode(gfx, Global::getScreenWidth(), Global::getScreenHeight());
	}

	void OptionFullscreen::run(const Menu::Context & context){
	changeScreenMode();
	}

	bool OptionFullscreen::leftKey(){
	changeScreenMode();
	return true;
	}
	bool OptionFullscreen::rightKey(){
	changeScreenMode();
	return true;
	}

	OptionFps::OptionFps(const Gui::ContextBox & parent, const Token * token):
	MenuOption(parent, token){
	readName(token);
	setRunnable(false);
	}

	void OptionFps::logic(){
	}

	void OptionFps::run(const Menu::Context & context){
	}

	std::string OptionFps::getText() const {
	ostringstream out;
	out << "Frames per second: " << Global::TICS_PER_SECOND;
	return out.str();
	}

	bool OptionFps::leftKey(){
	Global::setTicksPerSecond(Global::TICS_PER_SECOND - 1);
	Configuration::setFps(Global::TICS_PER_SECOND);
	return true;
	}

	bool OptionFps::rightKey(){
	Global::setTicksPerSecond(Global::TICS_PER_SECOND + 1);
	Configuration::setFps(Global::TICS_PER_SECOND);
	return true;
	}

	OptionFps::~OptionFps(){
	}

	OptionQualityFilter::OptionQualityFilter(const Gui::ContextBox & parent, const Token * token):
	MenuOption(parent, token){
	readName(token);
	setRunnable(false);
	}

	std::string OptionQualityFilter::getText() const {
	ostringstream out;
	out << MenuOption::getText() << ": " << Configuration::getQualityFilter();
	return out.str();
	}

	void OptionQualityFilter::logic(){
	}

	bool OptionQualityFilter::leftKey(){
	string quality = Configuration::getQualityFilter();
	if (quality == "none"){
	quality = "hqx";
	} else if (quality == "hqx"){
	quality = "xbr";
	} else if (quality == "xbr"){
	quality = "none";
	}
	Configuration::setQualityFilter(quality);
	return true;
	}

	bool OptionQualityFilter::rightKey(){
	string quality = Configuration::getQualityFilter();
	if (quality == "none"){
	quality = "xbr";
	} else if (quality == "hqx"){
	quality = "none";
	} else if (quality == "xbr"){
	quality = "hqx";
	}
	Configuration::setQualityFilter(quality);
	return true;

	}

	void OptionQualityFilter::run(const Menu::Context & context){
	}

	OptionQualityFilter::~OptionQualityFilter(){
	}

	OptionInvincible::OptionInvincible(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token),
	lblue(255),
	lgreen(255),
	rblue(255),
	rgreen(255){
	setRunnable(false);

	if ( *token != "invincible" )
	throw LoadException(__FILE__, __LINE__, "Not invincible option");

	readName(token);
	}

	OptionInvincible::~OptionInvincible()
	{
	// Nothing
	}

	std::string OptionInvincible::getText() const {
	ostringstream out;
	out << MenuOption::getText() << ": " << (Configuration::getInvincible() ? "Yes" : "No");
	return out.str();
	}

	void OptionInvincible::logic(){
	}

	void OptionInvincible::run(const Menu::Context & context){
	}

	bool OptionInvincible::leftKey(){
	Configuration::setInvincible(!Configuration::getInvincible());
	return true;
	}
	bool OptionInvincible::rightKey(){
	Configuration::setInvincible(!Configuration::getInvincible());
	return true;
	}

	#if 0
	static OptionJoystick::JoystickType convertToKey(const std::string &k){
	std::string temp = k;
	for(unsigned int i=0;i<temp.length();i++){
	temp[i] = tolower(temp[i]);
	}

	if (temp == "up") return OptionJoystick::Up;
	if (temp == "down") return OptionJoystick::Down;
	if (temp == "left") return OptionJoystick::Left;
	/*
	if (temp == "right") return OptionJoystick::Right;
	if (temp == "jump") return OptionJoystick::Jump;
	if (temp == "attack1") return OptionJoystick::Attack1;
	if (temp == "attack2") return OptionJoystick::Attack2;
	if (temp == "attack3") return OptionJoystick::Attack3;
	if (temp == "attack4") return OptionJoystick::Attack4;
	if (temp == "attack5") return OptionJoystick::Attack5;
	if (temp == "attack6") return OptionJoystick::Attack6;

	return OptionJoystick::Invalidkey;
	}

	static Configuration::JoystickInput getKey(int player, OptionJoystick::JoystickType k){
	switch(k){
	case OptionJoystick::Up:
	return Joystick::Up;
	case OptionJoystick::Down:
	return Joystick::Down;
	case OptionJoystick::Left:
	return Joystick::Left;
	case OptionJoystick::Right:
	return Joystick::Right;
	case OptionJoystick::Jump:
	return Joystick::Button4;
	case OptionJoystick::Attack1:
	return Joystick::Button1;
	case OptionJoystick::Attack2:
	return Joystick::Button2;
	case OptionJoystick::Attack3:
	return Joystick::Button3;
	case OptionJoystick::Attack4:
	return Joystick::Button4;
	case OptionJoystick::Attack5:
	return Joystick::Button5;
	case OptionJoystick::Attack6:
	return Joystick::Button6;
	default:
	break;
	}

	return Joystick::Up;
	}

	static void setKey(int player, OptionJoystick::JoystickType k, Configuration::JoystickInput key){
	/*
	switch(k){
	case OptionJoystick::Up:
	Configuration::setJoystickUp(player, key);
	break;
	case OptionJoystick::Down:
	Configuration::setJoystickDown(player, key);
	break;
	case OptionJoystick::Left:
	Configuration::setJoystickLeft(player, key);
	break;
	case OptionJoystick::Right:
	Configuration::setJoystickRight(player, key);
	break;
	case OptionJoystick::Jump:
	Configuration::setJoystickJump(player, key);
	break;
	case OptionJoystick::Attack1:
	Configuration::setJoystickAttack1(player, key);
	break;
	case OptionJoystick::Attack2:
	Configuration::setJoystickAttack2(player, key);
	break;
	case OptionJoystick::Attack3:
	Configuration::setJoystickAttack3(player, key);
	break;
	case OptionJoystick::Attack4:
	Configuration::setJoystickAttack4(player, key);
	break;
	case OptionJoystick::Attack5:
	Configuration::setJoystickAttack5(player, key);
	break;
	case OptionJoystick::Attack6:
	Configuration::setJoystickAttack6(player, key);
	break;
	default:
	break;
	}
	*/
	}

	static Configuration::JoystickInput readJoystick(){
	vector<Joystick::Key> keys;
	keys.push_back(Joystick::Up);
	keys.push_back(Joystick::Down);
	keys.push_back(Joystick::Left);
	keys.push_back(Joystick::Right);
	keys.push_back(Joystick::Button1);
	keys.push_back(Joystick::Button2);
	keys.push_back(Joystick::Button3);
	keys.push_back(Joystick::Button4);
	keys.push_back(Joystick::Button5);
	keys.push_back(Joystick::Button6);

	InputMap<Joystick::Key> input;
	for (vector<Joystick::Key>::iterator it = keys.begin(); it != keys.end(); it++){
	input.set(it, 0, true, it);
	}
	input.set(Keyboard::Key_ESC, 0, true, Joystick::Invalid);

	while (true){
	InputManager::poll();
	vector<InputMap<Joystick::Key>::InputEvent> out = InputManager::getEvents(input, InputSource());
	for (vector<InputMap<Joystick::Key>::InputEvent>::iterator it = out.begin(); it != out.end(); it++){
	const InputMap<Joystick::Key>::InputEvent & event = *it;
	if (event.enabled){
	Global::debug(1) << "Press: " << event.out << std::endl;
	if (event.out == Joystick::Invalid){
	InputManager::waitForRelease(input, InputSource(), Joystick::Invalid);
	throw Exception::Return(__FILE__, __LINE__);
	}
	return event.out;
	}
	}
	Util::rest(1);
	}

	/* control probably shouldn't get here.. */
	return Joystick::Up;
	}

	OptionJoystick::OptionJoystick(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token),
	name(""),
	player(-1),
	type(Invalidkey),
	keyCode(0){
	if (*token != "joystick"){
	throw LoadException(__FILE__, __LINE__, "Not joystick option");
	}

	TokenView view = token->view();
	while (view.hasMore()){
	try{
	const Token * tok;
	view >> tok;
	if ( *tok == "name" ){
	tok->view() >> name;
	} else if ( *tok == "player" ) {
	tok->view() >> player;
	} else if ( *tok == "type" ) {
	std::string temp;
	tok->view() >> temp;
	type = convertToKey(temp);
	} else {
	Global::debug( 3 ) <<"Unhandled menu attribute: "<<endl;
	tok->print(" ");
	}
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Menu parse error");
	} catch ( const LoadException & ex ) {
	// delete current;
	throw ex;
	}
	}

	if (name.empty()){
	throw LoadException(__FILE__, __LINE__, "No name set, this option should have a name!");
	}

	if (type == Invalidkey){
	throw LoadException(__FILE__, __LINE__, "Invalid joystick button, should be up, down, left, right, up, down, jump, attack1-6!");
	}

	if (player == -1){
	throw LoadException(__FILE__, __LINE__, "Player not specified in joystick configuration");
	}

	ostringstream out;
	out << name << ": " << Joystick::keyToName(getKey(player, type));
	setText(out.str());
	}

	OptionJoystick::~OptionJoystick(){
	// Nothing
	}

	void OptionJoystick::logic(){
	/*
	char temp[255];
	sprintf( temp, "%s: %s", name.c_str(), Joystick::keyToName(getKey(player,type)));
	setText(std::string(temp));
	*/
	}

	void OptionJoystick::run(const Menu::Context & context){
	/*
	//int x, y, width, height;
	const Font & vFont = Menu::menuFontParameter.current()->get();
	const char * message = "Press a joystick button!";
	const int width = vFont.textLength(message) + 10;
	const int height = vFont.getHeight() + 10;
	// const int x = (getParent()->getWork()->getWidth()/2) - (width/2);
	// const int y = (getParent()->getWork()->getHeight()/2) - (height/2);
	const int x = Menu::Menu::Width / 2 - width/2;
	const int y = Menu::Menu::Height / 2 - height/2;
	Box dialog;
	dialog.location.setPosition(Gui::AbsolutePoint(0,0));
	dialog.location.setDimensions(vFont.textLength(message) + 10, vFont.getHeight() + 10);
	dialog.transforms.setRadius(0);
	dialog.colors.body = Graphics::makeColor(0,0,0);
	dialog.colors.bodyAlpha = 200;
	dialog.colors.border = Graphics::makeColor(255,255,255);
	dialog.colors.borderAlpha = 255;
	Graphics::Bitmap temp = Graphics::Bitmap::temporaryBitmap(width,height);
	dialog.render(temp, vFont);
	vFont.printf( 5, 5, Graphics::makeColor(255,255,255), temp, message, -1);
	temp.BlitToScreen(x,y);

	setKey(player, type, readJoystick());

	ostringstream out;
	out << name << ": " << Joystick::keyToName(getKey(player, type));
	setText(out.str());
	*/

	Graphics::Bitmap temp(Menu::Menu::Width, Menu::Menu::Height);
	// Menu::Context tempContext = context;
	Menu::Context tempContext(context);
	tempContext.initialize();
	Menu::InfoBox keyDialog;
	// keyDialog.setFont(tempContext.getFont());
	//keyDialog.location.set(-1,-1,1,1);
	const int width = temp.getWidth();
	const int height = temp.getHeight();
	const Font & font = Menu::menuFontParameter.current()->get();
	const int radius = 15;
	keyDialog.setText("Press a joystick button!");
	keyDialog.initialize(font);
	keyDialog.location.setDimensions(font.textLength("Press a joystick button!") + radius, font.getHeight() + radius);
	keyDialog.location.setCenterPosition(Gui::RelativePoint(0, 0));
	// keyDialog.location.setPosition(Gui::AbsolutePoint((width/2)-(keyDialog.location.getWidth()/2), (height/2)-(keyDialog.location.getHeight()/2)));
	// keyDialog.location.setPosition2(Gui::AbsolutePoint((
	keyDialog.transforms.setRadius(radius);
	keyDialog.colors.body = Graphics::makeColor(0,0,0);
	keyDialog.colors.bodyAlpha = 180;
	keyDialog.colors.border = Graphics::makeColor(255,255,255);
	keyDialog.colors.borderAlpha = 255;
	keyDialog.open();
	InputManager::waitForClear();
	while (!InputManager::anyInput() && keyDialog.isActive()){
	InputManager::poll();
	keyDialog.act(font);
	/*
	if (keyDialog.isActive()){
	InputManager::poll();
	}
	*/
	tempContext.act();
	tempContext.render(0, temp);
	keyDialog.render(temp, font);
	temp.BlitToScreen();
	}
	tempContext.finish();
	setKey(player, type, readJoystick());
	InputManager::waitForClear();

	ostringstream out;
	out << name << ": " << Joystick::keyToName(getKey(player, type));
	setText(out.str());

	/*
	Keyboard key;
	keyCode = readKey(key);
	setKey(player,type, keyCode);
	*/
	}
	#endif

	static OptionKey::keyType convertToKeyboardKey(const std::string &k){
	std::string temp = k;
	for(unsigned int i=0;i<temp.length();i++){
	temp[i] = tolower(temp[i]);
	}
	if (temp == "up") return OptionKey::up;
	if (temp == "down") return OptionKey::down;
	if (temp == "left") return OptionKey::left;
	if (temp == "right") return OptionKey::right;
	if (temp == "jump") return OptionKey::jump;
	if (temp == "attack1") return OptionKey::attack1;
	if (temp == "attack2") return OptionKey::attack2;
	if (temp == "attack3") return OptionKey::attack3;
	if (temp == "attack4") return OptionKey::attack4;
	if (temp == "attack5") return OptionKey::attack5;
	if (temp == "attack6") return OptionKey::attack6;

	return OptionKey::invalidkey;
	}

	static int getKey(int player, OptionKey::keyType k){
	switch(k){
	case OptionKey::up:
	return Configuration::getUp(player);
	break;
	case OptionKey::down:
	return Configuration::getDown(player);
	break;
	case OptionKey::left:
	return Configuration::getLeft(player);
	break;
	case OptionKey::right:
	return Configuration::getRight(player);
	break;
	case OptionKey::jump:
	return Configuration::getJump(player);
	break;
	case OptionKey::attack1:
	return Configuration::getAttack1(player);
	break;
	case OptionKey::attack2:
	return Configuration::getAttack2(player);
	break;
	case OptionKey::attack3:
	return Configuration::getAttack3(player);
	break;
	case OptionKey::attack4:
	return Configuration::getAttack4(player);
	case OptionKey::attack5:
	return Configuration::getAttack5(player);
	case OptionKey::attack6:
	return Configuration::getAttack6(player);
	default:
	break;
	}

	return 0;
	}

	static void setKey(int player, OptionKey::keyType k, int key){
	switch(k){
	case OptionKey::up:
	Configuration::setUp(player, key);
	break;
	case OptionKey::down:
	Configuration::setDown(player, key);
	break;
	case OptionKey::left:
	Configuration::setLeft(player, key);
	break;
	case OptionKey::right:
	Configuration::setRight(player, key);
	break;
	case OptionKey::jump:
	Configuration::setJump(player, key);
	break;
	case OptionKey::attack1:
	Configuration::setAttack1(player, key);
	break;
	case OptionKey::attack2:
	Configuration::setAttack2(player, key);
	break;
	case OptionKey::attack3:
	Configuration::setAttack3(player, key);
	break;
	case OptionKey::attack4:
	Configuration::setAttack4(player, key);
	break;
	case OptionKey::attack5:
	Configuration::setAttack5(player, key);
	break;
	case OptionKey::attack6:
	Configuration::setAttack6(player, key);
	break;
	default:
	break;
	}
	}

	/*
	static int readKey( Keyboard & key ){
	int k = key.readKey();
	key.wait();
	return k;
	}
	*/

	OptionKey::OptionKey(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token),
	name(""),
	player(-1),
	type(invalidkey),
	keyCode(0){
	if ( *token != "key" )
	throw LoadException(__FILE__, __LINE__, "Not key option");

	TokenView view = token->view();
	while (view.hasMore()) {
	try {
	const Token * tok;
	view >> tok;
	if ( *tok == "name" ) {
	tok->view() >> name;
	} else if ( *tok == "player" ) {
	tok->view() >> player;
	} else if ( *tok == "type" ) {
	std::string temp;
	tok->view() >> temp;
	type = convertToKeyboardKey(temp);
	} else {
	Global::debug( 3 ) <<"Unhandled menu attribute: "<<endl;
	tok->print(" ");
	}
	} catch ( const TokenException & ex ){
	throw LoadException(__FILE__, __LINE__, ex, "Menu parse error");
	} catch ( const LoadException & ex ) {
	// delete current;
	throw ex;
	}
	}

	if(name.empty())throw LoadException(__FILE__, __LINE__, "No name set, this option should have a name!");
	if(type == invalidkey)throw LoadException(__FILE__, __LINE__, "Invalid key, should be up, down, left, right, up, down, jump, attack1-6!");
	if(player == -1)throw LoadException(__FILE__, __LINE__, "Player not specified in key configuration");

	char temp[255];
	sprintf( temp, "%s: %s", name.c_str(), Keyboard::keyToName(getKey(player,type)));
	setText(std::string(temp));
	}

	OptionKey::~OptionKey(){
	// Nothing
	}

	void OptionKey::logic(){
	char temp[255];
	sprintf( temp, "%s: %s", name.c_str(), Keyboard::keyToName(getKey(player,type)));
	setText(std::string(temp));
	}

	void OptionKey::run(const Menu::Context & context){
	// Do dialog
	//Box::messageDialog(Menu::Menu::Width, Menu::Menu::Height, "Press a Key!",2);

	/*
	Keyboard key;
	key.wait();
	*/
	Graphics::Bitmap temp(Menu::Menu::Width, Menu::Menu::Height);
	// Menu::Context tempContext = context;
	Menu::Context tempContext(context);
	tempContext.initialize();
	Menu::InfoBox keyDialog;
	// keyDialog.setFont(tempContext.getFont());
	//keyDialog.location.set(-1,-1,1,1);
	const int width = temp.getWidth();
	const int height = temp.getHeight();
	const Font & font = Menu::menuFontParameter.current()->get();
	const int radius = 15;
	keyDialog.setText("Press a Key!");
	keyDialog.initialize(font);
	keyDialog.location.setDimensions(font.textLength("Press a Key!") + radius, font.getHeight() + radius);
	keyDialog.location.setCenterPosition(Gui::RelativePoint(0, 0));
	// keyDialog.location.setPosition(Gui::AbsolutePoint((width/2)-(keyDialog.location.getWidth()/2), (height/2)-(keyDialog.location.getHeight()/2)));
	// keyDialog.location.setPosition2(Gui::AbsolutePoint((
	keyDialog.transforms.setRadius(radius);
	keyDialog.colors.body = Graphics::makeColor(0,0,0);
	keyDialog.colors.bodyAlpha = 180;
	keyDialog.colors.border = Graphics::makeColor(255,255,255);
	keyDialog.colors.borderAlpha = 255;
	keyDialog.open();
	InputManager::waitForClear();
	while (!InputManager::anyInput() && keyDialog.isActive()){
	InputManager::poll();
	keyDialog.act(font);
	/*
	if (keyDialog.isActive()){
	InputManager::poll();
	}
	*/
	tempContext.act();
	tempContext.render(Util::ReferenceCount<Menu::Renderer>(NULL), temp);
	keyDialog.render(temp, font);
	temp.BlitToScreen();
	}
	tempContext.finish();
	keyCode = InputManager::readKey();
	setKey(player,type, keyCode);
	InputManager::waitForClear();
	}

	OptionLevel::OptionLevel(const Gui::ContextBox & parent, const Token token, int set, int value):
	MenuOption(parent, token),
	set(set),
	value(value){
	// Nothing
	}

	OptionLevel::~OptionLevel(){
	}

	void OptionLevel::logic(){
	}

	void OptionLevel::run(const Menu::Context & context){
	*set = value;
	throw Menu::MenuException(__FILE__, __LINE__);
	}

	OptionLives::OptionLives(const Gui::ContextBox & parent, const Token * token):
	MenuOption(parent, token),
	lblue(255),
	lgreen(255),
	rblue(255),
	rgreen(255){
	setRunnable(false);

	if ( *token != "lives" ){
	throw LoadException(__FILE__, __LINE__, "Not lives option" );
	}

	readName(token);
	}

	OptionLives::~OptionLives(){
	}

	std::string OptionLives::getText() const {
	ostringstream out;
	out << MenuOption::getText() << ": " << Configuration::getLives();
	return out.str();
	}

	void OptionLives::logic(){

	}

	void OptionLives::run(const Menu::Context & context){
	}

	bool OptionLives::leftKey(){
	Configuration::setLives(Configuration::getLives() - 1);
	if ( Configuration::getLives() < 1 ){
	Configuration::setLives(1);
	}

	return false;
	}

	bool OptionLives::rightKey(){
	Configuration::setLives( Configuration::getLives() + 1 );

	return false;
	}

	OptionMenu::OptionMenu(const Gui::ContextBox & parent, const Token *token, const Menu::OptionFactory & factory):
	MenuOption(parent, token),
	menu(0){
	if (*token != "menu"){
	throw LoadException(__FILE__, __LINE__, "Not a menu");
	}

	if (token->numTokens() == 1){
	std::string temp;
	token->view() >> temp;
	menu = new Menu::Menu(Storage::instance().find(Filesystem::RelativePath(temp)), factory);
	} else {
	menu = new Menu::Menu(token, factory);
	}

	this->setText(menu->getName());
	this->setInfoText(menu->getInfo());

	// Lets check if this menu is going bye bye
	//if ( menu->checkRemoval() ) setForRemoval(true);
	}

	OptionMenu::~OptionMenu(){
	// Delete our menu
	if (menu){
	delete menu;
	}
	}

	void OptionMenu::logic(){
	// Nothing
	}

	void OptionMenu::run(const Menu::Context & context){
	// Do our new menu
	try{
	menu->run(context);
	} catch (const Exception::Return ignore){
	throw Menu::Reload(__FILE__, __LINE__);
	}
	}

	OptionNpcBuddies::OptionNpcBuddies(const Gui::ContextBox & parent, const Token * token):
	MenuOption(parent, token),
	lblue(255),
	lgreen(255),
	rblue(255),
	rgreen(255){
	setRunnable(false);

	if ( *token != "npc" ){
	throw LoadException(__FILE__, __LINE__, "Not npc option" );
	}

	readName(token);
	}

	OptionNpcBuddies::~OptionNpcBuddies(){
	// Nothing
	}

	std::string OptionNpcBuddies::getText() const {
	ostringstream out;
	out << MenuOption::getText() << ": " << Configuration::getNpcBuddies();
	return out.str();
	}

	void OptionNpcBuddies::logic(){

	}

	void OptionNpcBuddies::run(const Menu::Context & context){
	}

	bool OptionNpcBuddies::leftKey(){
	Configuration::setNpcBuddies(Configuration::getNpcBuddies() - 1);
	if ( Configuration::getNpcBuddies() < 1 ){
	Configuration::setNpcBuddies(1);
	}

	return false;
	}

	bool OptionNpcBuddies::rightKey(){
	Configuration::setNpcBuddies( Configuration::getNpcBuddies() + 1 );
	rblue = rgreen = 0;
	return false;
	}

	OptionPlayMode::OptionPlayMode(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token),
	lblue(255),
	lgreen(255),
	rblue(255),
	rgreen(255){
	setRunnable(false);

	if ( *token != "play-mode" ){
	throw LoadException(__FILE__, __LINE__, "Not a play-mode");
	}

	readName(token);
	}

	OptionPlayMode::~OptionPlayMode(){
	// Nothing
	}

	std::string OptionPlayMode::getText() const {
	ostringstream out;
	out << MenuOption::getText() << ": ";

	/* TODO: language translations of these */
	if (Configuration::getPlayMode() == Configuration::FreeForAll){
	out << "Free for all";
	} else if (Configuration::getPlayMode() == Configuration::Cooperative){
	out << "Cooperative";
	}

	return out.str();
	}

	void OptionPlayMode::logic(){

	}

	void OptionPlayMode::run(const Menu::Context & context){
	}

	void OptionPlayMode::changeMode(){
	if (Configuration::getPlayMode() == Configuration::FreeForAll){
	Configuration::setPlayMode(Configuration::Cooperative);
	} else if (Configuration::getPlayMode() == Configuration::Cooperative){
	Configuration::setPlayMode(Configuration::FreeForAll);
	}
	}

	bool OptionPlayMode::leftKey(){
	changeMode();
	lblue = lgreen = 0;
	return true;
	}

	bool OptionPlayMode::rightKey(){
	changeMode();
	rblue = rgreen = 0;
	return true;
	}

	OptionReturn::OptionReturn(const Gui::ContextBox & parent, const Token * token):
	MenuOption(parent, token){
	if (*token != "return"){
	throw LoadException(__FILE__, __LINE__, "Not a return option");
	}
	readName(token);
	}

	void OptionReturn::logic(){
	}

	/* maybe this option is misnamed, but its supposed to quit the current game
	* and go back to the main menu
	*/
	void OptionReturn::run(const Menu::Context & context){
	throw Exception::Quit(__FILE__, __LINE__);
	}

	OptionReturn::~OptionReturn(){
	}

	OptionContinue::OptionContinue(const Gui::ContextBox & parent, const Token * token):
	MenuOption(parent, token){
	if (*token != "continue"){
	throw LoadException(__FILE__, __LINE__, "Not a continue option");
	}
	readName(token);
	}

	void OptionContinue::logic(){
	}

	void OptionContinue::run(const Menu::Context & context){
	throw Exception::Return(__FILE__, __LINE__);
	}

	OptionContinue::~OptionContinue(){
	}

	OptionQuit::OptionQuit(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token){
	if ( *token != "quit" ){
	throw LoadException(__FILE__, __LINE__, "Not quit option");
	}

	readName(token);
	}

	OptionQuit::OptionQuit(const Gui::ContextBox & parent, const std::string &name):
	MenuOption(parent, 0){
	if (name.empty()){
	throw LoadException(__FILE__, __LINE__, "No name given to quit");
	}
	this->setText(name);
	}

	OptionQuit::~OptionQuit(){
	}

	void OptionQuit::logic(){
	}

	void OptionQuit::run(const Menu::Context & context){
	throw ShutdownException();
	}


	#if defined(WINDOWS) && defined(doesnt_work_yet)
	#include <windows.h>
	#include <stdio.h>

	/* contributed by Roy Underthump from allegro.cc */
	static vector<ScreenSize> getScreenResolutions(){
	HWND hwnd;
	HDC hdc;

	// int iPixelFormat;
	int descerr;
	int retval;

	DEVMODE d;

	PIXELFORMATDESCRIPTOR pfd;

	hwnd = GetDesktopWindow();
	hdc = GetDC(hwnd);

	vector<ScreenSize> modes;

	for (int i = 0;; i++){
	retval = EnumDisplaySettings(0,i,&d);
	if (!retval){
	break;
	}

	descerr = DescribePixelFormat(hdc, i+1, sizeof(pfd), &pfd);
	if(!descerr){
	continue;
	}

	/*
	printf("\n#%d bpp %d width %d height %d colorbits %d fps %d",i,d.dmBitsPerPel,
	d.dmPelsWidth, d.dmPelsHeight,pfd.cColorBits,d.dmDisplayFrequency);

	if(pfd.dwFlags & PFD_SUPPORT_OPENGL)printf(" OGL OK");
	*/
	modes.push_back(ScreenSize(d.dmPelsWidth, d.dmPelsHeight));
	}

	if (modes.empty()){
	modes.push_back(ScreenSize(640,480));
	}

	return modes;
	}
	#else
	static vector<ScreenSize> getScreenResolutions(){
	vector<ScreenSize> modes;
	modes.push_back(ScreenSize(320, 240));
	modes.push_back(ScreenSize(640, 480));
	modes.push_back(ScreenSize(800, 600));
	modes.push_back(ScreenSize(960, 720));
	modes.push_back(ScreenSize(1024, 768));
	modes.push_back(ScreenSize(1280, 960));
	modes.push_back(ScreenSize(1600, 1200));
	return modes;
	}
	#endif

	static bool doSort(const ScreenSize & a, const ScreenSize & b){
	return (a.w * a.h) < (b.w * b.h);
	}

	static vector<ScreenSize> sortResolutions(const vector<ScreenSize> & modes){
	vector<ScreenSize> copy(modes);
	std::sort(copy.begin(), copy.end(), doSort);
	return copy;
	}

	OptionScreenSize::OptionScreenSize(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token),
	name(""),
	lblue(255),
	lgreen(255),
	rblue(255),
	rgreen(255){
	setRunnable(false);

	Global::debug(1) << "Get screen resolution" << endl;
	modes = sortResolutions(getScreenResolutions());

	if (Global::getDebug() >= 1){
	for (vector<ScreenSize>::iterator it = modes.begin(); it != modes.end(); it++){
	Global::debug(1) << "Screen size: " << it->w << " x " << it->h << endl;
	}
	}

	if ( *token != "screen-size" ){
	throw LoadException(__FILE__, __LINE__, "Not a screen-size");
	}

	readName(token);
	}

	OptionScreenSize::~OptionScreenSize(){
	// Nothing
	}

	void OptionScreenSize::logic(){
	ostringstream temp;
	temp << "Screen size: " << Configuration::getScreenWidth() << " x " << Configuration::getScreenHeight();
	setText(temp.str());

	}

	void OptionScreenSize::run(const Menu::Context & context){
	}

	void OptionScreenSize::setMode(int width, int height){
	if (width != Configuration::getScreenWidth() \|\|
	height != Configuration::getScreenHeight()){

	Global::debug(1) << "Changing mode to " << width << " x " << height << endl;
	int gfx = Configuration::getFullscreen() ? Global::FULLSCREEN : Global::WINDOWED;
	int ok = Graphics::setGraphicsMode(gfx, width, height);
	if (ok == 0){
	Global::debug(1) << "Success" << endl;
	Configuration::setScreenWidth(width);
	Configuration::setScreenHeight(height);
	} else {
	Global::debug(1) << "Fail" << endl;
	int ok = Graphics::setGraphicsMode(gfx, Configuration::getScreenWidth(), Configuration::getScreenHeight());
	Global::debug(1) << "Set mode back " << ok << endl;
	}
	}
	}

	/*
	static int modes[][2] = {{640,480}, {800,600}, {1024,768}, {1280,1024}, {1600,1200}};
	// static int max_modes = sizeof(modes) / sizeof(int[]);
	static int max_modes = 5;
	*/

	int OptionScreenSize::findMode(int width, int height){
	for (int mode = 0; mode < (int) modes.size(); mode++){
	if (modes[mode].w == width && modes[mode].h == height){
	return mode;
	}
	}
	return -1;
	}

	bool OptionScreenSize::leftKey(){
	int mode = findMode(Configuration::getScreenWidth(), Configuration::getScreenHeight());
	if (mode >= 1 && mode < (int)modes.size()){
	mode -= 1;
	} else {
	mode = 0;
	}

	setMode(modes[mode].w, modes[mode].h);

	lblue = lgreen = 0;
	return true;
	}

	bool OptionScreenSize::rightKey(){
	int mode = findMode(Configuration::getScreenWidth(), Configuration::getScreenHeight());
	if (mode >= 0 && mode < (int)modes.size() - 1){
	mode += 1;
	} else {
	mode = 0;
	}

	setMode(modes[mode].w, modes[mode].h);

	rblue = rgreen = 0;
	return true;
	}

	static string joinPaths(const vector<Filesystem::AbsolutePath> & strings, const string & middle){
	ostringstream out;

	for (vector<Filesystem::AbsolutePath>::const_iterator it = strings.begin(); it != strings.end(); it++){
	out << (*it).path() << middle;
	}

	return out.str();
	}

	static bool sortInfo(const Util::ReferenceCount<Menu::FontInfo> & info1,
	const Util::ReferenceCount<Menu::FontInfo> & info2){
	string name1 = Util::lowerCaseAll(info1->getName());
	string name2 = Util::lowerCaseAll(info2->getName());
	return name1 < name2;
	}

	static bool isWindows(){
	#ifdef WINDOWS
	return true;
	#else
	return false;
	#endif
	}

	static bool isOSX(){
	#ifdef MACOSX
	return true;
	#else
	return false;
	#endif
	}

	template <class X>
	static vector<X> operator+(const vector<X> & v1, const vector<X> & v2){
	vector<X> out;
	for (typename vector<X>::const_iterator it = v1.begin(); it != v1.end(); it++){
	out.push_back(*it);
	}
	for (typename vector<X>::const_iterator it = v2.begin(); it != v2.end(); it++){
	out.push_back(*it);
	}
	return out;
	}

	static vector<Filesystem::AbsolutePath> findSystemFonts(){
	if (isWindows()){
	const char * windows = getenv("windir");
	if (windows != NULL){
	return Storage::instance().getFilesRecursive(Filesystem::AbsolutePath(string(windows) + "/fonts"), "*.ttf");
	}
	return vector<Filesystem::AbsolutePath>();
	} else if (isOSX()){
	return Storage::instance().getFilesRecursive(Filesystem::AbsolutePath("/Library/Fonts"), "*.ttf");
	} else {
	/* assume unix/linux conventions */
	return Storage::instance().getFilesRecursive(Filesystem::AbsolutePath("/usr/share/fonts/truetype"), "*.ttf") +
	Storage::instance().getFilesRecursive(Filesystem::AbsolutePath("/usr/local/share/fonts/truetype"), "*.ttf");

	}
	}

	static vector<Util::ReferenceCount<Menu::FontInfo> > findFonts(){
	vector<Util::ReferenceCount<Menu::FontInfo> > fonts;
	try{
	Filesystem::AbsolutePath fontsDirectory = Storage::instance().find(Filesystem::RelativePath("fonts"));
	Global::debug(1, "fonts") << "Font directory " << fontsDirectory.path() << endl;
	vector<Filesystem::AbsolutePath> ttfFonts = Storage::instance().getFiles(fontsDirectory, "*.ttf");
	Global::debug(1, "fonts") << "Found ttf fonts " << joinPaths(ttfFonts, ", ") << endl;
	vector<Filesystem::AbsolutePath> otfFonts = Storage::instance().getFiles(fontsDirectory, "*.otf");
	Global::debug(1, "fonts") << "Found otf fonts " << joinPaths(otfFonts, ", ") << endl;

	for (vector<Filesystem::AbsolutePath>::iterator it = ttfFonts.begin(); it != ttfFonts.end(); it++){
	fonts.push_back(Util::ReferenceCount<Menu::FontInfo>(new Menu::RelativeFontInfo(Storage::instance().cleanse(*it), Configuration::getMenuFontWidth(), Configuration::getMenuFontHeight())));
	}

	for (vector<Filesystem::AbsolutePath>::iterator it = otfFonts.begin(); it != otfFonts.end(); it++){
	fonts.push_back(Util::ReferenceCount<Menu::FontInfo>(new Menu::RelativeFontInfo(Storage::instance().cleanse(*it), Configuration::getMenuFontWidth(), Configuration::getMenuFontHeight())));
	}

	/* linux specific fonts */
	vector<Filesystem::AbsolutePath> systemFonts = findSystemFonts();
	for (vector<Filesystem::AbsolutePath>::iterator it = systemFonts.begin(); it != systemFonts.end(); it++){
	Global::debug(1) << "Adding system font `" << (*it).path() << "'" << endl;
	fonts.push_back(Util::ReferenceCount<Menu::FontInfo>(new Menu::AbsoluteFontInfo(*it, Configuration::getMenuFontWidth(), Configuration::getMenuFontHeight())));
	}

	sort(fonts.begin(), fonts.end(), sortInfo);

	// DEFAULT (blank)
	// fonts.insert(fonts.begin(), new Menu::DefaultFontInfo());
	fonts.insert(fonts.begin(), Util::ReferenceCount<Menu::FontInfo>(NULL));
	} catch (const Filesystem::NotFound & e){
	throw LoadException(__FILE__, __LINE__, e, "Could not load font");
	}

	return fonts;
	}

	OptionSelectFont::OptionSelectFont(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token),
	typeAdjust(fontName),
	lblue(255),
	lgreen(255),
	rblue(255),
	rgreen(255){
	setRunnable(false);

	if ( *token != "font-select" ){
	throw LoadException(__FILE__, __LINE__, "Not a font selector");
	}

	TokenView view = token->view();
	while (view.hasMore()){
	try{
	const Token * tok;
	view >> tok;
	if ( *tok == "adjust" ){
	std::string temp;
	tok->view() >> temp;
	if ( temp == "name" ) typeAdjust = fontName;
	else if ( temp == "width" ) typeAdjust = fontWidth;
	else if ( temp == "height" ) typeAdjust = fontHeight;
	else throw LoadException(__FILE__, __LINE__, "Incorrect value \"" + temp + "\" in font-select");
	} else {
	Global::debug(3) << "Unhandled menu attribute: " << endl;
	if (Global::getDebug() >= 3){
	tok->print(" ");
	}
	}
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Menu parse error");
	} catch ( const LoadException & ex ) {
	// delete current;
	throw ex;
	}
	}
	}

	void OptionSelectFont::open(){
	// Find and set fonts now
	if (typeAdjust == fontName){
	fonts = findFonts();
	}
	}

	void OptionSelectFont::close(){
	if (typeAdjust == fontName){
	/* the user probably loaded a bunch of different fonts that will
	* never be used again, so clear the font cache
	* TODO: dont clear the currently selected font
	*/
	FontFactory::clear();
	}
	}

	OptionSelectFont::~OptionSelectFont(){
	// Nothing
	}

	void OptionSelectFont::logic(){
	/* FIXME Get current font and display info */
	switch (typeAdjust){
	case fontName:{
	std::string name;
	if (Configuration::hasMenuFont()){
	name = Configuration::getMenuFont()->getName();
	} else {
	name = "Default";
	}
	setText("Current Font: " + name);
	break;
	}
	case fontWidth:{
	ostringstream temp;
	temp << "Font Width: " << Configuration::getMenuFontWidth();
	setText(temp.str());
	break;
	}
	case fontHeight:{
	ostringstream temp;
	temp << "Font Height: " << Configuration::getMenuFontHeight();
	setText(temp.str());
	break;
	}
	default: break;
	}
	if (lblue < 255){
	lblue += 5;
	}

	if (rblue < 255){
	rblue += 5;
	}

	if (lgreen < 255){
	lgreen += 5;
	}

	if (rgreen < 255){
	rgreen += 5;
	}
	}

	void OptionSelectFont::run(const Menu::Context & context){
	// throw Menu::MenuException(__FILE__, __LINE__);
	/* throw something to quit back to the previous menu */
	}

	bool OptionSelectFont::leftKey(){
	switch (typeAdjust){
	case fontName:
	nextIndex(false);
	break;
	case fontWidth:
	Configuration::setMenuFontWidth(Configuration::getMenuFontWidth() - 1);
	break;
	case fontHeight:
	Configuration::setMenuFontHeight(Configuration::getMenuFontHeight() - 1);
	break;
	default:
	break;
	}
	lblue = lgreen = 0;
	return true;
	}

	bool OptionSelectFont::rightKey(){
	switch (typeAdjust){
	case fontName:
	nextIndex(true);
	break;
	case fontWidth:
	Configuration::setMenuFontWidth(Configuration::getMenuFontWidth() + 1);
	break;
	case fontHeight:
	Configuration::setMenuFontHeight(Configuration::getMenuFontHeight() + 1);
	break;
	default:
	break;
	}
	rblue = rgreen = 0;
	return true;
	}

	static bool saneFont(const Util::ReferenceCount<Menu::FontInfo> & info){
	class Context: public Loader::LoadingContext {
	public:
	Context(const Util::ReferenceCount<Menu::FontInfo> & info):
	info(info),
	isok(false){
	}

	bool ok(){
	try{
	const Font & font = info->get();
	return font.textLength("A") != 0 &&
	font.getHeight() != 0;
	} catch (const Exception::Base & ignore){
	return true;
	}
	}

	virtual void load(){
	isok = ok();
	}

	const Util::ReferenceCount<Menu::FontInfo> & info;
	bool isok;
	};

	if (info == NULL){
	return true;
	}

	Context context(info);
	/* an empty Info object, we don't really care about it */
	Loader::Info level;
	Loader::loadScreen(context, level, Loader::SimpleCircle);
	return context.isok;
	}

	void OptionSelectFont::nextIndex(bool forward){
	if (fonts.size() == 0){
	return;
	}

	int index = 0;
	for (unsigned int i = 0 ; i < fonts.size() ; ++i){
	if ((Configuration::getMenuFont() == NULL && fonts[i] == NULL) \|\|
	((Configuration::getMenuFont() != NULL && fonts[i] != NULL) &&
	(Configuration::getMenuFont() == fonts[i]))){
	index = i;
	}
	}

	if (forward){
	index++;
	if (index >= (int) fonts.size()){
	index = 0;
	}
	} else {
	index--;
	if (index < 0){
	index = (int)fonts.size()-1;
	}
	}

	while (!saneFont(fonts[index])){
	Global::debug(0) << "Warning: erasing font `" << fonts[index]->getName() << "'" << endl;
	int where = 0;
	vector<Util::ReferenceCount<Menu::FontInfo> >::iterator it;
	for (it = fonts.begin(); it != fonts.end() && where != index; it++, where++){
	}
	fonts.erase(it);
	if (index >= (int) fonts.size()){
	index = fonts.size() - 1;
	}
	}

	Configuration::setMenuFont(fonts[index]);

	/* FIXME */
	/*
	if (fonts[index] == "Default"){
	Configuration::setMenuFont("");
	} else {
	Configuration::setMenuFont(fonts[index]);
	}
	*/
	}

	OptionSpeed::OptionSpeed(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token),
	name(""),
	lblue(255),
	lgreen(255),
	rblue(255),
	rgreen(255){
	setRunnable(false);

	if ( *token != "speed" )
	throw LoadException(__FILE__, __LINE__, "Not speed option");

	readName(token);
	}

	OptionSpeed::~OptionSpeed(){
	// Nothing
	}


	std::string OptionSpeed::getText() const {
	ostringstream out;
	out << MenuOption::getText() << ": " << Configuration::getGameSpeed();
	return out.str();
	}

	void OptionSpeed::logic(){
	/*
	//ostringstream temp;
	char temp[255];
	sprintf( temp, "%s: %0.2f", name.c_str(), MenuGlobals::getGameSpeed() );
	setText(std::string(temp));
	*/

	}

	void OptionSpeed::run(const Menu::Context & context){
	}

	bool OptionSpeed::leftKey(){
	Configuration::setGameSpeed(Configuration::getGameSpeed() - 0.05);
	if (Configuration::getGameSpeed() < 0.1){
	Configuration::setGameSpeed(0.1);
	}
	return false;
	}
	bool OptionSpeed::rightKey(){
	Configuration::setGameSpeed(Configuration::getGameSpeed() + 0.05);
	rblue = rgreen = 0;
	return false;
	}

	OptionTabMenu::OptionTabMenu(const Gui::ContextBox & parent, const Token *token, const Menu::OptionFactory & factory):
	MenuOption(parent, token),
	menu(0){
	if (token->numTokens() == 1){
	std::string temp;
	token->view() >> temp;
	menu = new Menu::Menu(Storage::instance().find(Filesystem::RelativePath(temp)), factory, Menu::Renderer::Tabbed);
	} else {
	menu = new Menu::Menu(token, factory, Menu::Renderer::Tabbed);
	}

	// this->setText(menu->getName());
	// token->print("Menu: ");
	const Token * tok = token->findToken("_/name");
	if (tok != NULL){
	std::string name;
	tok->view() >> name;
	// Global::debug(0, "menu") << "Menu name: " << name << endl;
	this->setText(name);
	} else {
	// No name?
	throw LoadException(__FILE__, __LINE__, "Menu has no name");
	}
	}

	OptionTabMenu::~OptionTabMenu(){
	// Delete our menu
	if (menu){
	delete menu;
	}
	}

	void OptionTabMenu::logic(){
	// Nothing
	}

	void OptionTabMenu::run(const Menu::Context & context){
	// Do our new menu
	// menu->run(context);
	try{
	menu->run(context);
	} catch (const Exception::Return ignore){
	throw Menu::Reload(__FILE__, __LINE__);
	}
	}

	OptionSound::OptionSound(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token),
	lblue(255),
	lgreen(255),
	rblue(255),
	rgreen(255){
	setRunnable(false);

	if (*token != "sound" ){
	throw LoadException(__FILE__, __LINE__, "Not a sound option");
	}

	readName(token);
	originalName = getName();
	}

	OptionSound::~OptionSound(){
	}

	void OptionSound::logic(){
	ostringstream temp;
	temp << originalName << ": " << Configuration::getSoundVolume();
	setText(temp.str());
	}

	void OptionSound::run(const Menu::Context & context){
	}

	void OptionSound::changeSound(int much){
	int volume = Configuration::getSoundVolume();
	volume += much;
	if (volume < 0){
	volume = 0;
	}

	if (volume > 100){
	volume = 100;
	}

	Configuration::setSoundVolume(volume);
	}

	bool OptionSound::leftKey(){
	changeSound(-1);

	lblue = lgreen = 0;
	return true;
	}

	bool OptionSound::rightKey(){
	changeSound(+1);

	rblue = rgreen = 0;
	return true;
	}

	OptionMusic::OptionMusic(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token),
	lblue(255),
	lgreen(255),
	rblue(255),
	rgreen(255){
	setRunnable(false);

	if (*token != "music" ){
	throw LoadException(__FILE__, __LINE__, "Not a music option");
	}

	readName(token);
	originalName = getName();
	}

	void OptionMusic::logic(){
	ostringstream temp;
	temp << originalName << ": " << Configuration::getMusicVolume();
	setText(temp.str());
	}

	void OptionMusic::run(const Menu::Context & context){
	}

	void OptionMusic::changeMusic(int much){
	int volume = Configuration::getMusicVolume();
	volume += much;
	if (volume < 0){
	volume = 0;
	}

	if (volume > 100){
	volume = 100;
	}

	Configuration::setMusicVolume(volume);
	Music::setVolume((double) volume / 100.0);
	}

	bool OptionMusic::leftKey(){
	changeMusic(-1);

	lblue = lgreen = 0;
	return true;
	}

	bool OptionMusic::rightKey(){
	changeMusic(+1);

	lblue = lgreen = 0;
	return true;
	}

	OptionMusic::~OptionMusic(){
	}

	OptionLanguage::OptionLanguage(const Gui::ContextBox & parent, const Token * token):
	MenuOption(parent, token){
	readName(token);
	#if 0
	const Token * start = token->getRootParent();
	vector<const Token> tokens = start->findTokens("/language");
	vector<string> all;
	for (vector<const Token*>::iterator it = tokens.begin(); it != tokens.end(); it++){
	string language;
	const Token * token = *it;
	if (token->match("language", language)){
	all.push_back(language);
	}
	}
	sort(all.begin(), all.end());
	unique_copy(all.begin(), all.end(), back_insert_iterator<vector<string> >(languages));
	// Global::debug(0) << "Found " << languages.size() << " languages" << endl;
	#endif
	}

	void OptionLanguage::run(const Menu::Context & context){
	class LanguageOption: public MenuOption {
	public:
	LanguageOption(const Gui::ContextBox & parent, const string & language):
	MenuOption(parent, NULL){
	setText(language);
	setInfoText(language);
	}

	virtual void logic(){
	}

	virtual void run(const ::Menu::Context & context){
	Configuration::setLanguage(getText());
	Configuration::saveConfiguration();
	throw ::Menu::MenuException(__FILE__, __LINE__);
	}
	};

	Util::NewReferenceCount<Menu::DefaultRenderer> renderer;
	Menu::Menu temp(renderer.convert<Menu::Renderer>());
	Util::ReferenceCount<Menu::FontInfo> info(new Menu::RelativeFontInfo(Global::DEFAULT_FONT, 24, 24));
	temp.setFont(info);

	const Gui::ContextBox & box = renderer->getBox();

	vector<string> languages = context.getLanguages();
	for (vector<string>::iterator it = languages.begin(); it != languages.end(); it++){
	temp.addOption(new LanguageOption(box, *it));
	}

	try {
	temp.run(context);
	} catch (const Exception::Return & ignore){
	} catch (const Menu::MenuException & ex){
	}

	throw Menu::Reload(__FILE__, __LINE__);
	// throw Exception::Return(__FILE__, __LINE__);
	}

	void OptionLanguage::logic(){
	}

	OptionGibs::OptionGibs(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token){
	setRunnable(false);

	if (*token != "gibs" ){
	throw LoadException(__FILE__, __LINE__, "Not a gibs option");
	}

	readName(token);
	originalName = getName();
	}

	void OptionGibs::logic(){
	ostringstream temp;
	/* FIXME: we want to use Gib::GibProperty here but that would necessitate a
	* dependancy on the Paintown engine.
	*/
	temp << originalName << ": " << Configuration::getProperty("paintown/gibs", 5);
	setText(temp.str());
	}

	void OptionGibs::run(const Menu::Context & context){
	}

	void OptionGibs::changeGibs(int much){
	int gibs = Configuration::getProperty("paintown/gibs", 5);
	gibs += much;
	if (gibs < 0){
	gibs = 0;
	}

	if (gibs > 10){
	gibs = 10;
	}

	Configuration::setProperty("paintown/gibs", gibs);
	}

	bool OptionGibs::leftKey(){
	changeGibs(-1);
	return true;
	}

	bool OptionGibs::rightKey(){
	changeGibs(+1);
	return true;
	}

	OptionGibs::~OptionGibs(){
	}

	OptionJoystick::OptionJoystick(const Gui::ContextBox & parent, const Token *token):
	MenuOption(parent, token){
	setRunnable(true);

	if (*token != "joystick" ){
	throw LoadException(__FILE__, __LINE__, "Not a joystick option");
	}

	readName(token);
	}

	void OptionJoystick::logic(){
	}

	class JoystickLogicDraw: public Util::Logic, public Util::Draw {
	public:
	enum Inputs{
	Exit
	};

	- JoystickLogicDraw(const Util::ReferenceCount<Joystick> & joystick):
	+ JoystickLogicDraw(const Util::ReferenceCount<Joystick> & joystick, const ::Menu::Context & context):
	joystick(joystick),
	- quit(false){
	+ quit(false),
	+ context(context, Menu::Context()){
	input.set(Keyboard::Key_ESC, Exit);
	}

	Util::ReferenceCount<Joystick> joystick;
	bool quit;
	+ Menu::Context context;
	InputMap<Inputs> input;

	void doInput(){
	vector<InputMap<Inputs>::InputEvent> out = InputManager::getEvents(input, InputSource());
	for (vector<InputMap<Inputs>::InputEvent>::iterator it = out.begin(); it != out.end(); it++){
	const InputMap<Inputs>::InputEvent & event = *it;
	if (event.enabled){
	if (event.out == Exit){
	quit = true;
	// context.finish();
	}
	}
	}
	}

	virtual void run(){
	doInput();
	+ context.act();
	}

	bool done(){
	return quit;
	}

	double ticks(double system){
	return system * Global::ticksPerSecond(60);
	}
	+
	+ void drawButtons(const Font & font, const Graphics::Bitmap & buffer){
	+ int y = 30;
	+ Graphics::Color color = Graphics::makeColor(255, 255, 255);
	+ font.printf(1, y, color, buffer, "Up: ", 0); y += font.getHeight() + 5;
	+ font.printf(1, y, color, buffer, "Down: ", 0); y += font.getHeight() + 5;
	+ font.printf(1, y, color, buffer, "Left: ", 0); y += font.getHeight() + 5;
	+ font.printf(1, y, color, buffer, "Right: ", 0); y += font.getHeight() + 5;
	+ font.printf(1, y, color, buffer, "Button1: ", 0); y += font.getHeight() + 5;
	+ font.printf(1, y, color, buffer, "Button2: ", 0); y += font.getHeight() + 5;
	+ font.printf(1, y, color, buffer, "Button3: ", 0); y += font.getHeight() + 5;
	+ font.printf(1, y, color, buffer, "Button4: ", 0); y += font.getHeight() + 5;
	+ font.printf(1, y, color, buffer, "Button5: ", 0); y += font.getHeight() + 5;
	+ font.printf(1, y, color, buffer, "Button6: ", 0); y += font.getHeight() + 5;
	+ font.printf(1, y, color, buffer, "Select: ", 0); y += font.getHeight() + 5;
	+ font.printf(1, y, color, buffer, "Quit: ", 0); y += font.getHeight() + 5;
	+ }

	void draw(const Graphics::Bitmap & buffer){
	+ const Font & font = Menu::menuFontParameter.current()->get();
	+ Graphics::StretchedBitmap work(640, 480, buffer, Graphics::qualityFilterName(Configuration::getQualityFilter()));
	+ work.start();
	+ context.renderBackground(buffer);
	+ font.printf(1, 1, Graphics::makeColor(255, 255, 255), buffer, "Joystick: %s", 0, joystick->getName().c_str());
	+
	+ drawButtons(font, buffer);
	+ context.renderForeground(buffer);
	+
	+ work.finish();
	+
	+ buffer.BlitToScreen();
	+
	+ /*
	+ Util::ReferenceCount<FontInfo> font = context.getFont();
	+ Font & font = font.get();
	+ */
	}
	};

	void OptionJoystick::run(const Menu::Context & context){
	class JoystickOption: public MenuOption {
	public:
	JoystickOption(const Gui::ContextBox & parent, int id, const Util::ReferenceCount<Joystick> & joystick):
	MenuOption(parent, NULL),
	joystick(joystick){
	ostringstream out;
	out << "Joystick " << (id + 1);
	setText(out.str());
	setInfoText(joystick->getName());
	}

	const Util::ReferenceCount<Joystick> joystick;

	virtual void logic(){
	}

	virtual void run(const ::Menu::Context & context){
	- JoystickLogicDraw mainLoop(joystick);
	+ JoystickLogicDraw mainLoop(joystick, context);
	Util::standardLoop(mainLoop, mainLoop);
	throw ::Menu::MenuException(__FILE__, __LINE__);
	}
	};

	Util::NewReferenceCount<Menu::DefaultRenderer> renderer;
	Menu::Menu menu(renderer.convert<Menu::Renderer>());
	/*
	Util::ReferenceCount<Menu::FontInfo> info(new Menu::RelativeFontInfo(Global::DEFAULT_FONT, 24, 24));
	temp.setFont(info);
	*/

	Gui::ContextBox & box = renderer->getBox();
	box.setListType(ContextBox::Normal);

	map<int, Util::ReferenceCount<Joystick> > joysticks = InputManager::getJoysticks();
	for (map<int, Util::ReferenceCount<Joystick> >::iterator it = joysticks.begin(); it != joysticks.end(); it++){
	menu.addOption(new JoystickOption(box, it->first, it->second));
	}

	if (joysticks.size() == 0){
	menu.addOption(new OptionDummy(box, "No joysticks found!"));
	}

	try {
	menu.run(context);
	} catch (const Exception::Return & ignore){
	} catch (const Menu::MenuException & ex){
	}
	}

	OptionJoystick::~OptionJoystick(){
	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Jan 30, 2:55 PM (5 d, 11 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55415
Default Alt Text: (235 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions