No OneTemporary
Actions

Authored By

Unknown

Size

108 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/Addons.cpp b/src/Addons.cpp
	index dea094a..5f7cc54 100644
	--- a/src/Addons.cpp
	+++ b/src/Addons.cpp
	@@ -1,586 +1,583 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#include "Addons.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "Objects.h"
	#include "GUIObject.h"
	#include "GUIScrollBar.h"
	#include "GUIListBox.h"
	#include "POASerializer.h"
	#include "InputManager.h"
	#include <string>
	#include <sstream>
	#include <iostream>
	#include <SDL/SDL_ttf.h>
	#include <SDL/SDL.h>
	using namespace std;

	Addons::Addons(){
	//Render the title.
	SDL_Color black={0,0,0};
	title=TTF_RenderUTF8_Blended(fontTitle,_("Addons"),black);

	FILE* addon=fopen((getUserPath(USER_CACHE)+"addons").c_str(),"wb");
	action=NONE;

	addons=NULL;

	//Create the gui.
	GUIObject* obj;
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//Try to get(download) the addonsList.
	if(getAddonsList(addon)==false) {
	//It failed so we show the error message.
	GUIObjectRoot=new GUIObject(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	obj=new GUIObject(90,96,200,32,GUIObjectLabel,_("Unable to initialze addon menu:"));
	obj->name="lbl";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(120,130,200,32,GUIObjectLabel,error.c_str());
	obj->name="lbl";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(90,550,200,32,GUIObjectButton,_("Back"));
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	return;
	}

	//Downloaded the addons file now we can create the GUI.
	GUIObjectRoot=new GUIObject(0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//Create list of categories
	GUISingleLineListBox *listTabs=new GUISingleLineListBox((SCREEN_WIDTH-360)/2,100,360,36);
	listTabs->name="lstTabs";
	listTabs->item.push_back(_("Levels"));
	listTabs->item.push_back(_("Level Packs"));
	listTabs->item.push_back(_("Themes"));
	listTabs->value=0;
	listTabs->eventCallback=this;
	GUIObjectRoot->childControls.push_back(listTabs);

	//Create the list for the addons.
	//By default levels will be selected.
	list=new GUIListBox(SCREEN_WIDTH0.1,160,SCREEN_WIDTH0.8,SCREEN_HEIGHT-220);
	list->item=addonsToList("levels");
	list->name="lstAddons";
	list->eventCallback=this;
	list->value=-1;
	GUIObjectRoot->childControls.push_back(list);
	type="levels";

	//And the buttons at the bottom of the screen.
	- obj=new GUIObject(SCREEN_WIDTH*0.3,SCREEN_HEIGHT-50,-1,32,GUIObjectButton,_("Back"),GUIGravityCenter);
	+ obj=new GUIObject(SCREEN_WIDTH*0.3,SCREEN_HEIGHT-50,-1,32,GUIObjectButton,_("Back"),0,true,true,GUIGravityCenter);
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	- actionButton=new GUIObject(SCREEN_WIDTH*0.7,SCREEN_HEIGHT-50,-1,32,GUIObjectButton,_("Uninstall"),GUIGravityCenter);
	+ actionButton=new GUIObject(SCREEN_WIDTH*0.7,SCREEN_HEIGHT-50,-1,32,GUIObjectButton,_("Uninstall"),0,false,true,GUIGravityCenter);
	actionButton->name="cmdInstall";
	actionButton->eventCallback=this;
	- actionButton->enabled=false;
	GUIObjectRoot->childControls.push_back(actionButton);
	- updateButton=new GUIObject(SCREEN_WIDTH*0.5,SCREEN_HEIGHT-50,-1,32,GUIObjectButton,_("Update"),GUIGravityCenter);
	+ updateButton=new GUIObject(SCREEN_WIDTH*0.5,SCREEN_HEIGHT-50,-1,32,GUIObjectButton,_("Update"),0,false,false,GUIGravityCenter);
	updateButton->name="cmdUpdate";
	- updateButton->enabled=false;
	- updateButton->visible=false;
	updateButton->eventCallback=this;
	GUIObjectRoot->childControls.push_back(updateButton);
	}

	Addons::~Addons(){
	delete addons;

	//Free the title surface.
	SDL_FreeSurface(title);

	//If the GUIObjectRoot exist delete it.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}

	bool Addons::getAddonsList(FILE* file){
	//First we download the file.
	if(downloadFile("http://meandmyshadow.sourceforge.net/game/addons03",file)==false){
	error="ERROR: unable to download addons file!";
	cerr<<error<<endl;
	return false;
	}
	fclose(file);

	//Load the downloaded file.
	ifstream addonFile;
	addonFile.open((getUserPath(USER_CACHE)+"addons").c_str());

	if(addonFile==false) {
	error="ERROR: unable to load addon_list file!";
	cerr<<error<<endl;
	return false;
	}

	//Parse the addonsfile.
	TreeStorageNode obj;
	{
	POASerializer objSerializer;
	if(!objSerializer.readNode(addonFile,&obj,true)){
	error="ERROR: Invalid file format of addons file!";
	cerr<<error<<endl;
	return false;
	}
	}

	//Also load the installed_addons file.
	ifstream iaddonFile;
	iaddonFile.open((getUserPath(USER_CONFIG)+"installed_addons").c_str());

	if(!iaddonFile) {
	//The installed_addons file doesn't exist, so we create it.
	ofstream iaddons;
	iaddons.open((getUserPath(USER_CONFIG)+"installed_addons").c_str());
	iaddons<<" "<<endl;
	iaddons.close();

	//Also load the installed_addons file.
	iaddonFile.open((getUserPath(USER_CONFIG)+"installed_addons").c_str());
	if(!iaddonFile) {
	error="ERROR: Unable to create the installed_addons file.";
	cerr<<error<<endl;
	return false;
	}
	}

	//And parse the installed_addons file.
	TreeStorageNode obj1;
	{
	POASerializer objSerializer;
	if(!objSerializer.readNode(iaddonFile,&obj1,true)){
	error="ERROR: Invalid file format of the installed_addons!";
	cerr<<error<<endl;
	return false;
	}
	}


	//Fill the vector.
	addons = new std::vector<Addon>;
	fillAddonList(*addons,obj,obj1);

	//Close the files.
	iaddonFile.close();
	addonFile.close();
	return true;
	}

	void Addons::fillAddonList(std::vector<Addons::Addon> &list, TreeStorageNode &addons, TreeStorageNode &installed_addons){
	//Loop through the blocks of the addons file.
	//These should contain the types levels, levelpacks, themes.
	for(unsigned int i=0;i<addons.subNodes.size();i++){
	TreeStorageNode* block=addons.subNodes[i];
	if(block==NULL) continue;

	string type;
	type=block->name;
	//Now loop the entries(subNodes) of the block.
	for(unsigned int i=0;i<block->subNodes.size();i++){
	TreeStorageNode* entry=block->subNodes[i];
	if(entry==NULL) continue;
	if(entry->name=="entry" && entry->value.size()==1){
	//The entry is valid so create a new Addon.
	Addon addon = *(new Addon);
	addon.type=type;
	addon.name=entry->value[0];
	addon.file=entry->attributes["file"][0];
	if(!entry->attributes["folder"].empty()){
	addon.folder=entry->attributes["folder"][0];
	}
	addon.author=entry->attributes["author"][0];
	addon.version=atoi(entry->attributes["version"][0].c_str());
	addon.upToDate=false;
	addon.installed=false;

	//Check if the addon is already installed.
	for(unsigned int i=0;i<installed_addons.subNodes.size();i++){
	TreeStorageNode* installed=installed_addons.subNodes[i];
	if(installed==NULL) continue;
	if(installed->name=="entry" && installed->value.size()==3){
	if(addon.type.compare(installed->value[0])==0 && addon.name.compare(installed->value[1])==0) {
	addon.installed=true;
	addon.installedVersion=atoi(installed->value[2].c_str());
	if(addon.installedVersion>=addon.version) {
	addon.upToDate=true;
	}

	}
	}
	}

	//Finally put him in the list.
	list.push_back(addon);
	}
	}
	}
	}

	std::vector<std::string> Addons::addonsToList(const std::string &type){
	std::vector<std::string> result;

	for(unsigned int i=0;i<addons->size();i++) {
	//Check if the addon is from the right type.
	if((*addons)[i].type==type) {
	string entry = (addons)[i].name + " by " + (addons)[i].author;
	if((*addons)[i].installed) {
	if((*addons)[i].upToDate) {
	entry += " *";
	} else {
	entry += " +";
	}
	}
	result.push_back(entry);
	}
	}
	return result;
	}

	bool Addons::saveInstalledAddons(){
	if(!addons) return false;

	//Open the file.
	ofstream iaddons;
	iaddons.open((getUserPath(USER_CONFIG)+"installed_addons").c_str());
	if(!iaddons) return false;

	//Loop all the levels.
	TreeStorageNode installed;
	for(unsigned int i=0;i<addons->size();i++) {
	//Check if the level is installed or not.
	if((*addons)[i].installed) {
	TreeStorageNode *entry=new TreeStorageNode;
	entry->name="entry";
	entry->value.push_back((*addons)[i].type);
	entry->value.push_back((*addons)[i].name);
	char version[64];
	sprintf(version,"%d",(*addons)[i].installedVersion);
	entry->value.push_back(version);

	installed.subNodes.push_back(entry);
	}
	}


	//And write away the file.
	POASerializer objSerializer;
	objSerializer.writeNode(&installed,iaddons,true,true);

	return true;
	}

	void Addons::handleEvents(){
	//Check if we should quit.
	if(event.type==SDL_QUIT){
	//Save the installed addons before exiting.
	saveInstalledAddons();
	setNextState(STATE_EXIT);
	}

	//Check if escape is pressed, if so return to the main menu.
	if(inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE)){
	setNextState(STATE_MENU);
	}
	}

	void Addons::logic(){}

	void Addons::render(){
	//We only need to draw the menu background.
	applySurface(0,0,menuBackground,screen,NULL);

	//Draw the title.
	applySurface((SCREEN_WIDTH-title->w)/2,40,title,screen,NULL);
	}

	void Addons::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	if(name=="lstTabs"){
	if(obj->value==0){
	list->item=addonsToList("levels");
	type="levels";
	}else if(obj->value==1){
	list->item=addonsToList("levelpacks");
	type="levelpacks";
	}else{
	list->item=addonsToList("themes");
	type="themes";
	}
	list->value=0;
	GUIEventCallback_OnEvent("lstAddons",list,GUIEventChange);
	}else if(name=="lstAddons"){
	//Get the addon struct that belongs to it.
	Addon *addon=NULL;
	if(list->item.size()>0) {
	string entry = list->item[list->value];
	if(type.compare("levels")==0) {
	for(unsigned int i=0;i<addons->size();i++) {
	std::string prefix=(*addons)[i].name;
	if(!entry.compare(0, prefix.size(), prefix)) {
	addon=&(*addons)[i];
	}
	}
	} else if(type.compare("levelpacks")==0) {
	for(unsigned int i=0;i<addons->size();i++) {
	std::string prefix=(*addons)[i].name;
	if(!entry.compare(0, prefix.size(), prefix)) {
	addon=&(*addons)[i];
	}
	}
	} else if(type.compare("themes")==0) {
	for(unsigned int i=0;i<addons->size();i++) {
	std::string prefix=(*addons)[i].name;
	if(!entry.compare(0, prefix.size(), prefix)) {
	addon=&(*addons)[i];
	}
	}
	}
	}

	selected=addon;
	updateActionButton();
	updateUpdateButton();
	}else if(name=="cmdBack"){
	saveInstalledAddons();
	setNextState(STATE_MENU);
	}else if(name=="cmdUpdate"){

	//First remove the addon and then install it again.
	if(type.compare("levels")==0) {
	if(downloadFile(selected->file,(getUserPath(USER_DATA)+"/levels/"))!=false){
	selected->upToDate=true;
	selected->installedVersion=selected->version;
	list->item=addonsToList("levels");
	updateActionButton();
	updateUpdateButton();
	}else{
	cerr<<"ERROR: Unable to download addon!"<<endl;
	msgBox(_("ERROR: Unable to download addon!"),MsgBoxOKOnly,_("ERROR:"));
	return;
	}
	}else if(type.compare("levelpacks")==0) {
	if(!removeDirectory((getUserPath(USER_DATA)+"levelpacks/"+selected->folder+"/").c_str())){
	cerr<<"ERROR: Unable to remove the directory "<<(getUserPath(USER_DATA)+"levelpacks/"+selected->folder+"/")<<"."<<endl;
	return;
	}
	if(downloadFile(selected->file,(getUserPath(USER_CACHE)+"/tmp/"))!=false){
	extractFile(getUserPath(USER_CACHE)+"/tmp/"+fileNameFromPath(selected->file,true),getUserPath(USER_DATA)+"/levelpacks/"+selected->folder+"/");
	selected->upToDate=true;
	selected->installedVersion=selected->version;
	list->item=addonsToList("levelpacks");
	updateActionButton();
	updateUpdateButton();
	}else{
	cerr<<"ERROR: Unable to download addon!"<<endl;
	msgBox(_("ERROR: Unable to download addon!"),MsgBoxOKOnly,_("ERROR:"));
	return;
	}
	}else if(type.compare("themes")==0) {
	if(!removeDirectory((getUserPath(USER_DATA)+"themes/"+selected->folder+"/").c_str())){
	cerr<<"ERROR: Unable to remove the directory "<<(getUserPath(USER_DATA)+"themes/"+selected->folder+"/")<<"."<<endl;
	return;
	}
	if(downloadFile(selected->file,(getUserPath(USER_CACHE)+"/tmp/"))!=false){
	extractFile((getUserPath(USER_CACHE)+"/tmp/"+fileNameFromPath(selected->file,true)),(getUserPath(USER_DATA)+"/themes/"+selected->folder+"/"));
	selected->upToDate=true;
	selected->installedVersion=selected->version;
	list->item=addonsToList("themes");
	updateActionButton();
	updateUpdateButton();
	}else{
	cerr<<"ERROR: Unable to download addon!"<<endl;
	msgBox(_("ERROR: Unable to download addon!"),MsgBoxOKOnly,_("ERROR:"));
	return;
	}
	}


	}else if(name=="cmdInstall"){
	switch(action) {
	case NONE:
	break;
	case INSTALL:
	//Download the addon.
	if(type.compare("levels")==0) {
	if(downloadFile(selected->file,getUserPath(USER_DATA)+"/levels/")!=false){
	selected->upToDate=true;
	selected->installed=true;
	selected->installedVersion=selected->version;
	list->item=addonsToList("levels");
	updateActionButton();
	;

	//And add the level to the levels levelpack.
	LevelPack* levelsPack=getLevelPackManager()->getLevelPack("Levels");
	levelsPack->addLevel(getUserPath(USER_DATA)+"/levels/"+fileNameFromPath(selected->file));
	levelsPack->setLocked(levelsPack->getLevelCount()-1);
	}else{
	cerr<<"ERROR: Unable to download addon!"<<endl;
	msgBox(_("ERROR: Unable to download addon!"),MsgBoxOKOnly,_("ERROR:"));
	return;
	}
	}else if(type.compare("levelpacks")==0) {
	if(downloadFile(selected->file,getUserPath(USER_CACHE)+"/tmp/")!=false){
	extractFile(getUserPath(USER_CACHE)+"/tmp/"+fileNameFromPath(selected->file,true),getUserPath(USER_DATA)+"/levelpacks/"+selected->folder+"/");
	selected->upToDate=true;
	selected->installed=true;
	selected->installedVersion=selected->version;
	list->item=addonsToList("levelpacks");
	updateActionButton();
	updateUpdateButton();

	//And add the levelpack to the levelpackManager.
	getLevelPackManager()->loadLevelPack(getUserPath(USER_DATA)+"/levelpacks/"+selected->folder);
	}else{
	cerr<<"ERROR: Unable to download addon!"<<endl;
	msgBox(_("ERROR: Unable to download addon!"),MsgBoxOKOnly,_("ERROR:"));
	return;
	}
	}else if(type.compare("themes")==0) {
	if(downloadFile(selected->file,getUserPath(USER_CACHE)+"/tmp/")!=false){
	extractFile(getUserPath(USER_CACHE)+"/tmp/"+fileNameFromPath(selected->file,true),getUserPath(USER_DATA)+"/themes/"+selected->folder+"/");
	selected->upToDate=true;
	selected->installed=true;
	selected->installedVersion=selected->version;
	list->item=addonsToList("themes");
	updateActionButton();
	updateUpdateButton();
	}else{
	cerr<<"ERROR: Unable to download addon!"<<endl;
	msgBox(_("ERROR: Unable to download addon!"),MsgBoxOKOnly,_("ERROR:"));
	return;
	}
	}
	break;
	case UNINSTALL:
	//Uninstall the addon.
	if(type.compare("levels")==0) {
	if(remove((getUserPath(USER_DATA)+"levels/"+fileNameFromPath(selected->file)).c_str())){
	cerr<<"ERROR: Unable to remove the file "<<(getUserPath(USER_DATA) + "levels/" + fileNameFromPath(selected->file))<<"."<<endl;
	return;
	}

	selected->upToDate=false;
	selected->installed=false;
	list->item=addonsToList("levels");
	updateActionButton();
	updateUpdateButton();

	//And remove the level from the levels levelpack.
	LevelPack* levelsPack=getLevelPackManager()->getLevelPack("Levels");
	for(int i=0;i<levelsPack->getLevelCount();i++){
	if(levelsPack->getLevelFile(i)==(getUserPath(USER_DATA)+"levels/"+fileNameFromPath(selected->file))){
	//Remove the level and break out of the loop.
	levelsPack->removeLevel(i);
	break;
	}
	}
	}else if(type.compare("levelpacks")==0) {
	if(!removeDirectory((getUserPath(USER_DATA)+"levelpacks/"+selected->folder+"/").c_str())){
	cerr<<"ERROR: Unable to remove the directory "<<(getUserPath(USER_DATA)+"levelpacks/"+selected->folder+"/")<<"."<<endl;
	return;
	}

	selected->upToDate=false;
	selected->installed=false;
	list->item=addonsToList("levelpacks");
	updateActionButton();
	updateUpdateButton();

	//And remove the levelpack from the levelpack manager.
	getLevelPackManager()->removeLevelPack(selected->folder);
	}else if(type.compare("themes")==0) {
	if(!removeDirectory((getUserPath(USER_DATA)+"themes/"+selected->folder+"/").c_str())){
	cerr<<"ERROR: Unable to remove the directory "<<(getUserPath(USER_DATA)+"themes/"+selected->folder+"/")<<"."<<endl;
	return;
	}

	selected->upToDate=false;
	selected->installed=false;
	list->item=addonsToList("themes");
	updateActionButton();
	updateUpdateButton();
	}
	break;
	}
	}
	}

	void Addons::updateUpdateButton(){
	//some sanity check
	if(selected==NULL){
	updateButton->enabled=false;
	return;
	}

	//Check if the selected addon is installed.
	if(selected->installed){
	//It is installed, but is it uptodate?
	if(selected->upToDate){
	//The addon is installed and there is no need to show the button.
	updateButton->enabled=false;
	updateButton->visible=false;
	}else{
	//Otherwise show the button
	updateButton->enabled=true;
	updateButton->visible=true;
	}
	}else{
	//The addon isn't installed so we can only install it.
	updateButton->enabled=false;
	}
	}



	void Addons::updateActionButton(){
	//some sanity check
	if(selected==NULL){
	actionButton->enabled=false;
	action = NONE;
	return;
	}

	//Check if the selected addon is installed.
	if(selected->installed){
	//It is installed, but is it uptodate?
	actionButton->enabled=true;
	actionButton->caption=_("Uninstall");
	action = UNINSTALL;
	}else{
	//The addon isn't installed so we can only install it.
	actionButton->enabled=true;
	actionButton->caption=_("Install");
	action = INSTALL;
	}
	}
	diff --git a/src/GUIObject.h b/src/GUIObject.h
	index 15856a9..c942848 100644
	--- a/src/GUIObject.h
	+++ b/src/GUIObject.h
	@@ -1,184 +1,185 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#ifndef GUIOBJECT_H
	#define GUIOBJECT_H

	#include "Globals.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include <string>
	#include <vector>
	#include <list>

	//Ids for the different GUIObject types.
	//None is a special type, it has no visual form.
	const int GUIObjectNone=0;
	//A label used to dispaly text.
	const int GUIObjectLabel=1;
	//Button which will invoke an event when pressed.
	const int GUIObjectButton=2;
	//Checkbox which represents a boolean value and can be toggled.
	const int GUIObjectCheckBox=3;
	//A text box used to enter text.
	const int GUIObjectTextBox=5;
	//Frame which is like a container.
	const int GUIObjectFrame=6;

	//Widget gravity properties
	const int GUIGravityLeft=0;
	const int GUIGravityCenter=1;
	const int GUIGravityRight=2;

	//The event id's.
	//A click event used for e.g. buttons.
	const int GUIEventClick=0;
	//A change event used for e.g. textboxes.
	const int GUIEventChange=1;


	class GUIObject;

	//Class that is used as event callback.
	class GUIEventCallback{
	public:
	//This method is called when an event is fired.
	//name: The name of the event.
	//obj: Pointer to the GUIObject which caused this event.
	//eventType: The type of event as defined above.
	virtual void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType)=0;
	};

	//Class containing the
	class GUIObject{
	public:
	//The relative x location of the GUIObject.
	int left;
	//The relative y location of the GUIObject.
	int top;
	//The width of the GUIObject.
	int width;
	//The height of the GUIObject.
	int height;

	//The type of the GUIObject.
	int type;
	//The value of the GUIObject.
	//It depends on the type of GUIObject what it means.
	int value;

	//The name of the GUIObject.
	std::string name;
	//The caption of the GUIObject.
	//It depends on the type of GUIObject what it is.
	std::string caption;

	//Boolean if the GUIObject is enabled.
	bool enabled;
	//Boolean if the GUIObject is visible.
	bool visible;

	//Vector containing the children of the GUIObject.
	std::vector<GUIObject*> childControls;

	//Event callback used to invoke events.
	GUIEventCallback* eventCallback;

	//Widget's gravity to centering
	int gravity;
	protected:
	//The state of the GUIObject.
	//It depends on the type of GUIObject where it's used for.
	int state;

	//Surface containing some gui images.
	SDL_Surface* bmGUI;

	//Surface that can be used to cache rendered text.
	SDL_Surface* cache;
	//String containing the old caption to detect if it changed.
	std::string cachedCaption;
	//Boolean containing the previous enabled state.
	bool cachedEnabled;
	public:
	//Constructor.
	//left: The relative x location of the GUIObject.
	//top: The relative y location of the GUIObject.
	//witdh: The width of the GUIObject.
	//height: The height of the GUIObject.
	//type: The type of the GUIObject.
	//caption: The text on the GUIObject.
	//value: The value of the GUIObject.
	//enabled: Boolean if the GUIObject is enabled or not.
	//visible: Boolean if the GUIObject is visisble or not.
	+ //gravity: The way the GUIObject needs to be aligned.
	GUIObject(int left=0,int top=0,int width=0,int height=0,int type=0,
	- const char* caption=NULL,int gravity=0,int value=0,
	- bool enabled=true,bool visible=true):
	+ const char* caption=NULL,int value=0,
	+ bool enabled=true,bool visible=true,int gravity=0):
	left(left),top(top),width(width),height(height),
	type(type),gravity(gravity),value(value),
	enabled(enabled),visible(visible),
	eventCallback(NULL),state(0),
	cache(NULL),cachedEnabled(enabled)
	{
	//Make sure that caption isn't NULL before setting it.
	if(caption){
	GUIObject::caption=caption;
	//And set the cached caption.
	cachedCaption=caption;
	}

	//Load the gui images.
	bmGUI=loadImage(getDataPath()+"gfx/gui.png");
	}
	//Destructor.
	virtual ~GUIObject();

	//Method used to handle mouse and/or key events.
	//x: The x mouse location.
	//y: The y mouse location.
	//enabled: Boolean if the parent is enabled or not.
	//visible: Boolean if the parent is visible or not.
	//processed: Boolean if the event has been processed (by the parent) or not.
	//Returns: Boolean if the event is processed by the child.
	virtual bool handleEvents(int x=0,int y=0,bool enabled=true,bool visible=true,bool processed=false);
	//Method that will render the GUIObject.
	//x: The x location to draw the GUIObject. (x+left)
	//y: The y location to draw the GUIObject. (y+top)
	virtual void render(int x=0,int y=0);
	};

	//Method used to handle the GUIEvents from the GUIEventQueue.
	//kill: Boolean if an SDL_QUIT event may kill the GUIObjectRoot.
	void GUIObjectHandleEvents(bool kill=false);

	//A structure containing the needed variables to call an event.
	struct GUIEvent{
	//Event callback used to invoke the event.
	GUIEventCallback* eventCallback;
	//The name of the event.
	std::string name;
	//Pointer to the object which invoked the event.
	GUIObject* obj;
	//The type of event.
	int eventType;
	};

	//List used to queue the gui events.
	extern std::list<GUIEvent> GUIEventQueue;

	#endif
	diff --git a/src/Game.cpp b/src/Game.cpp
	index 47fcde9..28a0414 100644
	--- a/src/Game.cpp
	+++ b/src/Game.cpp
	@@ -1,1249 +1,1249 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#include "GameState.h"
	#include "Globals.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "GameObjects.h"
	#include "ThemeManager.h"
	#include "Objects.h"
	#include "Game.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "InputManager.h"
	#include <fstream>
	#include <iostream>
	#include <sstream>
	#include <vector>
	#include <map>
	#include <algorithm>
	#include <locale>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	const char* Game::blockName[TYPE_MAX]={"Block","PlayerStart","ShadowStart",
	"Exit","ShadowBlock","Spikes",
	"Checkpoint","Swap","Fragile",
	"MovingBlock","MovingShadowBlock","MovingSpikes",
	"Teleporter","Button","Switch",
	"ConveyorBelt","ShadowConveyorBelt","NotificationBlock", "Collectable",
	};

	map<string,int> Game::blockNameMap;
	string Game::recordFile;

	Game::Game(bool loadLevel):isReset(false)
	,currentLevelNode(NULL)
	,customTheme(NULL)
	,background(NULL)
	,won(false)
	,interlevel(false)
	,gameTipIndex(0)
	,time(0),timeSaved(0)
	,recordings(0),recordingsSaved(0)
	,shadowCam(false)
	,player(this),shadow(this),objLastCheckPoint(NULL){

	saveStateNextTime=false;
	loadStateNextTime=false;

	//Reserve the memory for the GameObject tips.
	memset(bmTips,0,sizeof(bmTips));

	action=loadImage(getDataPath()+"gfx/actions.png");
	medals=loadImage(getDataPath()+"gfx/medals.png");
	collectable=loadImage(getDataPath()+"gfx/collectable.png");

	//Check if we should load record file.
	if(!recordFile.empty()){
	loadRecord(recordFile.c_str());
	recordFile.clear();
	return;
	}

	//If we should load the level then load it.
	if(loadLevel){
	this->loadLevel(levels->getLevelpackPath()+levels->getLevelFile());
	levels->saveLevelProgress();
	}
	}

	Game::~Game(){
	//Simply call our destroy method.
	destroy();
	}

	void Game::destroy(){
	//Loop through the levelObjects and delete them.
	for(unsigned int i=0;i<levelObjects.size();i++)
	delete levelObjects[i];
	//Done now clear the levelObjects vector.
	levelObjects.clear();

	//Clear the name and the editor data.
	levelName.clear();
	levelFile.clear();
	editorData.clear();

	//Loop through the tips.
	for(int i=0;i<TYPE_MAX;i++){
	//If it exist free the SDL_Surface.
	if(bmTips[i])
	SDL_FreeSurface(bmTips[i]);
	}
	memset(bmTips,0,sizeof(bmTips));

	//Remove everything from the themeManager.
	background=NULL;
	if(customTheme)
	objThemes.removeTheme();
	customTheme=NULL;

	//delete current level (if any)
	if(currentLevelNode){
	delete currentLevelNode;
	currentLevelNode=NULL;
	}

	//Reset the time.
	time=timeSaved=0;
	recordings=recordingsSaved=0;
	}

	void Game::loadLevelFromNode(TreeStorageNode* obj,const string& fileName){
	//Make sure there's nothing left from any previous levels.
	destroy();

	//set current level to loaded one.
	currentLevelNode=obj;

	//Temp var used for block locations.
	SDL_Rect box;

	//Set the level dimensions to the default, it will probably be changed by the editorData,
	//but 800x600 is a fallback.
	LEVEL_WIDTH=800;
	LEVEL_HEIGHT=600;

	currentCollectables=0;
	totalCollectables=0;
	currentCollectablesSaved=0;

	//Load the additional data.
	for(map<string,vector<string> >::iterator i=obj->attributes.begin();i!=obj->attributes.end();i++){
	if(i->first=="size"){
	//We found the size attribute.
	if(i->second.size()>=2){
	//Set the dimensions of the level.
	LEVEL_WIDTH=atoi(i->second[0].c_str());
	LEVEL_HEIGHT=atoi(i->second[1].c_str());
	}
	}else if(i->second.size()>0){
	//Any other data will be put into the editorData.
	editorData[i->first]=i->second[0];
	}
	}

	//Get the theme.
	{
	//If a theme is configured then load it.
	string theme=processFileName(getSettings()->getValue("theme"));

	//Check if it isn't the default theme, because if it is it's already loaded.
	if(fileNameFromPath(theme)!="Cloudscape") {
	customTheme=objThemes.appendThemeFromFile(theme+"/theme.mnmstheme");
	}

	//Check if level themes are enabled.
	if(getSettings()->getBoolValue("leveltheme")) {
	string &s=editorData["theme"];
	if(!s.empty()){
	customTheme=objThemes.appendThemeFromFile(processFileName(theme)+"/theme.mnmstheme");
	}
	}

	//Set the Appearance of the player and the shadow.
	objThemes.getCharacter(false)->createInstance(&player.appearance);
	objThemes.getCharacter(true)->createInstance(&shadow.appearance);
	}


	for(unsigned int i=0;i<obj->subNodes.size();i++){
	TreeStorageNode* obj1=obj->subNodes[i];
	if(obj1==NULL) continue;
	if(obj1->name=="tile" && obj1->value.size()>=3){
	int objectType=blockNameMap[obj1->value[0]];

	box.x=atoi(obj1->value[1].c_str());
	box.y=atoi(obj1->value[2].c_str());

	map<string,string> obj;

	for(map<string,vector<string> >::iterator i=obj1->attributes.begin();i!=obj1->attributes.end();i++){
	if(i->second.size()>0) obj[i->first]=i->second[0];
	}

	//If the type is collectable, increase the number of totalCollectables
	if (objectType==TYPE_COLLECTABLE)
	totalCollectables++;

	levelObjects.push_back( new Block ( box.x, box.y, objectType, this) );
	levelObjects.back()->setEditorData(obj);
	}
	}

	//Set the levelName to the name of the current level.
	levelName=editorData["name"];
	levelFile=fileName;

	//Some extra stuff only needed when not in the levelEditor.
	if(stateID!=STATE_LEVEL_EDITOR){
	//We create a text with the text "Level <levelno> <levelName>".
	//It will be shown in the left bottom corner of the screen.
	string s;
	if (levels->getLevelCount()>1){
	s=tfm::format(_("Level %d %s"),levels->getCurrentLevel()+1,editorData["name"]);
	}

	SDL_Color fg={0,0,0,0};
	SDL_Color bg={255,255,255,0};
	bmTips[0]=TTF_RenderUTF8_Shaded(fontText,s.c_str(),fg,bg);
	if(bmTips[0])
	SDL_SetAlpha(bmTips[0],SDL_SRCALPHA,160);
	}

	//Get the background
	background=objThemes.getBackground();
	if(background)
	background->resetAnimation(true);
	}

	void Game::loadLevel(string fileName){
	//Create a TreeStorageNode that will hold the loaded data.
	TreeStorageNode *obj=new TreeStorageNode();
	{
	POASerializer objSerializer;
	string s=fileName;

	//Parse the file.
	if(!objSerializer.loadNodeFromFile(s.c_str(),obj,true)){
	cout<<"Can't load level file "<<s<<endl;
	delete obj;
	return;
	}
	}

	//Now call another function.
	loadLevelFromNode(obj,fileName);
	}

	void Game::saveRecord(const char* fileName){
	//check if current level is NULL (which should be impossible)
	if(currentLevelNode==NULL) return;

	TreeStorageNode obj;
	POASerializer objSerializer;

	//put current level to the node.
	currentLevelNode->name="map";
	obj.subNodes.push_back(currentLevelNode);

	//serialize the game record using RLE compression.
	#define PUSH_BACK \
	if(j>0){ \
	if(j>1){ \
	sprintf(c,"%d*%d",last,j); \
	}else{ \
	sprintf(c,"%d",last); \
	} \
	v.push_back(c); \
	}
	vector<string> &v=obj.attributes["record"];
	vector<int> *record=player.getRecord();
	char c[64];
	int i,j=0,last;
	for(i=0;i<(int)record->size();i++){
	int currentKey=(*record)[i];
	if(j==0 \|\| currentKey!=last){
	PUSH_BACK;
	last=currentKey;
	j=1;
	}else{
	j++;
	}
	}
	PUSH_BACK;
	#undef PUSH_BACK

	#ifdef RECORD_FILE_DEBUG
	//add record file debug data.
	{
	obj.attributes["recordKeyPressLog"].push_back(player.keyPressLog());

	vector<SDL_Rect> &playerPosition=player.playerPosition();
	string s;
	char c[32];

	sprintf(c,"%d\n",int(playerPosition.size()));
	s=c;

	for(unsigned int i=0;i<playerPosition.size();i++){
	SDL_Rect& r=playerPosition[i];
	sprintf(c,"%d %d\n",r.x,r.y);
	s+=c;
	}

	obj.attributes["recordPlayerPosition"].push_back(s);
	}
	#endif

	//save it
	objSerializer.saveNodeToFile(fileName,&obj,true,true);

	//remove current level from node to prevent delete it.
	obj.subNodes.clear();
	}

	void Game::loadRecord(const char* fileName){
	//Create a TreeStorageNode that will hold the loaded data.
	TreeStorageNode obj;
	{
	POASerializer objSerializer;
	string s=fileName;

	//Parse the file.
	if(!objSerializer.loadNodeFromFile(s.c_str(),&obj,true)){
	cout<<"Can't load record file "<<s<<endl;
	return;
	}
	}

	//find the node named 'map'.
	bool loaded=false;
	for(unsigned int i=0;i<obj.subNodes.size();i++){
	if(obj.subNodes[i]->name=="map"){
	//load the level. (fileName=???)
	loadLevelFromNode(obj.subNodes[i],"???");
	//remove this node to prevent delete it.
	obj.subNodes[i]=NULL;
	//over
	loaded=true;
	break;
	}
	}

	if(!loaded){
	cout<<"ERROR: Can't find subnode named 'map' from record file"<<endl;
	return;
	}

	//load the record.
	{
	vector<int> *record=player.getRecord();
	record->clear();
	vector<string> &v=obj.attributes["record"];
	for(unsigned int i=0;i<v.size();i++){
	string &s=v[i];
	string::size_type pos=s.find_first_of('*');
	if(pos==string::npos){
	//1 item only.
	int i=atoi(s.c_str());
	record->push_back(i);
	}else{
	//contains many items.
	int i=atoi(s.substr(0,pos).c_str());
	int j=atoi(s.substr(pos+1).c_str());
	for(;j>0;j--){
	record->push_back(i);
	}
	}
	}
	}

	#ifdef RECORD_FILE_DEBUG
	//load the debug data
	{
	vector<string> &v=obj.attributes["recordPlayerPosition"];
	vector<SDL_Rect> &playerPosition=player.playerPosition();
	playerPosition.clear();
	if(!v.empty()){
	if(!v[0].empty()){
	stringstream st(v[0]);
	int m;
	st>>m;
	for(int i=0;i<m;i++){
	SDL_Rect r;
	st>>r.x>>r.y;
	r.w=0;
	r.h=0;
	playerPosition.push_back(r);
	}
	}
	}
	}
	#endif

	//play the record.
	//TODO: tell the level manager don't save the level progress.
	player.playRecord();
	shadow.playRecord(); //???
	}

	/////////////EVENT///////////////
	void Game::handleEvents(){
	//First of all let the player handle input.
	player.handleInput(&shadow);

	//Check for an SDL_QUIT event.
	if(event.type==SDL_QUIT){
	//We need to quit so enter STATE_EXIT.
	setNextState(STATE_EXIT);
	}

	//Check for the escape key.
	if(inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE)){
	//Escape means we go one level up, to the level select state.
	setNextState(STATE_LEVEL_SELECT);
	//Save the progress.
	levels->saveLevelProgress();

	//And change the music back to the menu music.
	getMusicManager()->playMusic("menu");
	}

	//Check if 'r' is pressed.
	if(inputMgr.isKeyDownEvent(INPUTMGR_RESTART)){
	isReset=true;
	}

	//Check for the next level buttons when in the interlevel popup.
	if(inputMgr.isKeyDownEvent(INPUTMGR_SPACE) \|\| (event.type==SDL_KEYDOWN && (event.key.keysym.sym==SDLK_RETURN \|\| event.key.keysym.sym==SDLK_RCTRL))){
	if(interlevel){
	//The interlevel popup is shown so we need to delete it.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//Now goto the next level.
	gotoNextLevel();
	}
	}

	//Check if tab is pressed.
	if(inputMgr.isKeyDownEvent(INPUTMGR_TAB)){
	shadowCam=!shadowCam;
	}
	}

	/////////////////LOGIC///////////////////
	void Game::logic(){
	//Check if we should save/load state.
	if(saveStateNextTime){
	saveState();
	}else if(loadStateNextTime){
	loadState();
	}
	saveStateNextTime=false;
	loadStateNextTime=false;

	//Add one tick to the time.
	time++;

	//Let the player store his move, if recording.
	player.shadowSetState();
	//Let the player give his recording to the shadow, if configured.
	player.shadowGiveState(&shadow);
	//Let the player jump.
	player.jump();
	//Let him move.
	player.move(levelObjects);
	//And let the camera follow him.
	if(!shadowCam){
	player.setMyCamera();
	}else{
	shadow.setMyCamera();
	}

	//Now let the shadow decide his move, if he's playing a recording.
	shadow.moveLogic();
	//Let the shadow jump.
	shadow.jump();
	//Let the shadow move.
	shadow.move(levelObjects);

	//Some levelObjects can move so update them.
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->move();
	}

	//Process any event in the queue.
	for(unsigned int idx=0;idx<eventQueue.size();idx++){
	//Get the event from the queue.
	typeGameObjectEvent &e=eventQueue[idx];

	//Check if the it has an id attached to it.
	if(e.flags\|1){
	//Loop through the levelObjects and give them the event if they have the right id.
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(e.objectType<0 \|\| levelObjects[i]->type==e.objectType){
	Block obj=dynamic_cast<Block>(levelObjects[i]);
	if(obj!=NULL && obj->id==e.id){
	levelObjects[i]->onEvent(e.eventType);
	}
	}
	}
	}else{
	//Loop through the levelObjects and give them the event.
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(e.objectType<0 \|\| levelObjects[i]->type==e.objectType){
	levelObjects[i]->onEvent(e.eventType);
	}
	}
	}
	}
	//Done processing the events so clear the queue.
	eventQueue.clear();

	//Check collision and stuff for the shadow and player.
	player.otherCheck(&shadow);

	//Check if we won.
	if(won){
	//Check if it's playing from record
	if(player.isPlayFromRecord() && !interlevel){
	recordingEnded();
	}else{
	//the string to store auto-save record path.
	string bestTimeFilePath,bestRecordingFilePath;
	//and if we can't get test path.
	bool filePathError=false;

	//Set the current level won.
	levels->getLevel()->won=true;
	if(levels->getLevel()->time==-1 \|\| levels->getLevel()->time>time){
	levels->getLevel()->time=time;
	//save the best-time game record.
	if(bestTimeFilePath.empty()){
	getCurrentLevelAutoSaveRecordPath(bestTimeFilePath,bestRecordingFilePath,true);
	}
	if(bestTimeFilePath.empty()){
	cout<<"ERROR: Couldn't get auto-save record file path"<<endl;
	filePathError=true;
	}else{
	saveRecord(bestTimeFilePath.c_str());
	}
	}
	if(levels->getLevel()->recordings==-1 \|\| levels->getLevel()->recordings>recordings){
	levels->getLevel()->recordings=recordings;
	//save the best-recordings game record.
	if(bestRecordingFilePath.empty() && !filePathError){
	getCurrentLevelAutoSaveRecordPath(bestTimeFilePath,bestRecordingFilePath,true);
	}
	if(bestRecordingFilePath.empty()){
	cout<<"ERROR: Couldn't get auto-save record file path"<<endl;
	filePathError=true;
	}else{
	saveRecord(bestRecordingFilePath.c_str());
	}
	}

	//Set the next level unlocked if it exists.
	if(levels->getCurrentLevel()+1<levels->getLevelCount()){
	levels->setLocked(levels->getCurrentLevel()+1);
	}
	//And save the progress.
	levels->saveLevelProgress();

	//Now go to the interlevel screen.
	replayPlay();

	//NOTE: We set isReset false to prevent the user from getting a best time of 0.00s and 0 recordings.
	}
	}
	won=false;

	//Check if we should reset.
	if(isReset)
	reset(false);
	isReset=false;
	}

	/////////////////RENDER//////////////////
	void Game::render(){
	//First of all render the background.
	{
	//Get a pointer to the background.
	ThemeBackground* bg=background;

	//Check if the background is null, but there are themes.
	if(bg==NULL && objThemes.themeCount()>0){
	//Get the background from the first theme in the stack.
	bg=objThemes[0]->getBackground();
	}

	//Check if the background isn't null.
	if(bg){
	//It isn't so draw it.
	bg->draw(screen);

	//And if it's the loaded background then also update the animation.
	//FIXME: Updating the animation in the render method?
	if(bg==background)
	bg->updateAnimation();
	}else{
	//There's no background so fill the screen with white.
	SDL_Rect r={0,0,SCREEN_WIDTH,SCREEN_HEIGHT};
	SDL_FillRect(screen,&r,-1);
	}
	}

	//Now we draw the levelObjects.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	levelObjects[o]->show();
	}

	//Followed by the player and the shadow.
	player.show();
	shadow.show();

	//Show the levelName if it isn't the level editor.
	if(stateID!=STATE_LEVEL_EDITOR && bmTips[0]!=NULL && !interlevel){
	applySurface(0,SCREEN_HEIGHT-bmTips[0]->h,bmTips[0],screen,NULL);
	}

	//Check if there's a tooltip.
	//NOTE: gameTipIndex 0 is used for the levelName, 1 for shadow death, 2 for restart text, 3 for restart+checkpoint.
	if(gameTipIndex>3 && gameTipIndex<TYPE_MAX){
	//Check if there's a tooltip for the type.
	if(bmTips[gameTipIndex]==NULL){
	//There isn't thus make it.
	string s;
	string keyCode=inputMgr.getKeyCodeName(inputMgr.getKeyCode(INPUTMGR_ACTION,false));
	transform(keyCode.begin(),keyCode.end(),keyCode.begin(),::toupper);
	switch(gameTipIndex){
	case TYPE_CHECKPOINT:
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with current action key
	s=tfm::format(_("Press %s key to save the game."),keyCode);
	break;
	case TYPE_SWAP:
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with current action key
	s=tfm::format(_("Press %s key to swap the position of player and shadow."),keyCode);
	break;
	case TYPE_SWITCH:
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with current action key
	s=tfm::format(_("Press %s key to activate the switch."),keyCode);
	break;
	case TYPE_PORTAL:
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with current action key
	s=tfm::format(_("Press %s key to teleport."),keyCode);
	break;
	}

	//If we have a string then it's a supported GameObject type.
	if(!s.empty()){
	SDL_Color fg={0,0,0,0},bg={255,255,255,0};
	bmTips[gameTipIndex]=TTF_RenderUTF8_Shaded(fontText,s.c_str(),fg,bg);
	SDL_SetAlpha(bmTips[gameTipIndex],SDL_SRCALPHA,160);
	}
	}

	//We already have a gameTip for this type so draw it.
	if(bmTips[gameTipIndex]!=NULL){
	applySurface(0,0,bmTips[gameTipIndex],screen,NULL);
	}
	}
	//Set the gameTip to 0.
	gameTipIndex=0;

	//Pointer to the sdl surface that will contain a message, if any.
	SDL_Surface* bm=NULL;

	//Check if the player is dead, meaning we draw a message.
	if(player.dead){
	//Get user configured restart key
	string keyCodeRestart=inputMgr.getKeyCodeName(inputMgr.getKeyCode(INPUTMGR_RESTART,false));
	transform(keyCodeRestart.begin(),keyCodeRestart.end(),keyCodeRestart.begin(),::toupper);
	//The player is dead, check if there's a state that can be loaded.
	if(player.canLoadState()){
	//Now check if the tip is already made, if not make it.
	if(bmTips[3]==NULL){
	//Get user defined key for loading checkpoint
	string keyCodeLoad=inputMgr.getKeyCodeName(inputMgr.getKeyCode(INPUTMGR_LOAD,false));
	transform(keyCodeLoad.begin(),keyCodeLoad.end(),keyCodeLoad.begin(),::toupper);
	//Draw string
	SDL_Color fg={0,0,0,0},bg={255,255,255,0};
	bmTips[3]=TTF_RenderUTF8_Shaded(fontText,
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - first %s means currently configured key to restart game
	/// - Second %s means configured key to load from last save
	tfm::format(_("Press %s to restart current level or press %s to load the game."),
	keyCodeRestart,keyCodeLoad).c_str(),
	fg,bg);
	SDL_SetAlpha(bmTips[3],SDL_SRCALPHA,160);
	}
	bm=bmTips[3];
	}else{
	//Now check if the tip is already made, if not make it.
	if(bmTips[2]==NULL){
	SDL_Color fg={0,0,0,0},bg={255,255,255,0};
	bmTips[2]=TTF_RenderUTF8_Shaded(fontText,
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with currently configured key to restart game
	tfm::format(_("Press %s to restart current level."),keyCodeRestart).c_str(),
	fg,bg);
	SDL_SetAlpha(bmTips[2],SDL_SRCALPHA,160);
	}
	bm=bmTips[2];
	}
	}

	//Check if the shadow has died (and there's no other notification).
	//NOTE: We use the shadow's jumptime as countdown, this variable isn't used when the shadow is dead.
	if(shadow.dead && bm==NULL && shadow.jumpTime>0){
	//Now check if the tip is already made, if not make it.
	if(bmTips[1]==NULL){
	SDL_Color fg={0,0,0,0},bg={255,255,255,0};
	bmTips[1]=TTF_RenderUTF8_Shaded(fontText,
	_("Your shadow has died."),
	fg,bg);
	SDL_SetAlpha(bmTips[1],SDL_SRCALPHA,160);
	}
	bm=bmTips[1];

	//NOTE: Logic in the render loop, we substract the shadow's jumptime by one.
	shadow.jumpTime--;
	}

	//Draw the tip.
	if(bm!=NULL)
	applySurface(0,0,bm,screen,NULL);

	if (currentCollectables<=totalCollectables && totalCollectables!=0){
	//Draw the key image in the middle of the screen.
	applySurface(SCREEN_WIDTH-collectable->w,SCREEN_HEIGHT-collectable->h,collectable,screen,NULL);

	//Temp stringstream just to addup all the text nicely
	stringstream temp;
	temp << currentCollectables << "/" << totalCollectables;

	SDL_Color black={0,0,0,0};
	SDL_Rect r;
	SDL_Surface* bm=TTF_RenderText_Blended(fontText,temp.str().c_str(),black);

	//Aligning the text to the icon of the key
	r.x=SCREEN_WIDTH-collectable->w+bm->w;
	r.y=SCREEN_HEIGHT-collectable->h-bm->h;

	SDL_BlitSurface(bm,NULL,screen,&r);
	SDL_FreeSurface(bm);
	}

	//show time and records used in level editor.
	if(stateID==STATE_LEVEL_EDITOR && time>0){
	SDL_Color fg={0,0,0,0},bg={255,255,255,0};
	SDL_Surface *bm;
	int y=SCREEN_HEIGHT;

	bm=TTF_RenderUTF8_Shaded(fontText,tfm::format(_("%d recordings"),recordings).c_str(),fg,bg);
	SDL_SetAlpha(bm,SDL_SRCALPHA,160);
	y-=bm->h;
	applySurface(0,y,bm,screen,NULL);
	SDL_FreeSurface(bm);

	char c[32];
	sprintf(c,"%-.2fs",time/40.0f);
	bm=TTF_RenderUTF8_Shaded(fontText,c,fg,bg);
	SDL_SetAlpha(bm,SDL_SRCALPHA,160);
	y-=bm->h;
	applySurface(0,y,bm,screen,NULL);
	SDL_FreeSurface(bm);
	}

	//Draw the current action in the upper right corner.
	if(player.record){
	applySurface(SCREEN_WIDTH-50,0,action,screen,NULL);
	}else if(shadow.state!=0){
	SDL_Rect r={50,0,50,50};
	applySurface(SCREEN_WIDTH-50,0,action,screen,&r);
	}

	//if the game is play from record then draw something indicates it
	if(player.isPlayFromRecord()){
	//Dim the screen if interlevel is true.
	if(interlevel){
	SDL_BlitSurface(screen,NULL,tempSurface,NULL);
	SDL_FillRect(screen,NULL,0);
	SDL_SetAlpha(tempSurface, SDL_SRCALPHA,220);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);

	//Check if the GUI isn't null.
	if(GUIObjectRoot){
	//==Create first box==

	//Create the title
	SDL_Color black={0,0,0,0};
	SDL_Rect r;
	/// TRANSLATORS: This is caption for finished level
	SDL_Surface* bm=TTF_RenderUTF8_Blended(fontGUI,_("You've finished:"),black);

	//Recreate the level string.
	string s;
	if (levels->getLevelCount()>0){
	/// TRANSLATORS: Please do not remove %s or %d from your translation:
	/// - %d means the level number in a levelpack
	/// - %s means the name of current level
	s=tfm::format(_("Level %d %s"),levels->getCurrentLevel()+1,levelName);
	}

	SDL_Surface* bm2=TTF_RenderUTF8_Blended(fontText,s.c_str(),black);

	//Now draw the first gui box so that it's bigger than longer text.
	int width;
	if(bm->w>bm2->w)
	width=bm->w+32;
	else
	width=bm2->w+32;
	drawGUIBox((SCREEN_WIDTH-width)/2,4,width,68,screen,0xDDDDDDA1);

	// Now draw title.
	r.x=(SCREEN_WIDTH-bm->w)/2;
	r.y=8;
	SDL_BlitSurface(bm,NULL,screen,&r);

	// And then level name.
	r.x=(SCREEN_WIDTH-bm2->w)/2;
	r.y=44;
	SDL_BlitSurface(bm2,NULL,screen,&r);

	//Free drawed texts
	SDL_FreeSurface(bm);
	SDL_FreeSurface(bm2);

	//==Create second box==

	//Now draw the second gui box.
	drawGUIBox(GUIObjectRoot->left,GUIObjectRoot->top,GUIObjectRoot->width,GUIObjectRoot->height,screen,0xDDDDDDA1);

	//Draw the medal.
	int medal=GUIObjectRoot->value;
	r.x=(medal-1)*30;
	r.y=0;
	r.w=30;
	r.h=30;
	applySurface(GUIObjectRoot->left+16,GUIObjectRoot->top+92,medals,screen,&r);
	applySurface(GUIObjectRoot->left+370,GUIObjectRoot->top+92,medals,screen,&r);
	}
	}else if((time & 0x10)==0x10){
	SDL_Rect r={50,0,50,50};
	applySurface(0,0,action,screen,&r);
	applySurface(0,SCREEN_HEIGHT-50,action,screen,&r);
	applySurface(SCREEN_WIDTH-50,SCREEN_HEIGHT-50,action,screen,&r);
	}
	}else if(player.objNotificationBlock){
	//If the player is in front of a notification block show the message.
	//And it isn't a replay.
	std::string &untranslated_message=(dynamic_cast<Block*>(player.objNotificationBlock))->message;
	std::string message=_C(levels->getDictionaryManager(),untranslated_message);
	std::vector<char> string_data(message.begin(), message.end());
	string_data.push_back('\0');

	int y = 20;
	vector<SDL_Surface*> lines;

	//Now process the prompt.
	{
	//Pointer to the string.
	char* lps=&string_data[0];
	//Pointer to a character.
	char* lp=NULL;

	//We keep looping forever.
	//The only way out is with the break statement.
	for(;;){
	//As long as it's still the same sentence we continue.
	//It will stop when there's a newline or end of line.
	for(lp=lps;lp!='\n'&&lp!='\r'&&*lp!=0;lp++);

	//Store the character we stopped on. (End or newline)
	char c=*lp;
	//Set the character in the string to 0, making lps a string containing one sentence.
	*lp=0;

	//Integer used to center the sentence horizontally.
	int x;
	TTF_SizeText(fontText,lps,&x,NULL);
	x=(SCREEN_WIDTH-200-x)/2;

	//Color the text will be: black.
	SDL_Color black={0,0,0,0};
	lines.push_back(TTF_RenderUTF8_Blended(fontText,lps,black));
	//Increase y with 25, about the height of the text.
	y+=25;

	//Check the stored character if it was a stop.
	if(c==0){
	//It was so break out of the for loop.
	lps=lp;
	break;
	}
	//It wasn't meaning more will follow.
	//We set lps to point after the "newline" forming a new string.
	lps=lp+1;
	}
	}
	drawGUIBox(100,SCREEN_HEIGHT-y-25,SCREEN_WIDTH-200,y+20,screen,0xDDDDDDA1);
	while(!lines.empty()){
	SDL_Surface* bm=lines[0];

	if(bm!=NULL){
	applySurface(100+((SCREEN_WIDTH-200-bm->w)/2),SCREEN_HEIGHT-y,bm,screen,NULL);
	SDL_FreeSurface(bm);
	}

	y-=25;
	lines.erase(lines.begin());

	}
	}
	}

	void Game::replayPlay(){
	//Reset the number of collectables
	currentCollectables=currentCollectablesSaved=0;

	interlevel=true;

	//Create the gui if it isn't already done.
	if(!GUIObjectRoot){
	GUIObjectRoot=new GUIObject((SCREEN_WIDTH-570)/2,SCREEN_HEIGHT-140,570,135,GUIObjectNone);
	//NOTE: We put the medal in the value of the GUIObjectRoot.

	//The different values.
	int bestTime=levels->getLevel()->time;
	int targetTime=levels->getLevel()->targetTime;
	int bestRecordings=levels->getLevel()->recordings;
	int targetRecordings=levels->getLevel()->targetRecordings;

	int medal=1;
	if(targetTime<0){
	medal=3;
	}else{
	if(targetTime<0 \|\| bestTime<=targetTime)
	medal++;
	if(targetRecordings<0 \|\| bestRecordings<=targetRecordings)
	medal++;
	}
	//Add it to the GUIObjectRoot.
	GUIObjectRoot->value=medal;

	//Create the labels with the time and best time.
	/// TRANSLATORS: Please do not remove %-.2f from your translation:
	/// - %-.2f means time in seconds
	/// - s is shortened form of a second. Try to keep it so.
	GUIObject* obj=new GUIObject(20,10,150,36,GUIObjectLabel,tfm::format(_("Time: %-.2fs"),time/40.0f).c_str());
	GUIObjectRoot->childControls.push_back(obj);

	/// TRANSLATORS: Please do not remove %-.2f from your translation:
	/// - %-.2f means time in seconds
	/// - s is shortened form of a second. Try to keep it so.
	obj=new GUIObject(20,34,150,36,GUIObjectLabel,tfm::format(_("Best time: %-.2fs"),bestTime/40.0f).c_str());
	GUIObjectRoot->childControls.push_back(obj);

	/// TRANSLATORS: Please do not remove %-.2f from your translation:
	/// - %-.2f means time in seconds
	/// - s is shortened form of a second. Try to keep it so.
	if(targetTime>=0){
	obj=new GUIObject(20,58,150,36,GUIObjectLabel,tfm::format(_("Target time: %-.2fs"),targetTime/40.0f).c_str());
	GUIObjectRoot->childControls.push_back(obj);
	}

	//Now the ones for the recordings.
	/// TRANSLATORS: Please do not remove %d from your translation:
	/// - %d means the number of recordings user has made
	obj=new GUIObject(210,10,150,36,GUIObjectLabel,tfm::format(_("Recordings: %d"),recordings).c_str());
	GUIObjectRoot->childControls.push_back(obj);

	/// TRANSLATORS: Please do not remove %d from your translation:
	/// - %d means the number of recordings user has made
	obj=new GUIObject(210,34,150,36,GUIObjectLabel,tfm::format(_("Best recordings: %d"),bestRecordings).c_str());
	GUIObjectRoot->childControls.push_back(obj);

	/// TRANSLATORS: Please do not remove %d from your translation:
	/// - %d means the number of recordings user has made
	if(targetRecordings>=0){
	obj=new GUIObject(210,58,150,36,GUIObjectLabel,tfm::format(_("Target recordings: %d"),targetRecordings).c_str());
	GUIObjectRoot->childControls.push_back(obj);
	}

	//The medal that is earned.
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with name of a prize medal (gold, silver or bronze)
	string s1=tfm::format(_("You earned the %s medal"),(medal>1)?(medal==3)?_("GOLD"):_("SILVER"):_("BRONZE"));
	obj=new GUIObject(48,92,150,36,GUIObjectLabel,s1.c_str());
	//Center it horizontally.
	int width;
	TTF_SizeText(fontText,s1.c_str(),&width,NULL);
	obj->width=width;
	obj->left=(416-width)/2;
	GUIObjectRoot->childControls.push_back(obj);

	//Create the three buttons, Menu, Restart, Next.
	/// TRANSLATORS: used as return to the level selector menu
	- obj=new GUIObject(570,10,-1,36,GUIObjectButton,_("Menu"),GUIGravityRight);
	+ obj=new GUIObject(570,10,-1,36,GUIObjectButton,_("Menu"),0,true,true,GUIGravityRight);
	obj->name="cmdMenu";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	/// TRANSLATORS: used as restart level
	- obj=new GUIObject(570,50,-1,36,GUIObjectButton,_("Restart"),GUIGravityRight);
	+ obj=new GUIObject(570,50,-1,36,GUIObjectButton,_("Restart"),0,true,true,GUIGravityRight);
	obj->name="cmdRestart";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	/// TRANSLATORS: used as next level
	- obj=new GUIObject(570,90,-1,36,GUIObjectButton,_("Next"),GUIGravityRight);
	+ obj=new GUIObject(570,90,-1,36,GUIObjectButton,_("Next"),0,true,true,GUIGravityRight);
	obj->name="cmdNext";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	}

	//We only need to reset a few things so we don't call reset().
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->reset(true);
	}
	//Also reset the background animation, if any.
	if(background)
	background->resetAnimation(true);

	//Make a copy of the playerButtons.
	vector<int> recordCopy=player.recordButton;
	player.reset(true);
	shadow.reset(true);
	player.recordButton=recordCopy;

	//Now play the recording.
	player.playRecord();
	}

	void Game::recordingEnded(){
	//Check if it's a normal replay, if so just stop.
	if(!interlevel){
	msgBox(_("Game replay is done."),MsgBoxOKOnly,_("Game Replay"));
	//Go to the level select menu.
	setNextState(STATE_LEVEL_SELECT);

	//And change the music back to the menu music.
	getMusicManager()->playMusic("menu");
	}else{
	//Instead of directly replaying we set won true to let the Game handle the replaying at the end of the update cycle.
	won=true;
	}
	}

	bool Game::canSaveState(){
	return (player.canSaveState() && shadow.canSaveState());
	}

	bool Game::saveState(){
	//Check if the player and shadow can save the current state.
	if(player.canSaveState() && shadow.canSaveState()){
	//Let the player and the shadow save their state.
	player.saveState();
	shadow.saveState();

	//Save the stats.
	timeSaved=time;
	recordingsSaved=recordings;

	//Save the current collectables
	currentCollectablesSaved=currentCollectables;

	//Save other state, for example moving blocks.
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->saveState();
	}

	//Also save the background animation, if any.
	if(background)
	background->saveAnimation();

	//Return true.
	return true;
	}

	//We can't save the state so return false.
	return false;
	}

	bool Game::loadState(){
	//Check if there's a state that can be loaded.
	if(player.canLoadState() && shadow.canLoadState()){
	//Let the player and the shadow load their state.
	player.loadState();
	shadow.loadState();

	//Load the stats.
	time=timeSaved;
	recordings=recordingsSaved;

	//Load the current collactbles
	currentCollectables=currentCollectablesSaved;

	//Load other state, for example moving blocks.
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->loadState();
	}

	//Also load the background animation, if any.
	if(background)
	background->loadAnimation();

	//Return true.
	return true;
	}

	//We can't load the state so return false.
	return false;
	}

	void Game::reset(bool save){
	//We need to reset the game so we also reset the player and the shadow.
	player.reset(save);
	shadow.reset(save);

	saveStateNextTime=false;
	loadStateNextTime=false;

	//Reset the stats.
	time=0;
	recordings=0;

	//Reset the number of collectables
	currentCollectables=currentCollectablesSaved=0;

	//There is no last checkpoint so set it to NULL.
	if(save)
	objLastCheckPoint=NULL;

	//Reset other state, for example moving blocks.
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->reset(save);
	}
	//Also reset the background animation, if any.
	if(background)
	background->resetAnimation(save);

	//Check if interlevel is true, if so we might need to delete the gui.
	if(interlevel){
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}

	//Also set interlevel to false.
	interlevel=false;
	}

	void Game::broadcastObjectEvent(int eventType,int objectType,const char* id){
	//Create a typeGameObjectEvent that can be put into the queue.
	typeGameObjectEvent e;
	//Set the event type.
	e.eventType=eventType;
	//Set the object type.
	e.objectType=objectType;
	//By default flags=0.
	e.flags=0;
	//Unless there's an id.
	if(id){
	//Set flags to 0x1 and set the id.
	e.flags\|=1;
	e.id=id;
	}

	//Add the event to the queue.
	eventQueue.push_back(e);
	}

	void Game::getCurrentLevelAutoSaveRecordPath(std::string &bestTimeFilePath,std::string &bestRecordingFilePath,bool createPath){
	levels->getLevelAutoSaveRecordPath(-1,bestTimeFilePath,bestRecordingFilePath,createPath);
	}

	void Game::gotoNextLevel(){
	//Goto the next level.
	levels->nextLevel();

	//Check if the level exists.
	if(levels->getCurrentLevel()<levels->getLevelCount()){
	setNextState(STATE_GAME);

	//Don't forget the music.
	getMusicManager()->pickMusic();
	}else{
	if(!levels->congratulationText.empty()){
	msgBox(_C(levels->getDictionaryManager(),levels->congratulationText),MsgBoxOKOnly,_("Congratulations"));
	}else{
	msgBox(_("You have finished the levelpack!"),MsgBoxOKOnly,_("Congratulations"));
	}
	//Now go back to the levelselect screen.
	setNextState(STATE_LEVEL_SELECT);
	//And set the music back to menu.
	getMusicManager()->playMusic("menu");
	}
	}

	void Game::GUIEventCallback_OnEvent(string name,GUIObject* obj,int eventType){
	if(name=="cmdMenu"){
	setNextState(STATE_LEVEL_SELECT);

	//And change the music back to the menu music.
	getMusicManager()->playMusic("menu");
	}else if(name=="cmdRestart"){
	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//And reset the game.
	//new: we don't need to clear the save game because
	//in level replay the game won't be saved
	//TODO: it doesn't work; better leave for next release
	reset(/false/ true);
	}else if(name=="cmdNext"){
	//No matter what, clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//And goto the next level.
	gotoNextLevel();
	}
	}
	diff --git a/src/LevelEditSelect.cpp b/src/LevelEditSelect.cpp
	index 153b158..01b0ef8 100644
	--- a/src/LevelEditSelect.cpp
	+++ b/src/LevelEditSelect.cpp
	@@ -1,657 +1,655 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#include "LevelEditSelect.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "Objects.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUIScrollBar.h"
	#include "InputManager.h"
	#include "Game.h"
	#include <SDL/SDL_ttf.h>
	#include <SDL/SDL.h>
	#include <stdio.h>
	#include <algorithm>
	#include <string>
	#include <iostream>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	LevelEditSelect::LevelEditSelect():LevelSelect(_("Map Editor"),LevelPackManager::CUSTOM_PACKS){
	//The levelpack name text field.
	levelpackName=new GUIObject(280,104,240,32,GUIObjectTextBox);
	levelpackName->eventCallback=this;
	levelpackName->visible=false;
	GUIObjectRoot->childControls.push_back(levelpackName);

	//Create the six buttons at the bottom of the screen.
	GUIObject* obj=new GUIObject(SCREEN_WIDTH*0.02,SCREEN_HEIGHT-120,-1,32,GUIObjectButton,_("New Levelpack"));
	obj->name="cmdNewLvlpack";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	- propertiesPack=new GUIObject(SCREEN_WIDTH*0.5,SCREEN_HEIGHT-120,-1,32,GUIObjectButton,_("Pack Properties"),GUIGravityCenter);
	+ propertiesPack=new GUIObject(SCREEN_WIDTH*0.5,SCREEN_HEIGHT-120,-1,32,GUIObjectButton,_("Pack Properties"),0,true,true,GUIGravityCenter);
	propertiesPack->name="cmdLvlpackProp";
	propertiesPack->eventCallback=this;
	GUIObjectRoot->childControls.push_back(propertiesPack);

	- removePack=new GUIObject(SCREEN_WIDTH*0.98,SCREEN_HEIGHT-120,-1,32,GUIObjectButton,_("Remove Pack"),GUIGravityRight);
	+ removePack=new GUIObject(SCREEN_WIDTH*0.98,SCREEN_HEIGHT-120,-1,32,GUIObjectButton,_("Remove Pack"),0,true,true,GUIGravityRight);
	removePack->name="cmdRmLvlpack";
	removePack->eventCallback=this;
	GUIObjectRoot->childControls.push_back(removePack);

	move=new GUIObject(SCREEN_WIDTH*0.02,SCREEN_HEIGHT-60,-1,32,GUIObjectButton,_("Move Map"));
	move->name="cmdMoveMap";
	move->eventCallback=this;
	move->enabled=false;
	GUIObjectRoot->childControls.push_back(move);

	- remove=new GUIObject(SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,32,GUIObjectButton,_("Remove Map"),GUIGravityCenter);
	+ remove=new GUIObject(SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,32,GUIObjectButton,_("Remove Map"),0,false,true,GUIGravityCenter);
	remove->name="cmdRmMap";
	remove->eventCallback=this;
	- remove->enabled=false;
	GUIObjectRoot->childControls.push_back(remove);

	- edit=new GUIObject(SCREEN_WIDTH*0.98,SCREEN_HEIGHT-60,-1,32,GUIObjectButton,_("Edit Map"),GUIGravityRight);
	+ edit=new GUIObject(SCREEN_WIDTH*0.98,SCREEN_HEIGHT-60,-1,32,GUIObjectButton,_("Edit Map"),0,false,true,GUIGravityRight);
	edit->name="cmdEdit";
	edit->eventCallback=this;
	- edit->enabled=false;
	GUIObjectRoot->childControls.push_back(edit);

	//Set the levelEditGUIObjectRoot.
	levelEditGUIObjectRoot=GUIObjectRoot;

	//show level list
	changePack();
	refresh();
	}

	LevelEditSelect::~LevelEditSelect(){
	selectedNumber=NULL;
	}

	void LevelEditSelect::changePack(){
	packName=levelpacks->item[levelpacks->value];
	if(packName=="Custom Levels"){
	//Disable some levelpack buttons.
	propertiesPack->enabled=false;
	removePack->enabled=false;
	}else{
	//Enable some levelpack buttons.
	propertiesPack->enabled=true;
	removePack->enabled=true;
	}

	//Set last levelpack.
	getSettings()->setValue("lastlevelpack",packName);

	//Now let levels point to the right pack.
	levels=getLevelPackManager()->getLevelPack(packName);
	}

	void LevelEditSelect::packProperties(){
	//Open a message popup.

	//NOTE: We can always point GUIObjectRoot to the main gui by using levelEditGUIObjectRoot.
	GUIObjectRoot=new GUIObject((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-320)/2,600,320,GUIObjectFrame,_("Properties"));
	GUIObject* obj;

	obj=new GUIObject(40,50,240,36,GUIObjectLabel,_("Name:"));
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(60,80,480,36,GUIObjectTextBox,packName.c_str());
	obj->name="LvlpackName";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(40,120,240,36,GUIObjectLabel,_("Description:"));
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(60,150,480,36,GUIObjectTextBox,levels->levelpackDescription.c_str());
	obj->name="LvlpackDescription";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(40,190,240,36,GUIObjectLabel,_("Congratulation text:"));
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(60,220,480,36,GUIObjectTextBox,levels->congratulationText.c_str());
	obj->name="LvlpackCongratulation";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(100,320-44,150,36,GUIObjectButton,_("OK"));
	obj->name="cfgOK";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	obj=new GUIObject(350,320-44,150,36,GUIObjectButton,_("Cancel"));
	obj->name="cfgCancel";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//Dim the screen using the tempSurface.
	SDL_FillRect(tempSurface,NULL,0);
	SDL_SetAlpha(tempSurface,SDL_SRCALPHA,155);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	while(GUIObjectRoot){
	while(SDL_PollEvent(&event)) GUIObjectHandleEvents(true);
	if(GUIObjectRoot) GUIObjectRoot->render();
	flipScreen();
	SDL_Delay(30);
	}

	//We're done so set the original GUIObjectRoot back.
	GUIObjectRoot=levelEditGUIObjectRoot;
	}

	void LevelEditSelect::addLevel(){
	//Open a message popup.

	//NOTE: We can always point GUIObjectRoot to the main gui by using levelEditGUIObjectRoot.
	GUIObjectRoot=new GUIObject((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,GUIObjectFrame,_("Add level"));
	GUIObject* obj;

	obj=new GUIObject(40,80,240,36,GUIObjectLabel,_("File name:"));
	GUIObjectRoot->childControls.push_back(obj);

	char s[64];
	sprintf(s,"map%02d.map",levels->getLevelCount()+1);
	obj=new GUIObject(300,80,240,36,GUIObjectTextBox,s);
	obj->name="LvlFile";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(100,200-44,150,36,GUIObjectButton,_("OK"));
	obj->name="cfgAddOK";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	obj=new GUIObject(350,200-44,150,36,GUIObjectButton,_("Cancel"));
	obj->name="cfgAddCancel";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//Dim the screen using the tempSurface.
	SDL_FillRect(tempSurface,NULL,0);
	SDL_SetAlpha(tempSurface,SDL_SRCALPHA,155);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	while(GUIObjectRoot){
	while(SDL_PollEvent(&event)) GUIObjectHandleEvents(true);
	if(GUIObjectRoot) GUIObjectRoot->render();
	flipScreen();
	SDL_Delay(30);
	}

	//We're done so set the original GUIObjectRoot back.
	GUIObjectRoot=levelEditGUIObjectRoot;
	}

	void LevelEditSelect::moveLevel(){
	//Open a message popup.

	//NOTE: We can always point GUIObjectRoot to the main gui by using levelEditGUIObjectRoot.
	GUIObjectRoot=new GUIObject((SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,GUIObjectFrame,_("Move level"));
	GUIObject* obj;

	obj=new GUIObject(40,80,240,36,GUIObjectLabel,_("Level: "));
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(300,80,240,36,GUIObjectTextBox,"1");
	obj->name=_("MoveLevel");
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUISingleLineListBox(40,120,240,36);
	obj->name="lstPlacement";
	vector<string> v;
	v.push_back(_("Before"));
	v.push_back(_("After"));
	v.push_back(_("Swap"));
	(dynamic_cast<GUISingleLineListBox*>(obj))->item=v;
	obj->value=0;
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(100,200-44,150,36,GUIObjectButton,_("OK"));
	obj->name="cfgMoveOK";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	obj=new GUIObject(350,200-44,150,36,GUIObjectButton,_("Cancel"));
	obj->name="cfgMoveCancel";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//Dim the screen using the tempSurface.
	SDL_FillRect(tempSurface,NULL,0);
	SDL_SetAlpha(tempSurface,SDL_SRCALPHA,155);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	while(GUIObjectRoot){
	while(SDL_PollEvent(&event)) GUIObjectHandleEvents(true);
	if(GUIObjectRoot) GUIObjectRoot->render();
	flipScreen();
	SDL_Delay(30);
	}

	//We're done so set the original GUIObjectRoot back.
	GUIObjectRoot=levelEditGUIObjectRoot;
	}
	void LevelEditSelect::refresh(){
	int m=levels->getLevelCount();
	numbers.clear();

	//clear the selected level
	if(selectedNumber!=NULL){
	selectedNumber=NULL;
	}

	//Disable the level specific buttons.
	move->enabled=false;
	remove->enabled=false;
	edit->enabled=false;

	for(int n=0;n<=m;n++){
	numbers.push_back(Number());
	}

	for(int n=0;n<m;n++){
	SDL_Rect box={(n%LEVELS_PER_ROW)64+80,(n/LEVELS_PER_ROW)64+184,0,0};
	numbers[n].init(n,box);
	}
	SDL_Rect box={(m%LEVELS_PER_ROW)64+80,(m/LEVELS_PER_ROW)64+184,0,0};
	numbers[m].init("+",box);

	m++; //including the "+" button
	if(m>LEVELS_DISPLAYED_IN_SCREEN){
	levelScrollBar->maxValue=(m-LEVELS_DISPLAYED_IN_SCREEN+LEVELS_PER_ROW-1)/LEVELS_PER_ROW;
	levelScrollBar->visible=true;
	}else{
	levelScrollBar->maxValue=0;
	levelScrollBar->visible=false;
	}
	if(!levels->levelpackDescription.empty()){
	levelpackDescription->caption=_C(levels->getDictionaryManager(),levels->levelpackDescription);
	int width,height;
	TTF_SizeText(fontText,_C(levels->getDictionaryManager(),levels->levelpackDescription),&width,&height);
	levelpackDescription->left=(SCREEN_WIDTH-width)/2;
	}else{
	levelpackDescription->caption="";
	}
	}

	void LevelEditSelect::selectNumber(unsigned int number,bool selected){
	if(selected){
	levels->setCurrentLevel(number);
	setNextState(STATE_LEVEL_EDITOR);

	//Pick music from the current music list.
	getMusicManager()->pickMusic();
	}else{
	if(number==numbers.size()-1){
	addLevel();
	}else if(number>=0 && number<numbers.size()){
	selectedNumber=&numbers[number];

	//Enable the level specific buttons.
	//NOTE: We check if 'remove levelpack' is enabled, if not then it's the Levels levelpack.
	if(removePack->enabled)
	move->enabled=true;
	remove->enabled=true;
	edit->enabled=true;
	}
	}
	}

	void LevelEditSelect::render(){
	//Let the levelselect render.
	LevelSelect::render();
	}

	void LevelEditSelect::renderTooltip(unsigned int number,int dy){
	SDL_Color fg={0,0,0};
	SDL_Surface* name;

	if(number==(unsigned)levels->getLevelCount()){
	//Render the name of the level.
	name=TTF_RenderUTF8_Blended(fontText,_("Add level"),fg);
	}else{
	//Render the name of the level.
	name=TTF_RenderUTF8_Blended(fontText,_C(levels->getDictionaryManager(),levels->getLevelName(number)),fg);
	}

	//Check if name isn't null.
	if(name==NULL)
	return;

	//Now draw a square the size of the three texts combined.
	SDL_Rect r=numbers[number].box;
	r.y-=dy*64;
	r.w=name->w;
	r.h=name->h;

	//Make sure the tooltip doesn't go outside the window.
	if(r.y>SCREEN_HEIGHT-200){
	r.y-=name->h+4;
	}else{
	r.y+=numbers[number].box.h+2;
	}
	if(r.x+r.w>SCREEN_WIDTH-50)
	r.x=SCREEN_WIDTH-50-r.w;

	//Draw a rectange
	Uint32 color=0xFFFFFF00\|240;
	drawGUIBox(r.x-5,r.y-5,r.w+10,r.h+10,screen,color);

	//Calc the position to draw.
	SDL_Rect r2=r;

	//Now we render the name if the surface isn't null.
	if(name!=NULL){
	//Draw the name.
	SDL_BlitSurface(name,NULL,screen,&r2);
	}

	//And free the surfaces.
	SDL_FreeSurface(name);
	}

	void LevelEditSelect::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	//NOTE: We check for the levelpack change to enable/disable some levelpack buttons.
	if(name=="cmdLvlPack"){
	//We call changepack and return to prevent the LevelSelect to undo what we did.
	changePack();
	refresh();
	return;
	}

	//Let the level select handle his GUI events.
	LevelSelect::GUIEventCallback_OnEvent(name,obj,eventType);

	//Check for the edit button.
	if(name=="cmdNewLvlpack"){
	//Clear the current pack name.
	packName.clear();
	LevelPack* levelpack=new LevelPack;
	levels=levelpack;

	//Create a new pack.
	packProperties();
	}else if(name=="cmdLvlpackProp"){
	//Show the pack properties.
	packProperties();
	}else if(name=="cmdRmLvlpack"){
	//Show an "are you sure" message.
	if(msgBox(_("Are you sure?"),MsgBoxYesNo,_("Remove prompt"))==MsgBoxYes){
	//Remove the directory.
	if(!removeDirectory(levels->levelpackPath.c_str())){
	cerr<<"ERROR: Unable to remove levelpack directory "<<levels->levelpackPath<<endl;
	}

	//Remove it from the vector (levelpack list).
	vector<string>::iterator it;
	it=find(levelpacks->item.begin(),levelpacks->item.end(),packName);
	if(it!=levelpacks->item.end()){
	levelpacks->item.erase(it);
	}

	//Remove it from the levelpackManager.
	getLevelPackManager()->removeLevelPack(packName);

	//And call changePack.
	levelpacks->value=levelpacks->item.size()-1;
	changePack();
	refresh();
	}
	}else if(name=="cmdMoveMap"){
	if(selectedNumber!=NULL){
	moveLevel();
	}
	}else if(name=="cmdRmMap"){
	if(selectedNumber!=NULL){
	if(packName!="Custom Levels"){
	if(!removeFile((levels->levelpackPath+"/"+levels->getLevel(selectedNumber->getNumber())->file).c_str())){
	cerr<<"ERROR: Unable to remove level "<<(levels->levelpackPath+"/"+levels->getLevel(selectedNumber->getNumber())->file).c_str()<<endl;
	}
	levels->removeLevel(selectedNumber->getNumber());
	levels->saveLevels(levels->levelpackPath+"/levels.lst");
	}else{
	//This is the levels levelpack so we just remove the file.
	if(!removeFile(levels->getLevel(selectedNumber->getNumber())->file.c_str())){
	cerr<<"ERROR: Unable to remove level "<<levels->getLevel(selectedNumber->getNumber())->file<<endl;
	}
	levels->removeLevel(selectedNumber->getNumber());
	}

	//And refresh the selection screen.
	refresh();
	}
	}else if(name=="cmdEdit"){
	if(selectedNumber!=NULL){
	levels->setCurrentLevel(selectedNumber->getNumber());
	setNextState(STATE_LEVEL_EDITOR);

	//Pick music from the current music list.
	getMusicManager()->pickMusic();
	}
	}

	//Check for levelpack properties events.
	if(name=="cfgOK"){
	//Now loop throught the children of the GUIObjectRoot in search of the fields.
	for(unsigned int i=0;i<GUIObjectRoot->childControls.size();i++){
	if(GUIObjectRoot->childControls[i]->name=="LvlpackName"){
	//Check if the name changed.
	if(packName!=GUIObjectRoot->childControls[i]->caption){
	//Delete the old one.
	if(!packName.empty()){
	if(!renameDirectory((getUserPath(USER_DATA)+"custom/levelpacks/"+packName).c_str(),(getUserPath(USER_DATA)+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption).c_str())){
	cerr<<"ERROR: Unable to move levelpack directory "<<(getUserPath(USER_DATA)+"custom/levelpacks/"+packName)<<" to "<<(getUserPath(USER_DATA)+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption)<<endl;
	}

	//Remove the old one from the levelpack manager.
	getLevelPackManager()->removeLevelPack(packName);

	//And the levelpack list.
	vector<string>::iterator it1;
	it1=find(levelpacks->item.begin(),levelpacks->item.end(),packName);
	if(it1!=levelpacks->item.end()){
	levelpacks->item.erase(it1);
	if((unsigned)levelpacks->value>levelpacks->item.size())
	levelpacks->value=levelpacks->item.size()-1;
	}
	}else{
	if(!createDirectory((getUserPath(USER_DATA)+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption).c_str())){
	cerr<<"ERROR: Unable to create levelpack directory "<<(getUserPath(USER_DATA)+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption)<<endl;
	}
	if(!createFile((getUserPath(USER_DATA)+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption+"/levels.lst").c_str())){
	cerr<<"ERROR: Unable to create levelpack file "<<(getUserPath(USER_DATA)+"custom/levelpacks/"+GUIObjectRoot->childControls[i]->caption+"/levels.lst")<<endl;
	}
	}
	//And set the new name.
	packName=GUIObjectRoot->childControls[i]->caption;
	levels->levelpackName=packName;
	levels->levelpackPath=(getUserPath(USER_DATA)+"custom/levelpacks/"+packName+"/");

	//Also add the levelpack location
	getLevelPackManager()->addLevelPack(levels);
	levelpacks->item.push_back(GUIObjectRoot->childControls[i]->caption);
	levelpacks->value=levelpacks->item.size()-1;

	//And call changePack.
	changePack();
	}
	}
	if(GUIObjectRoot->childControls[i]->name=="LvlpackDescription"){
	levels->levelpackDescription=GUIObjectRoot->childControls[i]->caption;
	}
	if(GUIObjectRoot->childControls[i]->name=="LvlpackCongratulation"){
	levels->congratulationText=GUIObjectRoot->childControls[i]->caption;
	}
	}
	//Refresh the leveleditselect to show the correct information.
	refresh();

	//Save the configuration.
	levels->saveLevels(getUserPath(USER_DATA)+"custom/levelpacks/"+packName+"/levels.lst");
	getSettings()->setValue("lastlevelpack",packName);

	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}else if(name=="cfgCancel"){
	//Check if packName is empty, if so it was a new levelpack and we need to revert to an existing one.
	if(packName.empty()){
	packName=levelpacks->item[levelpacks->value];
	changePack();
	}

	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}

	//Check for add level events.
	if(name=="cfgAddOK"){
	//Check if the file name isn't null.
	//Now loop throught the children of the GUIObjectRoot in search of the fields.
	for(unsigned int i=0;i<GUIObjectRoot->childControls.size();i++){
	if(GUIObjectRoot->childControls[i]->name=="LvlFile"){
	if(GUIObjectRoot->childControls[i]->caption.empty()){
	msgBox(_("No file name given for the new level."),MsgBoxOKOnly,_("Missing file name"));
	return;
	}else{
	string tmp_caption = GUIObjectRoot->childControls[i]->caption;

	//Replace all spaces with a underline.
	size_t j;
	for(;(j=tmp_caption.find(" "))!=string::npos;){
	tmp_caption.replace(j,1,"_");
	}

	//If there isn't ".map" extension add it.
	size_t found=tmp_caption.find_first_of(".");
	if(found!=string::npos)
	tmp_caption.replace(tmp_caption.begin()+found+1,tmp_caption.end(),"map");
	else if (tmp_caption.substr(found+1)!="map")
	tmp_caption.append(".map");

	/* Create path and file in it */
	string path=(levels->levelpackPath+"/"+tmp_caption);
	if(packName=="Custom Levels"){
	path=(getUserPath(USER_DATA)+"/custom/levels/"+tmp_caption);
	}

	//First check if the file doesn't exist already.
	FILE* f;
	f=fopen(path.c_str(),"rb");

	//Check if it exists.
	if(f){
	//Close the file.
	fclose(f);

	//Let the currentState render once to prevent multiple GUI overlapping and prevent the screen from going black.
	currentState->render();
	levelEditGUIObjectRoot->render();

	//Notify the user.
	msgBox(("The file "+tmp_caption+" already exists.").c_str(),MsgBoxOKOnly,"Error");
	return;
	}

	if(!createFile(path.c_str())){
	cerr<<"ERROR: Unable to create level file "<<path<<endl;
	}
	levels->addLevel(path);
	if(packName!="Custom Levels")
	levels->saveLevels(getUserPath(USER_DATA)+"custom/levelpacks/"+packName+"/levels.lst");
	refresh();

	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	return;
	}
	}
	}
	}
	}else if(name=="cfgAddCancel"){
	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}

	//Check for move level events.
	if(name=="cfgMoveOK"){
	//Check if the entered level number is valid.
	//Now loop throught the children of the GUIObjectRoot in search of the fields.
	int level=0;
	int placement=0;
	for(unsigned int i=0;i<GUIObjectRoot->childControls.size();i++){
	if(GUIObjectRoot->childControls[i]->name=="MoveLevel"){
	level=atoi(GUIObjectRoot->childControls[i]->caption.c_str());
	if(level<=0 \|\| level>levels->getLevelCount()){
	msgBox(_("The entered level number isn't valid!"),MsgBoxOKOnly,_("Illegal number"));
	return;
	}
	}
	if(GUIObjectRoot->childControls[i]->name=="lstPlacement"){
	placement=GUIObjectRoot->childControls[i]->value;
	}
	}

	//Now we execute the swap/move.
	//Check for the place before.
	if(placement==0){
	//We place the selected level before the entered level.
	levels->moveLevel(selectedNumber->getNumber(),level-1);
	}else if(placement==1){
	//We place the selected level after the entered level.
	if(level<selectedNumber->getNumber())
	levels->moveLevel(selectedNumber->getNumber(),level);
	else
	levels->moveLevel(selectedNumber->getNumber(),level+1);
	}else if(placement==2){
	//We swap the selected level with the entered level.
	levels->swapLevel(selectedNumber->getNumber(),level-1);
	}

	//And save the change.
	if(packName!="Custom Levels")
	levels->saveLevels(getUserPath(USER_DATA)+"custom/levelpacks/"+packName+"/levels.lst");

	refresh();

	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}else if(name=="cfgMoveCancel"){
	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	}
	diff --git a/src/TitleMenu.cpp b/src/TitleMenu.cpp
	index 175dcb6..dc774d7 100644
	--- a/src/TitleMenu.cpp
	+++ b/src/TitleMenu.cpp
	@@ -1,623 +1,623 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#include "Functions.h"
	#include "GameState.h"
	#include "Globals.h"
	#include "TitleMenu.h"
	#include "GUIListBox.h"
	#include "InputManager.h"
	#include <iostream>
	#include <algorithm>
	#include <sstream>

	#include "libs/tinygettext/tinygettext.hpp"

	using namespace std;

	/////////////////////////MAIN_MENU//////////////////////////////////

	//Integer containing the highlighted/selected menu option.
	static int highlight=0;

	Menu::Menu(){
	highlight=0;
	animation=0;

	//Load the title image.
	title=loadImage(getDataPath()+"gfx/menu/title.png");

	//Now render the five entries.
	SDL_Color black={0,0,0};
	entries[0]=TTF_RenderUTF8_Blended(fontTitle,_("Play"),black);
	entries[1]=TTF_RenderUTF8_Blended(fontTitle,_("Options"),black);
	entries[2]=TTF_RenderUTF8_Blended(fontTitle,_("Map Editor"),black);
	entries[3]=TTF_RenderUTF8_Blended(fontTitle,_("Addons"),black);
	entries[4]=TTF_RenderUTF8_Blended(fontTitle,_("Exit"),black);
	entries[5]=TTF_RenderUTF8_Blended(fontTitle,">",black);
	entries[6]=TTF_RenderUTF8_Blended(fontTitle,"<",black);
	}

	Menu::~Menu(){
	//We need to free the five text surfaceses.
	for(unsigned int i=0;i<7;i++)
	SDL_FreeSurface(entries[i]);
	}


	void Menu::handleEvents(){
	//Get the x and y location of the mouse.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Calculate which option is highlighted using the location of the mouse.
	//Only if mouse is 'doing something'
	if(event.type==SDL_MOUSEMOTION \|\| event.type==SDL_MOUSEBUTTONDOWN){
	if(x>=200&&x<SCREEN_WIDTH-200&&y>=(SCREEN_HEIGHT-200)/2&&y<(SCREEN_HEIGHT-200)/2+320){
	highlight=(y-((SCREEN_HEIGHT-200)/2-64))/64;
	}
	}

	//Down/Up -arrows move highlight
	if(inputMgr.isKeyDownEvent(INPUTMGR_DOWN)){
	highlight++;
	if(highlight>=6)
	highlight=5;
	}
	if(inputMgr.isKeyDownEvent(INPUTMGR_UP)){
	highlight--;
	if(highlight<1)
	highlight=1;
	}

	//Check if there's a press event.
	if((event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT) \|\|
	(inputMgr.isKeyUpEvent(INPUTMGR_SELECT))){
	//We have one so check which selected/highlighted option needs to be done.
	switch(highlight){
	case 1:
	//Enter the levelSelect state.
	setNextState(STATE_LEVEL_SELECT);
	break;
	case 2:
	//Enter the options state.
	setNextState(STATE_OPTIONS);
	break;
	case 3:
	//Enter the levelEditor, but first set the level to a default leveledit map.
	levelName="";
	setNextState(STATE_LEVEL_EDIT_SELECT);
	break;
	case 4:
	//Check if internet is enabled.
	if(!getSettings()->getBoolValue("internet")){
	msgBox(_("Enable internet in order to install addons."),MsgBoxOKOnly,_("Internet disabled"));
	break;
	}

	//Enter the help state.
	setNextState(STATE_ADDONS);
	break;
	case 5:
	//We quit, so we enter the exit state.
	setNextState(STATE_EXIT);
	break;
	}
	}

	//We also need to quit the menu when escape is pressed.
	if(inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE)){
	setNextState(STATE_EXIT);
	}

	//Check if we need to quit, if so we enter the exit state.
	if(event.type==SDL_QUIT){
	setNextState(STATE_EXIT);
	}
	}

	//Nothing to do here
	void Menu::logic(){
	animation++;
	if(animation>10)
	animation=-10;
	}


	void Menu::render(){
	applySurface(0,0,menuBackground,screen,NULL);

	//Draw the title.
	applySurface((SCREEN_WIDTH-title->w)/2,40,title,screen,NULL);

	//Draw the menu entries.
	for(unsigned int i=0;i<5;i++){
	applySurface((SCREEN_WIDTH-entries[i]->w)/2,(SCREEN_HEIGHT-200)/2+64*i+(64-entries[i]->h)/2,entries[i],screen,NULL);
	}

	//Check if an option is selected/highlighted.
	if(highlight>0){
	//Draw the '>' sign, which is entry 5.
	int x=(SCREEN_WIDTH-entries[highlight-1]->w)/2-(25-abs(animation)/2)-entries[5]->w;
	int y=(SCREEN_HEIGHT-200)/2-64+64*highlight+(64-entries[5]->h)/2;
	applySurface(x,y,entries[5],screen,NULL);

	//Draw the '<' sign, which is entry 6.
	x=(SCREEN_WIDTH-entries[highlight-1]->w)/2+entries[highlight-1]->w+(25-abs(animation)/2);
	y=(SCREEN_HEIGHT-200)/2-64+64*highlight+(64-entries[6]->h)/2;
	applySurface(x,y,entries[6],screen,NULL);
	}
	}


	/////////////////////////OPTIONS_MENU//////////////////////////////////

	//Some varables for the options.
	static bool fullscreen,leveltheme,internet;
	static string themeName,languageName;
	static int lastLang,lastRes;

	static bool useProxy;
	static string internetProxy;

	static bool restartFlag;

	static _res currentRes;
	static vector<_res> resolution_list;

	Options::Options(){
	//Render the title.
	SDL_Color black={0,0,0};
	title=TTF_RenderUTF8_Blended(fontTitle,_("Settings"),black);

	//Load the jump sound, used for sound volume configuration.
	jumpSound=Mix_LoadWAV((getDataPath()+"sfx/jump.wav").c_str());
	lastJumpSound=0;

	//Set some default settings.
	fullscreen=getSettings()->getBoolValue("fullscreen");
	languageName=getSettings()->getValue("lang");
	themeName=processFileName(getSettings()->getValue("theme"));
	leveltheme=getSettings()->getBoolValue("leveltheme");
	internet=getSettings()->getBoolValue("internet");
	internetProxy=getSettings()->getValue("internet-proxy");
	useProxy=!internetProxy.empty();

	//Set the restartFlag false.
	restartFlag=false;

	//Variables for positioning
	int x = (SCREEN_WIDTH-540)/2;
	int liftY=40; //TODO: This is variable for laziness of maths...

	//Create the root element of the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	GUIObjectRoot=new GUIObject(0,0,SCREEN_WIDTH,SCREEN_HEIGHT,GUIObjectNone);

	//Now we create GUIObjects for every option.
	GUIObject* obj=new GUIObject(x,150-liftY,240,36,GUIObjectLabel,_("Music"));
	GUIObjectRoot->childControls.push_back(obj);

	musicSlider=new GUISlider(x+220,150-liftY,256,36,atoi(getSettings()->getValue("music").c_str()),0,128,15);
	musicSlider->name="sldMusic";
	musicSlider->eventCallback=this;
	GUIObjectRoot->childControls.push_back(musicSlider);

	obj=new GUIObject(x,190-liftY,240,36,GUIObjectLabel,_("Sound"));
	GUIObjectRoot->childControls.push_back(obj);

	soundSlider=new GUISlider(x+220,190-liftY,256,36,atoi(getSettings()->getValue("sound").c_str()),0,128,15);
	soundSlider->name="sldSound";
	soundSlider->eventCallback=this;
	GUIObjectRoot->childControls.push_back(soundSlider);

	obj=new GUIObject(x,230-liftY,240,36,GUIObjectCheckBox,_("Fullscreen"),fullscreen?1:0);
	obj->name="chkFullscreen";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(x,270-liftY,240,36,GUIObjectLabel,_("Resolution"));
	obj->name="lstResolution";
	GUIObjectRoot->childControls.push_back(obj);

	//Create list with many different resolutions
	resolutions = new GUISingleLineListBox(x+220,270-liftY,300,36);
	resolutions->value=-1;

	//Enumerate avaliable resolutions using SDL_ListModes()
	//Note: we enumerate fullscreen resolutions because
	// windowed resolutions always can be arbitrary
	if(resolution_list.empty()){
	SDL_Rect **modes=SDL_ListModes(NULL, SDL_FULLSCREEN\|SDL_HWSURFACE);

	if(modes==NULL \|\| ((intptr_t)modes) == -1){
	cout<<"Error: Can't enumerate avaliable screen resolutions."
	" Use predefined screen resolutions list instead."<<endl;

	static const _res predefined_resolution_list[] = {
	{800,600},
	{1024,600},
	{1024,768},
	{1152,864},
	{1280,720},
	{1280,768},
	{1280,800},
	{1280,960},
	{1280,1024},
	{1360,768},
	{1366,768},
	{1440,900},
	{1600,900},
	{1600,1200},
	{1680,1080},
	{1920,1080},
	{1920,1200},
	{2560,1440},
	{3840,2160}
	};

	for(unsigned int i=0;i<sizeof(predefined_resolution_list)/sizeof(_res);i++){
	resolution_list.push_back(predefined_resolution_list[i]);
	}
	}else{
	for(unsigned int i=0;modes[i]!=NULL;i++){
	//Check if the resolution is big enough
	if(modes[i]->w>=800 && modes[i]->h>=600){
	_res res={modes[i]->w, modes[i]->h};
	resolution_list.push_back(res);
	}
	}
	}
	}

	//Get current resolution from config file. Thus it can be user defined
	currentRes.w=atoi(getSettings()->getValue("width").c_str());
	currentRes.h=atoi(getSettings()->getValue("height").c_str());

	for (int i=0; i<(int)resolution_list.size();i++){
	//Create a string from width and height and then add it to list
	ostringstream out;
	out << resolution_list[i].w << "x" << resolution_list[i].h;
	resolutions->item.push_back(out.str());

	//Check if current resolution matches, select it
	if (resolution_list[i].w==currentRes.w && resolution_list[i].h==currentRes.h){
	resolutions->value=i;
	}
	}

	//Add current resolution if it isn't already in the list
	if(resolutions->value==-1){
	ostringstream out;
	out << currentRes.w << "x" << currentRes.h;
	resolutions->item.push_back(out.str());
	resolutions->value=resolutions->item.size()-1;
	}
	lastRes=resolutions->value;

	GUIObjectRoot->childControls.push_back(resolutions);

	obj=new GUIObject(x,310-liftY,240,36,GUIObjectLabel,_("Language"));
	obj->name="lstResolution";
	GUIObjectRoot->childControls.push_back(obj);

	//Create GUI list with available languages
	langs = new GUISingleLineListBox(x+220,310-liftY,300,36);
	langs->name="lstLanguages";

	/// TRANSLATORS: as detect user's language automatically
	langs->item.push_back(_("Auto-Detect"));
	langValues.push_back("");

	langs->item.push_back("English");
	langValues.push_back("en");

	//Get a list of every available language
	set<tinygettext::Language> languages = dictionaryManager->get_languages();
	for (set<tinygettext::Language>::iterator s0 = languages.begin(); s0 != languages.end(); ++s0){
	//If language in loop is the same in config file, then select it
	if (getSettings()->getValue("lang")==s0->str()){
	lastLang=distance(languages.begin(),s0)+2;
	}
	//Add language in loop to list and listbox
	langs->item.push_back(s0->get_name());
	langValues.push_back(s0->str());
	}

	//If Auto or English are selected
	if(getSettings()->getValue("lang")==""){
	lastLang=0;
	}else if(getSettings()->getValue("lang")=="en"){
	lastLang=1;
	}

	langs->value=lastLang;
	GUIObjectRoot->childControls.push_back(langs);

	obj=new GUIObject(x,350-liftY,240,36,GUIObjectLabel,_("Theme"));
	obj->name="theme";
	GUIObjectRoot->childControls.push_back(obj);

	//Create the theme option gui element.
	theme=new GUISingleLineListBox(x+220,350-liftY,300,36);
	theme->name="lstTheme";
	vector<string> v=enumAllDirs(getUserPath(USER_DATA)+"themes/");
	for(vector<string>::iterator i = v.begin(); i != v.end(); ++i){
	themeLocations[i]=getUserPath(USER_DATA)+"themes/"+i;
	}
	vector<string> v2=enumAllDirs(getDataPath()+"themes/");
	for(vector<string>::iterator i = v2.begin(); i != v2.end(); ++i){
	themeLocations[i]=getDataPath()+"themes/"+i;
	}
	v.insert(v.end(), v2.begin(), v2.end());

	//Try to find the configured theme so we can display it.
	int value=-1;
	for(vector<string>::iterator i = v.begin(); i != v.end(); ++i){
	if(themeLocations[*i]==themeName) {
	value=i-v.begin();
	}
	}
	theme->item=v;
	if(value==-1)
	value=theme->item.size()-1;
	theme->value=value;
	//NOTE: We call the event handling method to correctly set the themename.
	GUIEventCallback_OnEvent("lstTheme",theme,GUIEventChange);
	theme->eventCallback=this;
	GUIObjectRoot->childControls.push_back(theme);

	obj=new GUIObject(x,390-liftY,240,36,GUIObjectCheckBox,_("Level themes"),leveltheme?1:0);
	obj->name="chkLeveltheme";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(x,430-liftY,240,36,GUIObjectCheckBox,_("Internet"),internet?1:0);
	obj->name="chkInternet";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//new: proxy settings
	obj=new GUIObject(x,470-liftY,240,36,GUIObjectLabel,_("Internet proxy"));
	obj->name="chkProxy";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	obj=new GUIObject(x+220,470-liftY,300,36,GUIObjectTextBox,internetProxy.c_str());
	obj->name="txtProxy";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//new: key settings
	- obj=new GUIObject(SCREEN_WIDTH*0.3,SCREEN_HEIGHT-120,-1,36,GUIObjectButton,_("Config Keys"),GUIGravityCenter);
	+ obj=new GUIObject(SCREEN_WIDTH*0.3,SCREEN_HEIGHT-120,-1,36,GUIObjectButton,_("Config Keys"),0,true,true,GUIGravityCenter);
	obj->name="cmdKeys";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//Reset progress settings.
	/// TRANSLATORS: Used for button which clear any level progress like unlocked levels and highscores.
	- obj=new GUIObject(SCREEN_WIDTH*0.7,SCREEN_HEIGHT-120,-1,36,GUIObjectButton,_("Clear Progress"),GUIGravityCenter);
	+ obj=new GUIObject(SCREEN_WIDTH*0.7,SCREEN_HEIGHT-120,-1,36,GUIObjectButton,_("Clear Progress"),0,true,true,GUIGravityCenter);
	obj->name="cmdReset";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	- obj=new GUIObject(SCREEN_WIDTH*0.3,SCREEN_HEIGHT-60,-1,36,GUIObjectButton,_("Cancel"),GUIGravityCenter);
	+ obj=new GUIObject(SCREEN_WIDTH*0.3,SCREEN_HEIGHT-60,-1,36,GUIObjectButton,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	- obj=new GUIObject(SCREEN_WIDTH*0.7,SCREEN_HEIGHT-60,-1,36,GUIObjectButton,_("Save Changes"),GUIGravityCenter);
	+ obj=new GUIObject(SCREEN_WIDTH*0.7,SCREEN_HEIGHT-60,-1,36,GUIObjectButton,_("Save Changes"),0,true,true,GUIGravityCenter);
	obj->name="cmdSave";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	}

	Options::~Options(){
	//Delete the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//Free the title image.
	SDL_FreeSurface(title);
	//And free the jump sound.
	Mix_FreeChunk(jumpSound);
	}

	static string convertInt(int i){
	stringstream ss;
	ss << i;
	return ss.str();
	}

	void Options::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	//Check what type of event it was.
	if(eventType==GUIEventClick){
	if(name=="cmdBack"){
	//TODO: Reset the key changes.

	//Reset the music volume.
	getMusicManager()->setVolume(atoi(getSettings()->getValue("music").c_str()));
	Mix_Volume(-1,atoi(getSettings()->getValue("sound").c_str()));

	//And goto the main menu.
	setNextState(STATE_MENU);
	}else if(name=="cmdSave"){
	//Save is pressed thus save
	char s[64];
	sprintf(s,"%d",soundSlider->value);
	getSettings()->setValue("sound",s);
	sprintf(s,"%d",musicSlider->value);
	getSettings()->setValue("music",s);
	getMusicManager()->setEnabled(musicSlider->value>0);
	Mix_Volume(-1,soundSlider->value);
	getSettings()->setValue("fullscreen",fullscreen?"1":"0");
	getSettings()->setValue("leveltheme",leveltheme?"1":"0");
	getSettings()->setValue("internet",internet?"1":"0");
	getSettings()->setValue("theme",themeName);
	if(!useProxy)
	internetProxy.clear();
	getSettings()->setValue("internet-proxy",internetProxy);

	getSettings()->setValue("lang",langValues.at(langs->value));

	//Is resolution from the list or is it user defined in config file
	if(resolutions->value<(int)resolution_list.size()){
	getSettings()->setValue("width",convertInt(resolution_list[resolutions->value].w));
	getSettings()->setValue("height",convertInt(resolution_list[resolutions->value].h));
	}else{
	getSettings()->setValue("width",convertInt(currentRes.w));
	getSettings()->setValue("height",convertInt(currentRes.h));
	}

	//Save the key configuration.
	inputMgr.saveConfig();

	//Save the settings.
	saveSettings();

	//Before we return check if some .
	if(restartFlag \|\| resolutions->value!=lastRes){
	//The resolution changed so we need to recreate the screen.
	if(!createScreen()){
	//Screen creation failed so set to safe settings.
	getSettings()->setValue("fullscreen","0");
	getSettings()->setValue("width",convertInt(resolution_list[lastRes].w));
	getSettings()->setValue("height",convertInt(resolution_list[lastRes].h));

	if(!createScreen()){
	//Everything fails so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}

	//The screen is created, now load the (menu) theme.
	if(!loadTheme()){
	//Loading the theme failed so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}
	if(langs->value!=lastLang){
	//We set the language.
	language=langValues.at(langs->value);
	dictionaryManager->set_language(tinygettext::Language::from_name(langValues.at(langs->value)));

	//And reload the fonts (in some cases not needed).
	if(!loadFonts()){
	//Loading failed so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}

	//Now return to the main menu.
	setNextState(STATE_MENU);
	}else if(name=="cmdKeys"){
	inputMgr.showConfig();
	}else if(name=="cmdReset"){
	if(msgBox(_("Do you really want to reset level progress?"),MsgBoxYesNo,_("Warning"))==MsgBoxYes){
	//We delete the progress folder.
	#ifdef WIN32
	removeDirectory((getUserPath()+"progress").c_str());
	createDirectory((getUserPath()+"progress").c_str());
	#else
	removeDirectory((getUserPath(USER_DATA)+"/progress").c_str());
	createDirectory((getUserPath(USER_DATA)+"/progress").c_str());
	#endif
	}
	return;
	}else if(name=="chkFullscreen"){
	fullscreen=obj->value?true:false;

	//Check if fullscreen changed.
	if(fullscreen==getSettings()->getBoolValue("fullscreen")){
	//We disable the restart message flag.
	restartFlag=false;
	}else{
	//We set the restart message flag.
	restartFlag=true;
	}

	}else if(name=="chkLeveltheme"){
	leveltheme=obj->value?true:false;
	}else if(name=="chkInternet"){
	internet=obj->value?true:false;
	}else if(name=="chkProxy"){
	useProxy=obj->value?true:false;
	}
	}
	if(name=="lstTheme"){
	if(theme!=NULL && theme->value>=0 && theme->value<(int)theme->item.size()){
	//Check if the theme is installed in the data path.
	if(themeLocations[theme->item[theme->value]].find(getDataPath())!=string::npos){
	themeName="%DATA%/themes/"+fileNameFromPath(themeLocations[theme->item[theme->value]]);
	}else if(themeLocations[theme->item[theme->value]].find(getUserPath(USER_DATA))!=string::npos){
	themeName="%USER%/themes/"+fileNameFromPath(themeLocations[theme->item[theme->value]]);
	}else{
	themeName=themeLocations[theme->item[theme->value]];
	}
	}
	}else if(name=="txtProxy"){
	internetProxy=obj->caption;

	//Check if the internetProxy field is empty.
	useProxy=!internetProxy.empty();
	}else if(name=="sldMusic"){
	getMusicManager()->setEnabled(musicSlider->value>0);
	getMusicManager()->setVolume(musicSlider->value);
	}else if(name=="sldSound"){
	Mix_Volume(-1,soundSlider->value);
	if(lastJumpSound==0){
	Mix_PlayChannel(-1,jumpSound,0);
	lastJumpSound=15;
	}
	}
	}

	void Options::handleEvents(){
	//Check if we need to quit, if so enter the exit state.
	if(event.type==SDL_QUIT){
	setNextState(STATE_EXIT);
	}

	//Check if the escape button is pressed, if so go back to the main menu.
	if(inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE)){
	setNextState(STATE_MENU);
	}
	}

	void Options::logic(){
	//Increase the lastJumpSound variable if needed.
	if(lastJumpSound!=0){
	lastJumpSound--;
	}
	}

	void Options::render(){
	//Render the menu background image.
	applySurface(0,0,menuBackground,screen,NULL);
	//Now render the title.
	applySurface((SCREEN_WIDTH-title->w)/2,40,title,screen,NULL);

	//NOTE: The rendering of the GUI is done in Main.
	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jun 16, 12:25 AM (2 w, 1 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 71111
Default Alt Text: (108 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions